fsc_Generation Class Reference
[File System Catalog]

#include <fsc_Generation.h>

Inheritance diagram for fsc_Generation:

[legend]

Collaboration diagram for fsc_Generation:

[legend]

List of all members.

---

Detailed Description

<Description:> A more elaborate class description that describes all aspects of class usage etc.

Author:

Dejan Volk Lupo, HERMES SoftLab

See also:

<reference>

Definition at line 35 of file fsc_Generation.h.

Public Member Functions
	fsc_Generation ()
	fsc_Generation (df_SplitInfo &a_splitInfo)
	fsc_Generation (const fsc_Generation_t &a_generation)
	~fsc_Generation ()
void	Insert (df_SplitInfo &a_splitInfo)
	Insert a split into Data location tree.
void	Remove (ivd_MediaKey_t a_mediumKey, ivd_MedVolNum_t a_medVolNum)
	remove all entries from particular volume.
bool	Remove (ivd_MediaKey_t a_mediumKey, ivd_MedVolNum_t a_medVolNum, UInt32_t a_blockOffs)
	Remove one particular entry.
void	GetCopiesPos (ivd_CopiesPos_v_t &a_copiesPos_v, fsc_MigInfo_t &a_migInfo)
	Get all copies from this generation.
bool	Write2DB (fsc_Generation_t &a_genData, fio_Transaction &a_trans)
	invoke next level write2DB and collect data for previous level
void	Dump (ostream &os)
bool	TreeWalk (fsc_Collector &a_collector)
Public Attributes
ivd_MigrationID_t	m_migrationID
ivd_FileSize_t	m_size
	the size of the file
ivd_DataType_t	m_dataType
	all data type that are stored in splits
	log_CLASSID_m
Private Member Functions
void	ReadMembers ()
	create and read next level members

---

Constructor & Destructor Documentation

fsc_Generation::fsc_Generation

(

)

[inline]

Definition at line 38 of file fsc_Generation.h.

Referenced by fsc_Generation().

{};

Here is the caller graph for this function:

fsc_Generation::fsc_Generation

(

df_SplitInfo &

a_splitInfo

)

Definition at line 38 of file fsc_Generation.cpp.

References dlc_MediaPos, dlc_Split, df_SplitInfo::Dump(), fsc_Generation(), ie_FSC_TOO_MUCH_COPIES, fsc_Entry::InitNextEntry(), df_SplitInfo::lastSplit, log_FUNC_m, maxNumOfCopies_c, df_SplitInfo::noCopies, and df_SplitInfo::splitOffset.

00039             :
00040             fsc_Entry(),
00041             m_migrationID(a_splitInfo.migrationID),
00042 //  FIX bug 1228    m_size(a_splitInfo.fileSize),
00043             m_size(a_splitInfo.lastSplit // size is defined when last split is insertted
00044                    ? a_splitInfo.splitOffset + a_splitInfo.splitSize
00045                    : 0), 
00046             m_dataType(a_splitInfo.dataType)
00047 {
00048     log_FUNC_m(fsc_Generation(df_SplitInfo));
00049 
00050     if (a_splitInfo.noCopies > maxNumOfCopies_c) {
00051         throw ivd_InternalError(ie_FSC_TOO_MUCH_COPIES, 
00052             "Front end agent created too many copies." + a_splitInfo.Dump(), true);
00053     }
00054 
00055 /*    if (a_splitInfo.noCopies > 1) {
00056         fsc_Entry::InitNextEntry(dlc_Copy, new fsc_CopyMgr(a_splitInfo));        
00057     }
00058     else */
00059     if ( !a_splitInfo.lastSplit
00060             || a_splitInfo.splitOffset > 0) { //FIX  bug 680  if split then generate another empty
00061         fsc_Entry::InitNextEntry(dlc_Split, new fsc_SplitMgr(a_splitInfo));     
00062     }
00063     else {
00064         fsc_Entry::InitNextEntry(dlc_MediaPos, new fsc_MedPosMgr(a_splitInfo));        
00065     }
00066 }
//============================================================================//

Here is the call graph for this function:

fsc_Generation::fsc_Generation

(

const fsc_Generation_t &

a_generation

)

Definition at line 69 of file fsc_Generation.cpp.

References dbg_DETAIL, fsc_Generation(), log_DBG_m, log_FUNC_m, fsc_Generation_t::migrationID, and fsc_Generation_t::size.

00071             :
00072             fsc_Entry(a_generation.nextEntity),
00073             m_migrationID(a_generation.migrationID),
00074             m_size(a_generation.size),
00075             m_dataType(a_generation.nextEntity.dataType)
00076 {
00077     log_FUNC_m(fsc_Generation(fsc_generation_t));
00078 
00079     log_DBG_m(dbg_DETAIL,"fsc_Generation_t  migId " << a_generation.migrationID
00080                        << " size " << a_generation.size );
00081 //    a_generation.nextEntity.Dbg();
00082 }
//============================================================================//

Here is the call graph for this function:

fsc_Generation::~fsc_Generation

(

)

Definition at line 85 of file fsc_Generation.cpp.

{
}

---

Member Function Documentation

void fsc_Generation::Insert

(

df_SplitInfo &

a_splitInfo

)

Insert a split into Data location tree.

Definition at line 90 of file fsc_Generation.cpp.

References fsc_SplitMgr::AddSplit(), fsc_CopyMgr::AddSplit(), cmn_Num2Str(), df_SplitInfo::dataType, dbg_DETAIL, dlc_Copy, dlc_MediaPos, dlc_Split, fsc_NextEntity_t::dlcType, df_SplitInfo::Dump(), ie_INVALID_ARG, fsc_Entry::Init(), fsc_MedPosMgr::IsItEqual(), df_SplitInfo::lastSplit, log_DBG_m, log_FUNC_m, fsc_Entry::m_changed, m_dataType, fsc_Entry::m_entryMgr_p, fsc_Entry::m_nextEntry, m_size, fsc_SplitMgr::m_split_p_l, ReadMembers(), sp_ALREADY_ADDED, sp_CHECK_OTHER_COPIES, sp_INSERTTED, sp_NEW_COPY, sp_REPLACE, df_SplitInfo::splitOffset, and df_SplitInfo::splitSize.

                                                      {
    log_FUNC_m(Insert);

    ReadMembers();

    // check if some new data type is add
    ivd_DataType_t previousDataType = m_dataType; 
    ivd_DataType_t dataType         = m_dataType | a_splitInfo.dataType; 
    if ( dataType != m_dataType) {
        m_dataType = dataType;
        m_changed  = true;
    }
    // fix bug 1228
    // when lastSplit is got and size is not updated, update it
    if (   a_splitInfo.lastSplit
        && (m_size < (a_splitInfo.splitOffset + a_splitInfo.splitSize))) { // 
        m_size = a_splitInfo.splitOffset + a_splitInfo.splitSize;
        m_changed  = true;
    }
    
    switch (m_nextEntry.dlcType) {
        case dlc_Copy : {
            log_DBG_m(dbg_DETAIL, "gen: add to copyMgr");
            fsc_CopyMgr* copyMgr_p = static_cast<fsc_CopyMgr*>(m_entryMgr_p);
            fsc_Split* split_p = new fsc_Split(a_splitInfo);
            // it's up to copyMgr or next objects in hierarhy to use or delete split_p
            copyMgr_p->AddSplit(split_p);
        }
        break;

        case dlc_Split : {
            log_DBG_m(dbg_DETAIL, "gen: add to splitMgr");
            fsc_SplitMgr* splitMgr_p = static_cast<fsc_SplitMgr*>(m_entryMgr_p);
            fsc_Split* split_p = new fsc_Split(a_splitInfo);
            fsc_Split_p_l_i possibleInsertPoint;
            fsc_Split_p_l_t replacedSplit_p_l;
            switch (splitMgr_p->AddSplit(split_p, possibleInsertPoint, replacedSplit_p_l)) {
            case sp_INSERTTED : 
                log_DBG_m(dbg_DETAIL, "gen: INSERTTED");
                return;

            case sp_CHECK_OTHER_COPIES :  // if no other places then use possibleInsertPoint
                log_DBG_m(dbg_DETAIL, "gen: CHECK_OTHER_COPIES");
                splitMgr_p->m_split_p_l.insert(possibleInsertPoint, split_p);
                return;

            case sp_NEW_COPY : {
                log_DBG_m(dbg_DETAIL, "gen: NEW_COPY");
                fsc_CopyMgr* copyMgr_p = new fsc_CopyMgr(dlc_Split, splitMgr_p, previousDataType);
                m_entryMgr_p = copyMgr_p;
                fsc_Entry::Init(dlc_Copy, 2, m_entryMgr_p);
                // TODO added split is checked twice for fit into same copy
                // once as generation and second as multi copy.
                copyMgr_p->AddSplit(split_p);
            }
            break;
            case sp_REPLACE : { // expect some splits in replacedSplit_p_l list
               log_DBG_m(dbg_DETAIL, "gen: REPLACE");
                m_entryMgr_p = new fsc_CopyMgr(dlc_Split, splitMgr_p, previousDataType);
                fsc_Entry::Init(dlc_Copy, 2, m_entryMgr_p);
                fsc_CopyMgr* copyMgr_p = static_cast<fsc_CopyMgr*>(m_entryMgr_p);
                fsc_Split_p_l_i iter = replacedSplit_p_l.begin();
                for ( ; iter != replacedSplit_p_l.end(); ++iter ) {
                    // NOTE: recursion, call this method again
                    copyMgr_p->AddSplit(*iter); // insert it again
                }                
            }
            break;

            case sp_ALREADY_ADDED :
                log_DBG_m(dbg_DETAIL, "gen: ALREADY_ADDED");
                delete split_p;
                return;
            default : ;
            }
        }
        break;

        case dlc_MediaPos : {  
                log_DBG_m(dbg_DETAIL, "gen: add to medPosMgr");
                fsc_MedPosMgr* medPosMgr_p = static_cast<fsc_MedPosMgr*>(m_entryMgr_p);
                if (medPosMgr_p->IsItEqual(a_splitInfo)) {
                    return;
                }
                // new copy of same split
                fsc_CopyMgr* copyMgr_p = new fsc_CopyMgr(dlc_MediaPos, medPosMgr_p, previousDataType);
                m_entryMgr_p = copyMgr_p;
                fsc_Entry::Init(dlc_Copy, 2, m_entryMgr_p);                         
                fsc_Split* split_p = new fsc_Split(a_splitInfo);
                copyMgr_p->AddSplit(split_p);
        }
        break;

        default:
            throw ivd_InternalError(ie_INVALID_ARG, 
                "Wrong dlcType =" + cmn_Num2Str((int)m_nextEntry.dlcType)+ a_splitInfo.Dump(), true);
            break;
    }
}

Here is the call graph for this function:

void fsc_Generation::Remove	(	ivd_MediaKey_t	a_mediumKey,
		ivd_MedVolNum_t	a_medVolNum
	)

remove all entries from particular volume.

Definition at line 191 of file fsc_Generation.cpp.

References cmn_Num2Str(), dlc_Copy, dlc_MediaPos, dlc_NotUsed, dlc_Split, fsc_NextEntity_t::dlcType, ie_INVALID_ARG, log_FUNC_m, fsc_Entry::m_entryMgr_p, fsc_Entry::m_nextEntry, ReadMembers(), fsc_MedPosMgr::Remove(), fsc_CopyMgr::Remove(), and fsc_SplitMgr::RemoveEntry().

Referenced by Remove().

                                                             {
    log_FUNC_m(Remove);
    ReadMembers();
    
    switch (m_nextEntry.dlcType) {
    case dlc_NotUsed :
         return;
    case dlc_Copy : {
            fsc_CopyMgr* p = static_cast<fsc_CopyMgr*>(m_entryMgr_p);
            p->Remove(a_mediumKey, a_medVolNum);
        }
        return;

    case dlc_Split : {
            fsc_SplitMgr* p = static_cast<fsc_SplitMgr*>(m_entryMgr_p);
            p->RemoveEntry(a_mediumKey, a_medVolNum);
        }
        return;

    case dlc_MediaPos : {
            fsc_MedPosMgr* p = static_cast<fsc_MedPosMgr*>(m_entryMgr_p);
            p->Remove(a_mediumKey, a_medVolNum);
        }
        return;

    default:
        throw ivd_InternalError(ie_INVALID_ARG, 
            "Wrong dlcType =" + cmn_Num2Str((int)m_nextEntry.dlcType), true);
        break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool fsc_Generation::Remove	(	ivd_MediaKey_t	a_mediumKey,
		ivd_MedVolNum_t	a_medVolNum,
		UInt32_t	a_blockOffs
	)

Remove one particular entry.

Definition at line 225 of file fsc_Generation.cpp.

References cmn_Num2Str(), dlc_Copy, dlc_MediaPos, dlc_NotUsed, dlc_Split, fsc_NextEntity_t::dlcType, ie_INVALID_ARG, log_FUNC_m, fsc_Entry::m_entryMgr_p, fsc_Entry::m_nextEntry, ReadMembers(), fsc_MedPosMgr::Remove(), fsc_CopyMgr::Remove(), Remove(), and fsc_SplitMgr::RemoveEntry().

                                                             {
    log_FUNC_m(Remove);
    ReadMembers();
    
    switch (m_nextEntry.dlcType) {
    case dlc_NotUsed :
         return false;
    case dlc_Copy : {
            fsc_CopyMgr* p = static_cast<fsc_CopyMgr*>(m_entryMgr_p);
            return p->Remove(a_mediumKey, a_medVolNum, a_blockOffs);
        }
        break;

    case dlc_Split : {
            fsc_SplitMgr* p = static_cast<fsc_SplitMgr*>(m_entryMgr_p);
            return p->RemoveEntry(a_mediumKey, a_medVolNum, a_blockOffs);
        }
        break;

    case dlc_MediaPos : {
            fsc_MedPosMgr* p = static_cast<fsc_MedPosMgr*>(m_entryMgr_p);
            return p->Remove(a_mediumKey, a_medVolNum, a_blockOffs);
        }
        break;

    default:
        throw ivd_InternalError(ie_INVALID_ARG, 
            "Wrong dlcType =" + cmn_Num2Str((int)m_nextEntry.dlcType), true);
        break;
    }
}

Here is the call graph for this function:

void fsc_Generation::GetCopiesPos	(	ivd_CopiesPos_v_t &	a_copiesPos_v,
		fsc_MigInfo_t &	a_migInfo
	)

Get all copies from this generation.

Definition at line 260 of file fsc_Generation.cpp.

References cmn_Num2Str(), ivd_MediaPos_t::dataType, dlc_Copy, dlc_MediaPos, dlc_Split, fsc_NextEntity_t::dlcType, fsc_CopyMgr::GetCopiesPos(), fsc_MedPosMgr::GetMediaPos(), fsc_SplitMgr::GetMediaPos(), ie_INVALID_ARG, log_FUNC_m, m_dataType, fsc_MigInfo_t::m_dataType, fsc_Entry::m_entryMgr_p, fsc_MigInfo_t::m_migId, m_migrationID, fsc_Entry::m_nextEntry, m_size, fsc_MigInfo_t::m_size, ReadMembers(), ivd_MediaPos_t::splitOffset, and ivd_MediaPos_t::splitSize.

Referenced by fsc_GenerationMgr::GetCopiesPos().

                                                                                            {
    log_FUNC_m(GetCopiesPos);

    ReadMembers();

    // fix bug 736
    a_migInfo.m_migId    = m_migrationID;
    a_migInfo.m_size     = m_size;
    a_migInfo.m_dataType = m_dataType;

    switch (m_nextEntry.dlcType) {
    case dlc_Copy : {
//            a_copiesPos.resize(m_nextEntry.Vector.NumOfElement);
        fsc_CopyMgr *copyMgr_p = static_cast<fsc_CopyMgr*>(m_entryMgr_p);
        copyMgr_p->GetCopiesPos(a_copiesPos_v, a_migInfo);
        }
        break;

    case dlc_Split : {// TODO check copy ID and no of copies
        a_copiesPos_v.resize(1);    // one copy
        fsc_SplitMgr *splitMgr_p = static_cast<fsc_SplitMgr*>(m_entryMgr_p);
        splitMgr_p->GetMediaPos(a_copiesPos_v.back(), a_migInfo);
        if (a_copiesPos_v.back().size() == 0) {
            a_copiesPos_v.clear();
        }
        }
        break;

    case dlc_MediaPos : {
        a_copiesPos_v.resize(1);    // one copy
        a_copiesPos_v[0].resize(1); // one split
        fsc_MedPosMgr *medPosMgr_p = static_cast<fsc_MedPosMgr*>(m_entryMgr_p);
        ivd_MediaPos_t &mediaPos = a_copiesPos_v[0][0];
        medPosMgr_p->GetMediaPos(mediaPos);
        mediaPos.splitOffset = 0;   
        mediaPos.splitSize   = m_size;
        mediaPos.dataType    = m_dataType;
        }
        break;

    default:
        throw ivd_InternalError(ie_INVALID_ARG, 
            "Wrong dlcType =" + cmn_Num2Str((int)m_nextEntry.dlcType), true);
        break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool fsc_Generation::Write2DB	(	fsc_Generation_t &	a_genData,
		fio_Transaction &	a_trans
	)

invoke next level write2DB and collect data for previous level

Definition at line 379 of file fsc_Generation.cpp.

References cmn_Num2Str(), fsc_NextEntity_t::dataType, dlc_Copy, dlc_MediaPos, dlc_Split, fsc_NextEntity_t::dlcType, ie_INVALID_ARG, log_FUNC_m, fsc_Entry::m_changed, m_dataType, fsc_Entry::m_entryMgr_p, m_migrationID, fsc_Entry::m_nextEntry, m_size, fsc_Generation_t::migrationID, fsc_Generation_t::nextEntity, NULL, fsc_Generation_t::size, fsc_MedPosMgr::Write2DB(), fsc_SplitMgr::Write2DB(), and fsc_CopyMgr::Write2DB().

Referenced by fsc_GenerationMgr::Write2DB().

                                                         {
    
//    log_DBG_m(dbg_DETAIL, "fsc_Generation::Write2DB ");
    bool vecIdxOrSizeChanged = false;

    if (m_entryMgr_p != NULL) {
//        log_DBG_m(dbg_DETAIL, "      m_entryMgr_p != NULL")

        // Write and check if changed next entryes first
        switch (m_nextEntry.dlcType) {

        case dlc_Copy : {
                fsc_CopyMgr *copyMgr_p = static_cast<fsc_CopyMgr*>(m_entryMgr_p);
                // update next level data 
                vecIdxOrSizeChanged = copyMgr_p->Write2DB(a_genData.nextEntity,
                                                          a_trans);
            }
            break;

        case dlc_Split : {
                fsc_SplitMgr *splitMgr_p = static_cast<fsc_SplitMgr*>(m_entryMgr_p);
                // update next level data 
                vecIdxOrSizeChanged = splitMgr_p->Write2DB(a_genData.nextEntity,
                                                           a_trans);
            }
            break;

        case dlc_MediaPos : {
                fsc_MedPosMgr *medPosMgr_p = static_cast<fsc_MedPosMgr*>(m_entryMgr_p);
                vecIdxOrSizeChanged = medPosMgr_p->Write2DB(a_genData.nextEntity);
            }
            break;

        default:
            log_FUNC_m(Write2DB);
            throw ivd_InternalError(ie_INVALID_ARG, 
                "Wrong dlcType =" + cmn_Num2Str((int)m_nextEntry.dlcType), true);
            break;
        }
        m_nextEntry = a_genData.nextEntity;
    }
    else { // index and size are the same as at construct time
//        log_DBG_m(dbg_DETAIL, "    m_entryMgr_p == NULL");
        a_genData.nextEntity = m_nextEntry;
    }
//    a_genData.nextEntity.Dbg();


    //set data, cause of moving vector. Doesn't mather if was not changed.
    a_genData.migrationID = m_migrationID;
    a_genData.size        = m_size;
    a_genData.nextEntity.dataType = m_dataType;

//    log_DBG_m(dbg_DETAIL, "WR MigID       = " << m_migrationID << endl <<
//                          "   File size   = " << m_size        << endl <<
//                          "   Data type   = " << hex << m_dataType  << dec  << endl);
    // if any data changed send message that was changed
//    log_DBG_m(dbg_DETAIL, " vecIdxOrSizeCahnged " << vecIdxOrSizeChanged
//                       << " m_changed " << m_changed);
    if (  vecIdxOrSizeChanged 
       || m_changed) {
        m_changed = false;
        return true;
    }

    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void fsc_Generation::Dump

(

ostream &

os

)

Definition at line 449 of file fsc_Generation.cpp.

References cmn_GetMigFlags(), dlc_Copy, dlc_MediaPos, dlc_Split, fsc_NextEntity_t::dlcType, fsc_MedPosMgr::Dump(), fsc_SplitMgr::Dump(), fsc_CopyMgr::Dump(), log_FUNC_m, m_dataType, fsc_Entry::m_entryMgr_p, m_migrationID, fsc_Entry::m_nextEntry, m_size, ReadMembers(), and cmn_Time::Time2YMDhms().

Referenced by fsc_GenerationMgr::Write2DB().

                                     {
    log_FUNC_m(Dump);

    ReadMembers();

//    log_DBG_m(dbg_DETAIL, "Generations : idx =" << a_dataL.generationIdx << endl <<
//        cmn_HexDump(g_gensData, firstVecSize * sizeof(fsc_Generation_t), sizeof(fsc_Generation_t), false) );
            
    cmn_Time t(m_migrationID >> 8);
    os << "       MigID           "  << m_migrationID << " " << t.Time2YMDhms() << ";" << (m_migrationID & 0xFF) << endl;
    os << "       Generation size "  << m_size << endl;
    os << "       Mig Flags:      "  << hex << m_dataType <<  dec << "  " 
        << cmn_GetMigFlags(m_dataType) << endl;

    switch (m_nextEntry.dlcType) {
    case dlc_Copy : {
//            a_copiesPos.resize(m_nextEntry.Vector.NumOfElement);
        fsc_CopyMgr *copyMgr_p = static_cast<fsc_CopyMgr*>(m_entryMgr_p);
        copyMgr_p->Dump(os);
        }
        break;

    case dlc_Split : {// TODO check copy ID and no of copies
        fsc_SplitMgr *splitMgr_p = static_cast<fsc_SplitMgr*>(m_entryMgr_p);
        splitMgr_p->Dump(os);
        }
        break;

    case dlc_MediaPos : {
        fsc_MedPosMgr *medPosMgr_p = static_cast<fsc_MedPosMgr*>(m_entryMgr_p);
        medPosMgr_p->Dump(os);
        }
        break;

    default:
        os << "           Wrong dlcType "  << (int)m_nextEntry.dlcType << endl;

        break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool fsc_Generation::TreeWalk

(

fsc_Collector &

a_collector

)

Definition at line 308 of file fsc_Generation.cpp.

References cmn_Num2Str(), dlc_Copy, dlc_MediaPos, dlc_Split, fsc_NextEntity_t::dlcType, ie_INVALID_ARG, log_FUNC_m, fsc_Entry::m_entryMgr_p, fsc_Entry::m_nextEntry, fsc_Collector::ProcObjGeneration(), ReadMembers(), fsc_MedPosMgr::TreeWalk(), fsc_SplitMgr::TreeWalk(), and fsc_CopyMgr::TreeWalk().

                                                          {
//    log_FUNC_m(TreeWalk);

    ReadMembers();

    if (!a_collector.ProcObjGeneration(this)) {
        return false;
    }
    switch (m_nextEntry.dlcType) {
    case dlc_Copy : {
        fsc_CopyMgr *copyMgr_p = static_cast<fsc_CopyMgr*>(m_entryMgr_p);
        return copyMgr_p->TreeWalk(a_collector);
        }
        break;

    case dlc_Split : {// TODO check copy ID and no of copies
        fsc_SplitMgr *splitMgr_p = static_cast<fsc_SplitMgr*>(m_entryMgr_p);
        return splitMgr_p->TreeWalk(a_collector);
        }
        break;

    case dlc_MediaPos : {
        fsc_MedPosMgr *medPosMgr_p = static_cast<fsc_MedPosMgr*>(m_entryMgr_p);
        return medPosMgr_p->TreeWalk(a_collector);
        }
        break;

    default:
        log_FUNC_m(TreeWalk);
        throw ivd_InternalError(ie_INVALID_ARG, 
            "Wrong dlcType =" + cmn_Num2Str((int)m_nextEntry.dlcType), true);
        break;
    }
    return true;
}

Here is the call graph for this function:

void fsc_Generation::ReadMembers

(

)

[private]

create and read next level members

Definition at line 345 of file fsc_Generation.cpp.

References cmn_Num2Str(), dbg_DETAIL, dlc_Copy, dlc_MediaPos, dlc_Split, fsc_NextEntity_t::dlcType, fsc_Vector_t::entryIdx, ie_INVALID_ARG, log_DBG_m, log_FUNC_m, m_dataType, fsc_Entry::m_entryMgr_p, fsc_Entry::m_nextEntry, NULL, fsc_Vector_t::numOfElement, and fsc_NextEntity_t::vector.

Referenced by Dump(), GetCopiesPos(), Insert(), Remove(), and TreeWalk().

                                 {
    log_FUNC_m(ReadMembers);

    log_DBG_m(dbg_DETAIL, "m_entryMgr_p = 0x" << hex << m_entryMgr_p
                       << " dlcType = 0x" << (int)m_nextEntry.dlcType << dec);
    if (m_entryMgr_p == NULL) {
            switch (m_nextEntry.dlcType) {
            case dlc_Copy :
                m_entryMgr_p = new fsc_CopyMgr(m_nextEntry.vector.numOfElement, 
                                               m_nextEntry.vector.entryIdx,
                                               m_dataType);
                break;

            case dlc_Split :
                m_entryMgr_p = new fsc_SplitMgr(m_nextEntry.vector.numOfElement, 
                                                m_nextEntry.vector.entryIdx);
                break;

            case dlc_MediaPos :
                m_entryMgr_p = new fsc_MedPosMgr(m_nextEntry);
                break;

            default:
                log_FUNC_m(ReadMembers);
                throw ivd_InternalError(ie_INVALID_ARG, 
                    "Wrong dlcType =" + cmn_Num2Str((int)m_nextEntry.dlcType), true);
                break;
            }
//        }
    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Member Data Documentation

ivd_MigrationID_t fsc_Generation::m_migrationID

Definition at line 45 of file fsc_Generation.h.

Referenced by fsc_GenerationMgr::CheckLastGen(), Dump(), fsc_GenerationMgr::GetCopiesPos(), GetCopiesPos(), fsc_SplitInfoCollector::ProcObjGeneration(), fsc_ColGeneration::ProcObjGenerationMgr(), and Write2DB().

ivd_FileSize_t fsc_Generation::m_size

the size of the file

Definition at line 48 of file fsc_Generation.h.

Referenced by Dump(), GetCopiesPos(), Insert(), fsc_SplitInfoCollector::ProcObjGeneration(), fsc_ColGeneration::ProcObjGenerationMgr(), and Write2DB().

ivd_DataType_t fsc_Generation::m_dataType

all data type that are stored in splits

Definition at line 51 of file fsc_Generation.h.

Referenced by Dump(), GetCopiesPos(), Insert(), fsc_SplitInfoCollector::ProcObjGeneration(), fsc_ColGeneration::ProcObjGenerationMgr(), ReadMembers(), and Write2DB().

fsc_Generation::log_CLASSID_m

Reimplemented from fsc_Entry.

Definition at line 54 of file fsc_Generation.h.

---

The documentation for this class was generated from the following files:

• fsc_Generation.h
• fsc_Generation.cpp