cgma
Classes | Public Member Functions | Private Types | Private Member Functions | Private Attributes
NCubitFile::CMetaData Class Reference

#include <CubitFileMetaData.hpp>

List of all members.

Classes

struct  SCubitFileMetaDataEntry
struct  SCubitFileMetaDataHeader

Public Member Functions

 CMetaData (UnsignedInt32 xintGrowSizeBy=64)
virtual ~CMetaData ()
UnsignedInt32 GetValue (UnsignedInt32 xintOwner, ConstCharPtr xpachrName, UnsignedInt32 &xintValue)
UnsignedInt32 GetValue (UnsignedInt32 xintOwner, ConstCharPtr xpachrName, ConstCharPtr &xpachrValue)
UnsignedInt32 GetValue (UnsignedInt32 xintOwner, ConstCharPtr xpachrName, double &xdblValue)
UnsignedInt32 GetValue (UnsignedInt32 xintOwner, ConstCharPtr xpachrName, const UnsignedInt32 *&xpaintValue, UnsignedInt32 &xintNumValues)
UnsignedInt32 GetValue (UnsignedInt32 xintOwner, ConstCharPtr xpachrName, const double *&xpadblValue, UnsignedInt32 &xintNumValues)
UnsignedInt32 SetValue (UnsignedInt32 xintOwner, ConstCharPtr xpachrName, UnsignedInt32 xintValue)
UnsignedInt32 SetValue (UnsignedInt32 xintOwner, ConstCharPtr xpachrName, ConstCharPtr xpachrValue)
UnsignedInt32 SetValue (UnsignedInt32 xintOwner, ConstCharPtr xpachrName, double xdblValue)
UnsignedInt32 SetValue (UnsignedInt32 xintOwner, ConstCharPtr xpachrName, const UnsignedInt32 *xpaintValue, UnsignedInt32 xintNumValues)
UnsignedInt32 SetValue (UnsignedInt32 xintOwner, ConstCharPtr xpachrName, const double *xpadblValue, UnsignedInt32 xintNumValues)
UnsignedInt32 ClearMetaDataForID (UnsignedInt32 xintOwner)
UnsignedInt32 GetMetaDataAll (UnsignedInt32 &xintNumFound, const ConstCharPtr *&xpapachrName, const UnsignedInt32 *&xpaintOwner, const UnsignedInt32 *&xpaintValue)
UnsignedInt32 GetMetaDataAll (UnsignedInt32 &xintNumFound, const ConstCharPtr *&xpapachrName, const UnsignedInt32 *&xpaintOwner, const ConstCharPtr *&xpapachrValue)
UnsignedInt32 GetMetaDataAll (UnsignedInt32 &xintNumFound, const ConstCharPtr *&xpapachrName, const UnsignedInt32 *&xpaintOwner, const double *&xpadblValue)
UnsignedInt32 GetMetaDataAll (UnsignedInt32 &xintNumFound, const ConstCharPtr *&xpapachrName, const UnsignedInt32 *&xpaintOwner, const ConstUnsignedInt32Ptr *&xpapaintValue, const UnsignedInt32 *&xpaintNumValues)
UnsignedInt32 GetMetaDataAll (UnsignedInt32 &xintNumFound, const ConstCharPtr *&xpapachrName, const UnsignedInt32 *&xpaintOwner, const ConstDoublePtr *&xpapadblValue, const UnsignedInt32 *&xpaintNumValues)
void WriteMetaData (FILE *xpFile, UnsignedInt32 &xintWroteAtOffset, UnsignedInt32 &xintLength, UnsignedInt32 xintOffsetFrom=0)
void ReadMetaData (FILE *xpFile, UnsignedInt32 xintAbsoluteOffset, UnsignedInt32 xintRelativeOffset, UnsignedInt32 xintSourceEndian)

Private Types

enum  EMetaDataType {
  eUnsignedInt32, eString, eDouble, eUnsignedInt32Array,
  eDoubleArray
}

Private Member Functions

void GrowSize ()
UnsignedInt32 Find (UnsignedInt32 xintOwner, ConstCharPtr xpachrName, UnsignedInt32 &xintIndex)
void FreeAll ()
void FreeAt (UnsignedInt32 xintEntry)
void FreeValueAt (UnsignedInt32 xintEntry)
UnsignedInt32 AddEntry (UnsignedInt32 xintOwner, ConstCharPtr xpachrName)
void RebuildSearchBuff (UnsignedInt32 xintSearchType)
UnsignedInt32 SearchByID (UnsignedInt32 xintSearchType, UnsignedInt32 xintOwner)
UnsignedInt32 SearchByName (UnsignedInt32 xintSearchType, const char *xpachrName)
UnsignedInt32 SearchAll (UnsignedInt32 xintSearchType)

Private Attributes

struct
NCubitFile::CMetaData::SCubitFileMetaDataHeader 		mHeader
struct
NCubitFile::CMetaData::SCubitFileMetaDataEntry * 		mpaEntries
UnsignedInt32 mintBufferSize
UnsignedInt32 mintGrowSizeBy
struct {
   UnsignedInt32   mintNumOwners
   UnsignedInt32 *   mpaintOwners
   UnsignedInt32   mintNumNames
   ConstCharPtr *   mpapachrNames
   UnsignedInt32   mintMetaDataType
   UnsignedInt32   mintNumMetaData
   void *   mpaValues
   UnsignedInt32 *   mpaintNumValues
} mSearchBuff

Detailed Description

Definition at line 41 of file CubitFileMetaData.hpp.

Member Enumeration Documentation

enum NCubitFile::CMetaData::EMetaDataType [private]
Enumerator:
eUnsignedInt32 
eString 
eDouble 
eUnsignedInt32Array 
eDoubleArray 

Definition at line 102 of file CubitFileMetaData.hpp.

                       { eUnsignedInt32, eString, eDouble,
        eUnsignedInt32Array, eDoubleArray };

Constructor & Destructor Documentation

CMetaData::CMetaData ( UnsignedInt32  xintGrowSizeBy = 64)

Definition at line 39 of file CubitFileMetaData.cpp.

{
    mHeader.mintMetaDataSchema = 0;
    mHeader.mintMetaDataCompress = 0;
    mHeader.mintMetaDataCount = 0;

    mintGrowSizeBy = xintGrowSizeBy ? xintGrowSizeBy : 64;
    mintBufferSize = 0;
    mpaEntries = NULL;

    // Initialize the return buffer - allocated structures needed to return
    // the results of meta data queries will be owned and freed by this object.
    mSearchBuff.mintNumOwners = mSearchBuff.mintNumNames =
        mSearchBuff.mintNumMetaData = 0;
    mSearchBuff.mpaintOwners = NULL;
    mSearchBuff.mpapachrNames = NULL;
    mSearchBuff.mintMetaDataType = eUnsignedInt32;
    mSearchBuff.mpaValues = NULL;
    mSearchBuff.mpaintNumValues = NULL;
}
CMetaData::~CMetaData ( ) [virtual]

Definition at line 60 of file CubitFileMetaData.cpp.

{
    // Free the meta data.
    FreeAll();

    // Free the search return buffer.
    if(mSearchBuff.mpaintOwners)
        delete [] mSearchBuff.mpaintOwners;
    if(mSearchBuff.mpapachrNames)
        delete [] mSearchBuff.mpapachrNames;
    if(mSearchBuff.mpaValues) {
        switch(mSearchBuff.mintMetaDataType) {
        case eUnsignedInt32:
            delete [] (UnsignedInt32*)mSearchBuff.mpaValues;
            break;
        case eString:
            delete [] (ConstCharPtr*)mSearchBuff.mpaValues;
            break;
        case eDouble:
            delete [] (double*)mSearchBuff.mpaValues;
            break;
        case eUnsignedInt32Array:
            delete [] (ConstUnsignedInt32Ptr*)mSearchBuff.mpaValues;
            break;
        case eDoubleArray:
            delete [] (ConstDoublePtr*)mSearchBuff.mpaValues;
            break;
        }
    }
    if(mSearchBuff.mpaintNumValues)
        delete [] mSearchBuff.mpaintNumValues;
}

Member Function Documentation

UnsignedInt32 CMetaData::AddEntry ( UnsignedInt32  xintOwner,
ConstCharPtr  xpachrName 
) [private]

Definition at line 124 of file CubitFileMetaData.cpp.

{
    if(mHeader.mintMetaDataCount == mintBufferSize)
        GrowSize();
    mpaEntries[mHeader.mintMetaDataCount].mintMetaDataOwner = xintOwner;
    UnsignedInt32 lintNameLength = std::strlen(xpachrName);
    mpaEntries[mHeader.mintMetaDataCount].mpachrName =
        new char[lintNameLength + 1];
    if(!mpaEntries[mHeader.mintMetaDataCount].mpachrName)
        throw CCubitFile::eMemoryError;
    std::strcpy(mpaEntries[mHeader.mintMetaDataCount].mpachrName, xpachrName);
    return mHeader.mintMetaDataCount++;
}
UnsignedInt32 CMetaData::ClearMetaDataForID ( UnsignedInt32  xintOwner)

Definition at line 792 of file CubitFileMetaData.cpp.

{
    if(mHeader.mintMetaDataCount) {
        for(UnsignedInt32 lintEntry = 0; lintEntry <
            mHeader.mintMetaDataCount; lintEntry++) {
            if(mpaEntries[lintEntry].mintMetaDataOwner == xintOwner)
                FreeAt(lintEntry);
        }
    }
    return CCubitFile::eSuccess;
}
UnsignedInt32 CMetaData::Find ( UnsignedInt32  xintOwner,
ConstCharPtr  xpachrName,
UnsignedInt32 &  xintIndex 
) [private]

Definition at line 141 of file CubitFileMetaData.cpp.

{
    if(!mHeader.mintMetaDataCount)  return 0;  // false, not found
    for(UnsignedInt32 lintEntry = 0; lintEntry <
        mHeader.mintMetaDataCount; lintEntry++) {
        if(mpaEntries[lintEntry].mintMetaDataOwner == xintOwner) {
            if(!std::strcmp(xpachrName, mpaEntries[lintEntry].mpachrName)) {
                xintIndex = lintEntry;
                return 1;  // true, found
            }
        }
    }
    return 0;  // false, not found
}
void CMetaData::FreeAll ( ) [private]

Definition at line 848 of file CubitFileMetaData.cpp.

{
    if(mHeader.mintMetaDataCount) {
        for(UnsignedInt32 lintEntry = 0; lintEntry < mintBufferSize; lintEntry++) {
            if(mpaEntries[lintEntry].mpachrName)
                delete [] mpaEntries[lintEntry].mpachrName;
            FreeValueAt(lintEntry);
        }
        delete [] mpaEntries;
        mHeader.mintMetaDataCount = 0;
        mintBufferSize = 0;
        mpaEntries = NULL;
    }
    mHeader.mintMetaDataSchema = 0;
    mHeader.mintMetaDataCompress = 0;
}
void CMetaData::FreeAt ( UnsignedInt32  xintEntry) [private]

Definition at line 828 of file CubitFileMetaData.cpp.

{
    // Free the allocated memory for an entry.
    delete [] mpaEntries[xintEntry].mpachrName;
    FreeValueAt(xintEntry);
    mHeader.mintMetaDataCount--;

    // Move all entries in the meta-data table ahead of the deleted one down
    // to fill in the gap.
    if(xintEntry < mHeader.mintMetaDataCount) {
        for(UnsignedInt32 lintCopyTo = xintEntry; lintCopyTo <
            mHeader.mintMetaDataCount; lintCopyTo++) {
            memcpy(&mpaEntries[lintCopyTo], &mpaEntries[lintCopyTo + 1],
                sizeof(SCubitFileMetaDataEntry));
        }
    }
}
void CMetaData::FreeValueAt ( UnsignedInt32  xintEntry) [private]

Definition at line 805 of file CubitFileMetaData.cpp.

{
    switch(mpaEntries[xintEntry].mintMetaDataType) {
    case eString:
        if(mpaEntries[xintEntry].muValue.mpachr)
            delete [] mpaEntries[xintEntry].muValue.mpachr;
        mpaEntries[xintEntry].muValue.mpachr = NULL;
        break;
    case eUnsignedInt32Array:
        if(mpaEntries[xintEntry].muValue.mpaint)
            delete [] mpaEntries[xintEntry].muValue.mpaint;
        mpaEntries[xintEntry].muValue.mpaint = NULL;
        break;
    case eDoubleArray:
        if(mpaEntries[xintEntry].muValue.mpadbl)
            delete [] mpaEntries[xintEntry].muValue.mpadbl;
        mpaEntries[xintEntry].muValue.mpadbl = NULL;
        break;
    }
}
UnsignedInt32 CMetaData::GetMetaDataAll ( UnsignedInt32 &  xintNumFound,
const ConstCharPtr *&  xpapachrName,
const UnsignedInt32 *&  xpaintOwner,
const UnsignedInt32 *&  xpaintValue 
)

Definition at line 423 of file CubitFileMetaData.cpp.

{
    xintNumFound = 0;
    xpapachrName = NULL;
    xpaintOwner = NULL;
    xpaintValue = NULL;
    try {  RebuildSearchBuff(eUnsignedInt32);  }
    catch(CCubitFile::EErrorCode xeErrorCode)  {  return xeErrorCode;  }
    catch(...)  {  return CCubitFile::eUnknownError;  }

    if((xintNumFound = SearchAll(eUnsignedInt32)) > 0) {
        xpapachrName = mSearchBuff.mpapachrNames;
        xpaintOwner = mSearchBuff.mpaintOwners;
        xpaintValue = (UnsignedInt32*)mSearchBuff.mpaValues;
    }
    return CCubitFile::eSuccess;
}
UnsignedInt32 CMetaData::GetMetaDataAll ( UnsignedInt32 &  xintNumFound,
const ConstCharPtr *&  xpapachrName,
const UnsignedInt32 *&  xpaintOwner,
const ConstCharPtr *&  xpapachrValue 
)

Definition at line 445 of file CubitFileMetaData.cpp.

{
    xintNumFound = 0;
    xpapachrName = NULL;
    xpaintOwner = NULL;
    xpapachrValue = NULL;
    try {  RebuildSearchBuff(eString);  }
    catch(CCubitFile::EErrorCode xeErrorCode)  {  return xeErrorCode;  }
    catch(...)  {  return CCubitFile::eUnknownError;  }

    if((xintNumFound = SearchAll(eString)) > 0) {
        xpapachrName = mSearchBuff.mpapachrNames;
        xpaintOwner = mSearchBuff.mpaintOwners;
        xpapachrValue = (ConstCharPtr*)mSearchBuff.mpaValues;
    }
    return CCubitFile::eSuccess;
}
UnsignedInt32 CMetaData::GetMetaDataAll ( UnsignedInt32 &  xintNumFound,
const ConstCharPtr *&  xpapachrName,
const UnsignedInt32 *&  xpaintOwner,
const double *&  xpadblValue 
)

Definition at line 467 of file CubitFileMetaData.cpp.

{
    xintNumFound = 0;
    xpapachrName = NULL;
    xpaintOwner = NULL;
    xpadblValue = NULL;
    try {  RebuildSearchBuff(eDouble);  }
    catch(CCubitFile::EErrorCode xeErrorCode)  {  return xeErrorCode;  }
    catch(...)  {  return CCubitFile::eUnknownError;  }

    if((xintNumFound = SearchAll(eDouble)) > 0) {
        xpapachrName = mSearchBuff.mpapachrNames;
        xpaintOwner = mSearchBuff.mpaintOwners;
        xpadblValue = (double*)mSearchBuff.mpaValues;
    }
    return CCubitFile::eSuccess;
}
UnsignedInt32 CMetaData::GetMetaDataAll ( UnsignedInt32 &  xintNumFound,
const ConstCharPtr *&  xpapachrName,
const UnsignedInt32 *&  xpaintOwner,
const ConstUnsignedInt32Ptr *&  xpapaintValue,
const UnsignedInt32 *&  xpaintNumValues 
)

Definition at line 489 of file CubitFileMetaData.cpp.

{
    xintNumFound = 0;
    xpapachrName = NULL;
    xpaintOwner = NULL;
    xpapaintValue = NULL;
    xpaintNumValues = NULL;
    try {  RebuildSearchBuff(eUnsignedInt32Array);  }
    catch(CCubitFile::EErrorCode xeErrorCode)  {  return xeErrorCode;  }
    catch(...)  {  return CCubitFile::eUnknownError;  }

    if((xintNumFound = SearchAll(eUnsignedInt32Array)) > 0) {
        xpapachrName = mSearchBuff.mpapachrNames;
        xpaintOwner = mSearchBuff.mpaintOwners;
        xpapaintValue = (ConstUnsignedInt32Ptr*)mSearchBuff.mpaValues;
        xpaintNumValues = mSearchBuff.mpaintNumValues;
    }
    return CCubitFile::eSuccess;
}
UnsignedInt32 CMetaData::GetMetaDataAll ( UnsignedInt32 &  xintNumFound,
const ConstCharPtr *&  xpapachrName,
const UnsignedInt32 *&  xpaintOwner,
const ConstDoublePtr *&  xpapadblValue,
const UnsignedInt32 *&  xpaintNumValues 
)

Definition at line 514 of file CubitFileMetaData.cpp.

{
    xintNumFound = 0;
    xpapachrName = NULL;
    xpaintOwner = NULL;
    xpapadblValue = NULL;
    xpaintNumValues = NULL;
    try {  RebuildSearchBuff(eDoubleArray);  }
    catch(CCubitFile::EErrorCode xeErrorCode)  {  return xeErrorCode;  }
    catch(...)  {  return CCubitFile::eUnknownError;  }

    if((xintNumFound = SearchAll(eDoubleArray)) > 0) {
        xpapachrName = mSearchBuff.mpapachrNames;
        xpaintOwner = mSearchBuff.mpaintOwners;
        xpapadblValue = (ConstDoublePtr*)mSearchBuff.mpaValues;
        xpaintNumValues = mSearchBuff.mpaintNumValues;
    }
    return CCubitFile::eSuccess;
}
UnsignedInt32 CMetaData::GetValue ( UnsignedInt32  xintOwner,
ConstCharPtr  xpachrName,
UnsignedInt32 &  xintValue 
)

Definition at line 165 of file CubitFileMetaData.cpp.

{
    UnsignedInt32 lintEntry;
    if(Find(xintOwner, xpachrName, lintEntry)) {
        if(mpaEntries[lintEntry].mintMetaDataType == eUnsignedInt32) {
            xintValue = mpaEntries[lintEntry].muValue.mint;
            return CCubitFile::eSuccess;
        }
    }
    xintValue = 0;
    return CCubitFile::eNotFound;
}
UnsignedInt32 CMetaData::GetValue ( UnsignedInt32  xintOwner,
ConstCharPtr  xpachrName,
ConstCharPtr &  xpachrValue 
)

Definition at line 182 of file CubitFileMetaData.cpp.

{
    UnsignedInt32 lintEntry;
    if(Find(xintOwner, xpachrName, lintEntry)) {
        if(mpaEntries[lintEntry].mintMetaDataType == eString) {
            xpachrValue = mpaEntries[lintEntry].muValue.mpachr;
            return CCubitFile::eSuccess;
        }
    }
    xpachrValue = NULL;
    return CCubitFile::eNotFound;
}
UnsignedInt32 CMetaData::GetValue ( UnsignedInt32  xintOwner,
ConstCharPtr  xpachrName,
double &  xdblValue 
)

Definition at line 199 of file CubitFileMetaData.cpp.

{
    UnsignedInt32 lintEntry;
    if(Find(xintOwner, xpachrName, lintEntry)) {
        if(mpaEntries[lintEntry].mintMetaDataType == eDouble) {
            xdblValue = mpaEntries[lintEntry].muValue.mdbl;
            return CCubitFile::eSuccess;
        }
    }
    xdblValue = 0.0;
    return CCubitFile::eNotFound;
}
UnsignedInt32 CMetaData::GetValue ( UnsignedInt32  xintOwner,
ConstCharPtr  xpachrName,
const UnsignedInt32 *&  xpaintValue,
UnsignedInt32 &  xintNumValues 
)

Definition at line 216 of file CubitFileMetaData.cpp.

{
    UnsignedInt32 lintEntry;
    if(Find(xintOwner, xpachrName, lintEntry)) {
        if(mpaEntries[lintEntry].mintMetaDataType == eUnsignedInt32Array) {
            xpaintValue = mpaEntries[lintEntry].muValue.mpaint;
            xintNumValues = mpaEntries[lintEntry].mintNumValues;
            return CCubitFile::eSuccess;
        }
    }
    xpaintValue = NULL;
    xintNumValues = 0;
    return CCubitFile::eNotFound;
}
UnsignedInt32 CMetaData::GetValue ( UnsignedInt32  xintOwner,
ConstCharPtr  xpachrName,
const double *&  xpadblValue,
UnsignedInt32 &  xintNumValues 
)

Definition at line 236 of file CubitFileMetaData.cpp.

{
    UnsignedInt32 lintEntry;
    if(Find(xintOwner, xpachrName, lintEntry)) {
        if(mpaEntries[lintEntry].mintMetaDataType == eDoubleArray) {
            xpadblValue = mpaEntries[lintEntry].muValue.mpadbl;
            xintNumValues = mpaEntries[lintEntry].mintNumValues;
            return CCubitFile::eSuccess;
        }
    }
    xpadblValue = NULL;
    xintNumValues = 0;
    return CCubitFile::eNotFound;
}
void CMetaData::GrowSize ( ) [private]

Definition at line 93 of file CubitFileMetaData.cpp.

{
    // Try to allocate a new storage structure.
    UnsignedInt32 lintNewBufferSize = mintBufferSize + mintGrowSizeBy;
    SCubitFileMetaDataEntry* lpaNewEntries =
        new SCubitFileMetaDataEntry[lintNewBufferSize];
    if(!lpaNewEntries)
        throw CCubitFile::eMemoryError;

    // Copy the existing data into the front new structure.
    if(mpaEntries) {
        memcpy(lpaNewEntries, mpaEntries,
            mintBufferSize * sizeof(SCubitFileMetaDataEntry));
    }
    // Initialize the remaining part of the new structure.
    for(UnsignedInt32 lintEntry = mintBufferSize; lintEntry <
        lintNewBufferSize; lintEntry++) {
        lpaNewEntries[lintEntry].mintMetaDataOwner = 0;
        lpaNewEntries[lintEntry].mintMetaDataType = eUnsignedInt32;
        lpaNewEntries[lintEntry].mpachrName = NULL;
        lpaNewEntries[lintEntry].muValue.mint = 0;
        lpaNewEntries[lintEntry].mintNumValues = 0;
    }
    // Replace the old structure with the new one and free the old one.
    if(mpaEntries)
        delete [] mpaEntries;
    mintBufferSize = lintNewBufferSize;
    mpaEntries = lpaNewEntries;
}
void CMetaData::ReadMetaData ( FILE *  xpFile,
UnsignedInt32  xintAbsoluteOffset,
UnsignedInt32  xintRelativeOffset,
UnsignedInt32  xintSourceEndian 
)

Definition at line 928 of file CubitFileMetaData.cpp.

{
    // Delete all stored data
    FreeAll();

    if(!xpFile)  throw CCubitFile::eFileReadError;

    CIOWrapper* lpIO = new CIOWrapper(xpFile, xintSourceEndian);
    lpIO->BeginReadBlock(xintAbsoluteOffset, xintRelativeOffset);

    // Read the description header.
    lpIO->Read(&mHeader.mintMetaDataSchema, 1);
    lpIO->Read(&mHeader.mintMetaDataCompress, 1);
    lpIO->Read(&mHeader.mintMetaDataCount, 1);

    UnsignedInt32 lintEntry, lintNumEntries = mHeader.mintMetaDataCount;
    if(lintNumEntries) {
        // Grow the storage capacity of the meta-data object to match that of
        // the stored data.
        UnsignedInt32 lintGrowSizeBy = mintGrowSizeBy;
        mintGrowSizeBy = lintNumEntries;
        GrowSize();
        mintGrowSizeBy = lintGrowSizeBy;

        // Read the stored meta-data entries.
        for(lintEntry = 0; lintEntry < lintNumEntries; lintEntry++) {
            lpIO->Read(&mpaEntries[lintEntry].mintMetaDataOwner, 1);
            lpIO->Read(&mpaEntries[lintEntry].mintMetaDataType, 1);
            mpaEntries[lintEntry].mpachrName = lpIO->Read();
            switch(mpaEntries[lintEntry].mintMetaDataType) {
            case eUnsignedInt32:
                lpIO->Read(&mpaEntries[lintEntry].muValue.mint, 1);
                break;
            case eString:
                mpaEntries[lintEntry].muValue.mpachr = lpIO->Read();
                break;
            case eDouble:
                lpIO->Read(&mpaEntries[lintEntry].muValue.mdbl, 1);
                break;
            case eUnsignedInt32Array:
                lpIO->Read(&mpaEntries[lintEntry].mintNumValues, 1);
                if(mpaEntries[lintEntry].mintNumValues) {
                    mpaEntries[lintEntry].muValue.mpaint =
                        new UnsignedInt32[mpaEntries[lintEntry].mintNumValues];
                    if(!mpaEntries[lintEntry].muValue.mpaint)
                        throw CCubitFile::eMemoryError;
                    lpIO->Read(mpaEntries[lintEntry].muValue.mpaint,
                        mpaEntries[lintEntry].mintNumValues);
                }
                break;
            case eDoubleArray:
                lpIO->Read(&mpaEntries[lintEntry].mintNumValues, 1);
                if(mpaEntries[lintEntry].mintNumValues) {
                    mpaEntries[lintEntry].muValue.mpadbl =
                        new double[mpaEntries[lintEntry].mintNumValues];
                    if(!mpaEntries[lintEntry].muValue.mpadbl)
                        throw CCubitFile::eMemoryError;
                    lpIO->Read(mpaEntries[lintEntry].muValue.mpadbl,
                        mpaEntries[lintEntry].mintNumValues);
                }
                break;
            }
        }
    }
    delete lpIO;
}
void CMetaData::RebuildSearchBuff ( UnsignedInt32  xintSearchType) [private]

Definition at line 542 of file CubitFileMetaData.cpp.

{
    if(!mintBufferSize)  return;

    if(mSearchBuff.mintNumOwners < mintBufferSize) {
        if(mSearchBuff.mpaintOwners)
            delete [] mSearchBuff.mpaintOwners;
        mSearchBuff.mpaintOwners = new UnsignedInt32[mintBufferSize];
        mSearchBuff.mintNumOwners = mintBufferSize;
        if(!mSearchBuff.mpaintOwners) {
            mSearchBuff.mintNumOwners = 0;
            throw CCubitFile::eMemoryError;
        }
    }
    if(mSearchBuff.mintNumNames < mintBufferSize) {
        if(mSearchBuff.mpapachrNames)
            delete [] mSearchBuff.mpapachrNames;
        mSearchBuff.mpapachrNames = new ConstCharPtr[mintBufferSize];
        mSearchBuff.mintNumNames = mintBufferSize;
        if(!mSearchBuff.mpapachrNames) {
            mSearchBuff.mintNumNames = 0;
            throw CCubitFile::eMemoryError;
        }
    }
    if((mSearchBuff.mintNumMetaData < mintBufferSize) ||
        (mSearchBuff.mintMetaDataType != xintSearchType)) {
        if(mSearchBuff.mpaValues) {
            switch(mSearchBuff.mintMetaDataType) {
            case eUnsignedInt32:
                delete [] (UnsignedInt32*)mSearchBuff.mpaValues;  break;
            case eString:
                delete [] (ConstCharPtr*)mSearchBuff.mpaValues;  break;
            case eDouble:
                delete [] (double*)mSearchBuff.mpaValues;  break;
            case eUnsignedInt32Array:
                delete [] (ConstUnsignedInt32Ptr*)mSearchBuff.mpaValues;  break;
            case eDoubleArray:
                delete [] (ConstDoublePtr*)mSearchBuff.mpaValues;  break;
            }
        }
        if(mSearchBuff.mpaintNumValues)
            delete [] mSearchBuff.mpaintNumValues;
        mSearchBuff.mintMetaDataType = xintSearchType;
        mSearchBuff.mintNumMetaData = mintBufferSize;

        switch(mSearchBuff.mintMetaDataType) {
        case eUnsignedInt32:
            mSearchBuff.mpaValues = new UnsignedInt32[mintBufferSize];
            break;
        case eString:
            mSearchBuff.mpaValues = new ConstCharPtr[mintBufferSize];
            break;
        case eDouble:
            mSearchBuff.mpaValues = new double[mintBufferSize];
            break;
        case eUnsignedInt32Array:
            mSearchBuff.mpaValues = new ConstUnsignedInt32Ptr[mintBufferSize];
            break;
        case eDoubleArray:
            mSearchBuff.mpaValues = new ConstDoublePtr[mintBufferSize];
            break;
        }
        if(!mSearchBuff.mpaValues) {
            mSearchBuff.mintNumMetaData = 0;
            throw CCubitFile::eMemoryError;
        }

        switch(mSearchBuff.mintMetaDataType) {
        case eUnsignedInt32Array:
        case eDoubleArray:
            mSearchBuff.mpaintNumValues = new UnsignedInt32[mintBufferSize];
            if(!mSearchBuff.mpaintNumValues) {
                mSearchBuff.mintMetaDataType = 0;
                switch(mSearchBuff.mintMetaDataType) {
                case eUnsignedInt32:
                    delete [] (UnsignedInt32*)mSearchBuff.mpaValues;  break;
                case eString:
                    delete [] (ConstCharPtr*)mSearchBuff.mpaValues;  break;
                case eDouble:
                    delete [] (double*)mSearchBuff.mpaValues;  break;
                case eUnsignedInt32Array:
                    delete [] (ConstUnsignedInt32Ptr*)mSearchBuff.mpaValues;  break;
                case eDoubleArray:
                    delete [] (ConstDoublePtr*)mSearchBuff.mpaValues;  break;
                }
                mSearchBuff.mpaValues = NULL;
                throw CCubitFile::eMemoryError;
            }
            break;
        default:
            mSearchBuff.mpaintNumValues = NULL;
        }
    }
}
UnsignedInt32 CMetaData::SearchAll ( UnsignedInt32  xintSearchType) [private]

Definition at line 739 of file CubitFileMetaData.cpp.

{
    if(!mHeader.mintMetaDataCount)  return 0;  // none found

    UnsignedInt32 lintNumFound = 0;
    for(UnsignedInt32 lintEntry = 0; lintEntry <
        mHeader.mintMetaDataCount; lintEntry++) {
        if(mpaEntries[lintEntry].mintMetaDataType == xintSearchType) {
            mSearchBuff.mpapachrNames[lintNumFound] =
                mpaEntries[lintEntry].mpachrName;
            mSearchBuff.mpaintOwners[lintNumFound] =
                mpaEntries[lintEntry].mintMetaDataOwner;
            switch(xintSearchType) {
            case eUnsignedInt32:
                ((UnsignedInt32*)mSearchBuff.mpaValues)[lintNumFound] =
                    mpaEntries[lintEntry].muValue.mint;
                break;
            case eString:
                ((ConstCharPtr*)mSearchBuff.mpaValues)[lintNumFound] =
                    mpaEntries[lintEntry].muValue.mpachr;
                break;
            case eDouble:
                ((double*)mSearchBuff.mpaValues)[lintNumFound] =
                    mpaEntries[lintEntry].muValue.mdbl;
                break;
            case eUnsignedInt32Array:
                ((ConstUnsignedInt32Ptr*)mSearchBuff.mpaValues)[lintNumFound] =
                    mpaEntries[lintEntry].muValue.mpaint;
                mSearchBuff.mpaintNumValues[lintNumFound] =
                    mpaEntries[lintEntry].mintNumValues;
                break;
            case eDoubleArray:
                ((ConstDoublePtr*)mSearchBuff.mpaValues)[lintNumFound] =
                    mpaEntries[lintEntry].muValue.mpadbl;
                mSearchBuff.mpaintNumValues[lintNumFound] =
                    mpaEntries[lintEntry].mintNumValues;
                break;
            }
            lintNumFound++;
        }
    }
    return lintNumFound;  // return number found
}
UnsignedInt32 CMetaData::SearchByID ( UnsignedInt32  xintSearchType,
UnsignedInt32  xintOwner 
) [private]

Definition at line 639 of file CubitFileMetaData.cpp.

{
    if(!mHeader.mintMetaDataCount)  return 0;  // none found

    UnsignedInt32 lintNumFound = 0;
    for(UnsignedInt32 lintEntry = 0; lintEntry <
        mHeader.mintMetaDataCount; lintEntry++) {
        if(mpaEntries[lintEntry].mintMetaDataOwner == xintOwner) {
            if(mpaEntries[lintEntry].mintMetaDataType == xintSearchType) {
                mSearchBuff.mpapachrNames[lintNumFound] =
                    mpaEntries[lintEntry].mpachrName;
                switch(xintSearchType) {
                case eUnsignedInt32:
                    ((UnsignedInt32*)mSearchBuff.mpaValues)[lintNumFound] =
                        mpaEntries[lintEntry].muValue.mint;
                    break;
                case eString:
                    ((ConstCharPtr*)mSearchBuff.mpaValues)[lintNumFound] =
                        mpaEntries[lintEntry].muValue.mpachr;
                    break;
                case eDouble:
                    ((double*)mSearchBuff.mpaValues)[lintNumFound] =
                        mpaEntries[lintEntry].muValue.mdbl;
                    break;
                case eUnsignedInt32Array:
                    ((ConstUnsignedInt32Ptr*)mSearchBuff.mpaValues)[lintNumFound] =
                        mpaEntries[lintEntry].muValue.mpaint;
                    mSearchBuff.mpaintNumValues[lintNumFound] =
                        mpaEntries[lintEntry].mintNumValues;
                    break;
                case eDoubleArray:
                    ((ConstDoublePtr*)mSearchBuff.mpaValues)[lintNumFound] =
                        mpaEntries[lintEntry].muValue.mpadbl;
                    mSearchBuff.mpaintNumValues[lintNumFound] =
                        mpaEntries[lintEntry].mintNumValues;
                    break;
                }
                lintNumFound++;
            }
        }
    }
    return lintNumFound;  // return number found
}
UnsignedInt32 CMetaData::SearchByName ( UnsignedInt32  xintSearchType,
const char *  xpachrName 
) [private]

Definition at line 689 of file CubitFileMetaData.cpp.

{
    if(!mHeader.mintMetaDataCount)  return 0;  // none found

    UnsignedInt32 lintNumFound = 0;
    for(UnsignedInt32 lintEntry = 0; lintEntry <
        mHeader.mintMetaDataCount; lintEntry++) {
        if(!std::strcmp(xpachrName, mpaEntries[lintEntry].mpachrName)) {
            if(mpaEntries[lintEntry].mintMetaDataType == xintSearchType) {
                mSearchBuff.mpaintOwners[lintNumFound] =
                    mpaEntries[lintEntry].mintMetaDataOwner;
                switch(xintSearchType) {
                case eUnsignedInt32:
                    ((UnsignedInt32*)mSearchBuff.mpaValues)[lintNumFound] =
                        mpaEntries[lintEntry].muValue.mint;
                    break;
                case eString:
                    ((ConstCharPtr*)mSearchBuff.mpaValues)[lintNumFound] =
                        mpaEntries[lintEntry].muValue.mpachr;
                    break;
                case eDouble:
                    ((double*)mSearchBuff.mpaValues)[lintNumFound] =
                        mpaEntries[lintEntry].muValue.mdbl;
                    break;
                case eUnsignedInt32Array:
                    ((ConstUnsignedInt32Ptr*)mSearchBuff.mpaValues)[lintNumFound] =
                        mpaEntries[lintEntry].muValue.mpaint;
                    mSearchBuff.mpaintNumValues[lintNumFound] =
                        mpaEntries[lintEntry].mintNumValues;
                    break;
                case eDoubleArray:
                    ((ConstDoublePtr*)mSearchBuff.mpaValues)[lintNumFound] =
                        mpaEntries[lintEntry].muValue.mpadbl;
                    mSearchBuff.mpaintNumValues[lintNumFound] =
                        mpaEntries[lintEntry].mintNumValues;
                    break;
                }
                lintNumFound++;
            }
        }
    }
    return lintNumFound;  // return number found
}
UnsignedInt32 CMetaData::SetValue ( UnsignedInt32  xintOwner,
ConstCharPtr  xpachrName,
UnsignedInt32  xintValue 
)

Definition at line 258 of file CubitFileMetaData.cpp.

{
    if(!xpachrName)
        return CCubitFile::ePassedNullPointer;

    try {
        UnsignedInt32 lintEntry;
        if(Find(xintOwner, xpachrName, lintEntry))
            FreeValueAt(lintEntry);
        else
            lintEntry = AddEntry(xintOwner, xpachrName);
        mpaEntries[lintEntry].mintMetaDataType = eUnsignedInt32;
        mpaEntries[lintEntry].muValue.mint = xintValue;
        return CCubitFile::eSuccess;
    }
    catch(CCubitFile::EErrorCode xeErrorCode)  {  return xeErrorCode;  }
    catch(...)  {  return CCubitFile::eUnknownError;  }
}
UnsignedInt32 CMetaData::SetValue ( UnsignedInt32  xintOwner,
ConstCharPtr  xpachrName,
ConstCharPtr  xpachrValue 
)

Definition at line 281 of file CubitFileMetaData.cpp.

{
    if(!xpachrName)
        throw CCubitFile::ePassedNullPointer;

    try {
        UnsignedInt32 lintEntry, lintLength;
        if(Find(xintOwner, xpachrName, lintEntry))
            FreeValueAt(lintEntry);
        else
            lintEntry = AddEntry(xintOwner, xpachrName);

        mpaEntries[lintEntry].mintMetaDataType = eString;
        lintLength = xpachrValue ? std::strlen(xpachrValue) : 0;
        if(lintLength) {
            mpaEntries[lintEntry].muValue.mpachr = new char[lintLength + 1];
            if(!mpaEntries[lintEntry].muValue.mpachr)
                throw CCubitFile::eMemoryError;
            std::strcpy(mpaEntries[lintEntry].muValue.mpachr, xpachrValue);
        }
        else
            mpaEntries[lintEntry].muValue.mpachr = NULL;

        return CCubitFile::eSuccess;
    }
    catch(CCubitFile::EErrorCode xeErrorCode)  {  return xeErrorCode;  }
    catch(...)  {  return CCubitFile::eUnknownError;  }
}
UnsignedInt32 CMetaData::SetValue ( UnsignedInt32  xintOwner,
ConstCharPtr  xpachrName,
double  xdblValue 
)

Definition at line 314 of file CubitFileMetaData.cpp.

{
    if(!xpachrName)
        throw CCubitFile::ePassedNullPointer;

    try {
        UnsignedInt32 lintEntry;
        if(Find(xintOwner, xpachrName, lintEntry))
            FreeValueAt(lintEntry);
        else
            lintEntry = AddEntry(xintOwner, xpachrName);
        mpaEntries[lintEntry].mintMetaDataType = eDouble;
        mpaEntries[lintEntry].muValue.mdbl = xdblValue;
        return CCubitFile::eSuccess;
    }
    catch(CCubitFile::EErrorCode xeErrorCode)  {  return xeErrorCode;  }
    catch(...)  {  return CCubitFile::eUnknownError;  }
}
UnsignedInt32 CMetaData::SetValue ( UnsignedInt32  xintOwner,
ConstCharPtr  xpachrName,
const UnsignedInt32 *  xpaintValue,
UnsignedInt32  xintNumValues 
)

Definition at line 336 of file CubitFileMetaData.cpp.

{
    if(!xpachrName)
        throw CCubitFile::ePassedNullPointer;

    try {
        UnsignedInt32 lintEntry;
        if(Find(xintOwner, xpachrName, lintEntry))
            FreeValueAt(lintEntry);
        else
            lintEntry = AddEntry(xintOwner, xpachrName);

        mpaEntries[lintEntry].mintMetaDataType = eUnsignedInt32Array;
        if(xpaintValue && xintNumValues) {
            mpaEntries[lintEntry].muValue.mpaint =
                new UnsignedInt32[xintNumValues];
            if(!mpaEntries[lintEntry].muValue.mpaint)
                throw CCubitFile::eMemoryError;
            memcpy(mpaEntries[lintEntry].muValue.mpaint, xpaintValue,
                xintNumValues * sizeof(UnsignedInt32));
            mpaEntries[lintEntry].mintNumValues = xintNumValues;
        }
        else {
            mpaEntries[lintEntry].muValue.mpaint = NULL;
            mpaEntries[lintEntry].mintNumValues = 0;
        }

        return CCubitFile::eSuccess;
    }
    catch(CCubitFile::EErrorCode xeErrorCode)  {  return xeErrorCode;  }
    catch(...)  {  return CCubitFile::eUnknownError;  }
}
UnsignedInt32 CMetaData::SetValue ( UnsignedInt32  xintOwner,
ConstCharPtr  xpachrName,
const double *  xpadblValue,
UnsignedInt32  xintNumValues 
)

Definition at line 374 of file CubitFileMetaData.cpp.

{
    if(!xpachrName)
        throw CCubitFile::ePassedNullPointer;

    try {
        UnsignedInt32 lintEntry;
        if(Find(xintOwner, xpachrName, lintEntry))
            FreeValueAt(lintEntry);
        else
            lintEntry = AddEntry(xintOwner, xpachrName);

        mpaEntries[lintEntry].mintMetaDataType = eDoubleArray;
        if(xpadblValue && xintNumValues) {
            mpaEntries[lintEntry].muValue.mpadbl =
                new double[xintNumValues];
            if(!mpaEntries[lintEntry].muValue.mpadbl)
                throw CCubitFile::eMemoryError;
            memcpy(mpaEntries[lintEntry].muValue.mpadbl, xpadblValue,
                xintNumValues * sizeof(double));
            mpaEntries[lintEntry].mintNumValues = xintNumValues;
        }
        else {
            mpaEntries[lintEntry].muValue.mpadbl = NULL;
            mpaEntries[lintEntry].mintNumValues = 0;
        }

        return CCubitFile::eSuccess;
    }
    catch(CCubitFile::EErrorCode xeErrorCode)  {  return xeErrorCode;  }
    catch(...)  {  return CCubitFile::eUnknownError;  }
}
void CMetaData::WriteMetaData ( FILE *  xpFile,
UnsignedInt32 &  xintWroteAtOffset,
UnsignedInt32 &  xintLength,
UnsignedInt32  xintOffsetFrom = 0 
)

Definition at line 873 of file CubitFileMetaData.cpp.

{
    if(!xpFile)  throw CCubitFile::eFileWriteError;

    CIOWrapper* lpIO = new CIOWrapper(xpFile);
    xintWroteAtOffset = lpIO->BeginWriteBlock(xintOffsetFrom);

    // Write a description header.
    lpIO->Write(&mHeader.mintMetaDataSchema, 1);
    lpIO->Write(&mHeader.mintMetaDataCompress, 1);
    lpIO->Write(&mHeader.mintMetaDataCount, 1);

    // Write the actual meta-data entries.
    UnsignedInt32 lintEntry, lintNumEntries = mHeader.mintMetaDataCount;
    if(lintNumEntries) {
        for(lintEntry = 0; lintEntry < lintNumEntries; lintEntry++) {
            lpIO->Write(&mpaEntries[lintEntry].mintMetaDataOwner, 1);
            lpIO->Write(&mpaEntries[lintEntry].mintMetaDataType, 1);
            lpIO->Write(mpaEntries[lintEntry].mpachrName);
            switch(mpaEntries[lintEntry].mintMetaDataType) {
            case eUnsignedInt32:
                lpIO->Write(&mpaEntries[lintEntry].muValue.mint, 1);
                break;
            case eString:
                lpIO->Write(mpaEntries[lintEntry].muValue.mpachr);
                break;
            case eDouble:
                lpIO->Write(&mpaEntries[lintEntry].muValue.mdbl, 1);
                break;
            case eUnsignedInt32Array:
                lpIO->Write(&mpaEntries[lintEntry].mintNumValues, 1);
                if(mpaEntries[lintEntry].mintNumValues) {
                    lpIO->Write(mpaEntries[lintEntry].muValue.mpaint,
                        mpaEntries[lintEntry].mintNumValues);
                }
                break;
            case eDoubleArray:
                lpIO->Write(&mpaEntries[lintEntry].mintNumValues, 1);
                if(mpaEntries[lintEntry].mintNumValues) {
                    lpIO->Write(mpaEntries[lintEntry].muValue.mpadbl,
                        mpaEntries[lintEntry].mintNumValues);
                }
                break;
            }
        }
    }
    xintLength = lpIO->EndWriteBlock();
    delete lpIO;
}

Member Data Documentation

struct NCubitFile::CMetaData::SCubitFileMetaDataHeader NCubitFile::CMetaData::mHeader [private]
UnsignedInt32 NCubitFile::CMetaData::mintBufferSize [private]

Definition at line 138 of file CubitFileMetaData.hpp.

UnsignedInt32 NCubitFile::CMetaData::mintGrowSizeBy [private]

Definition at line 139 of file CubitFileMetaData.hpp.

UnsignedInt32 NCubitFile::CMetaData::mintMetaDataType

Definition at line 146 of file CubitFileMetaData.hpp.

UnsignedInt32 NCubitFile::CMetaData::mintNumMetaData

Definition at line 147 of file CubitFileMetaData.hpp.

UnsignedInt32 NCubitFile::CMetaData::mintNumNames

Definition at line 144 of file CubitFileMetaData.hpp.

UnsignedInt32 NCubitFile::CMetaData::mintNumOwners

Definition at line 142 of file CubitFileMetaData.hpp.

struct NCubitFile::CMetaData::SCubitFileMetaDataEntry * NCubitFile::CMetaData::mpaEntries [private]
UnsignedInt32* NCubitFile::CMetaData::mpaintNumValues

Definition at line 149 of file CubitFileMetaData.hpp.

UnsignedInt32* NCubitFile::CMetaData::mpaintOwners

Definition at line 143 of file CubitFileMetaData.hpp.

ConstCharPtr* NCubitFile::CMetaData::mpapachrNames

Definition at line 145 of file CubitFileMetaData.hpp.

void* NCubitFile::CMetaData::mpaValues

Definition at line 148 of file CubitFileMetaData.hpp.

struct { ... } NCubitFile::CMetaData::mSearchBuff [private]
The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines