void FAWbdConfKeeper::Initialize()

in blingfireclient.library/src/FAWbdConfKeeper.cpp [56:232]
157 lines of code
30 McCabe index (conditional complexity)

void FAWbdConfKeeper::Initialize (const FALDB * pLDB, const int * pValues, const int Size)
{
    LogAssert (pLDB);
    LogAssert (pValues || 0 >= Size);

    int FsmType = FAFsmConst::TYPE_MOORE_DFA;
    const unsigned char * pFsmDump = NULL;

    FAWbdConfKeeper::Clear ();

    for (int i = 0; i < Size; ++i) {

        const int Param = pValues [i];

        switch (Param) {

        case FAFsmConst::PARAM_MAP_MODE:
        {
            const int MMType = pValues [++i];
            LogAssert (FAFsmConst::MODE_PACK_TRIV == MMType);
            break;
        }
        case FAFsmConst::PARAM_DEPTH:
        {
            m_MaxDepth = pValues [++i];
            LogAssert (0 <= m_MaxDepth);
            break;
        }
        case FAFsmConst::PARAM_MAX_LENGTH:
        {
            m_MaxTokenLength = pValues [++i];
            LogAssert (0 <= m_MaxTokenLength);
            break;
        }
        case FAFsmConst::PARAM_IGNORE_CASE:
        {
            m_IgnoreCase = true;
            break;
        }
        case FAFsmConst::PARAM_FSM_TYPE:
        {
            FsmType = pValues [++i];
            LogAssert (FAFsmConst::TYPE_MOORE_DFA == FsmType ||
                FAFsmConst::TYPE_MOORE_MULTI_DFA == FsmType);
            break;
        }
        case FAFsmConst::PARAM_FSM:
        {
            const int DumpNum = pValues [++i];
            pFsmDump = pLDB->GetDump (DumpNum);
            LogAssert (pFsmDump);

            if (!m_pRsDfa) {
                m_pRsDfa = new FARSDfa_pack_triv;
                LogAssert (m_pRsDfa);
            }
            m_pRsDfa->SetImage (pFsmDump);
            m_pRsDfaA = m_pRsDfa;

            break;
        }
        case FAFsmConst::PARAM_MULTI_MAP:
        {
            const int DumpNum = pValues [++i];
            const unsigned char * pDump = pLDB->GetDump (DumpNum);
            LogAssert (pDump);

            if (!m_pMMapTriv) {
                m_pMMapTriv = new FAMultiMap_pack;
                LogAssert (m_pMMapTriv);
            }
            m_pMMapTriv->SetImage (pDump);
            m_pMMapA = m_pMMapTriv;

            break;
        }
        case FAFsmConst::PARAM_CHARMAP:
        {
            const int DumpNum = pValues [++i];
            const unsigned char * pDump = pLDB->GetDump (DumpNum);
            LogAssert (pDump);

            if (!m_pCharMap) {
                m_pCharMap = new FAMultiMap_pack_fixed;
                LogAssert (m_pCharMap);
            }
            m_pCharMap->SetImage (pDump);

            break;
        }
        case FAFsmConst::PARAM_ACT_DATA:
        {
            const int DumpNum = pValues [++i];
            const unsigned char * pDump = pLDB->GetDump (DumpNum);
            LogAssert (pDump);

            if (!m_pActData) {
                m_pActData = new FAMultiMap_pack;
                LogAssert (m_pActData);
            }
            m_pActData->SetImage (pDump);
            m_pActDataCA = m_pActData;
            break;
        }
        case FAFsmConst::PARAM_PUNKT:
        {
            m_TagPunkt = pValues [++i];
            break;
        }
        case FAFsmConst::PARAM_EOS:
        {
            m_TagEos = pValues [++i];
            break;
        }
        case FAFsmConst::PARAM_EOP:
        {
            m_TagEop = pValues [++i];
            break;
        }
        case FAFsmConst::PARAM_WORD:
        {
            m_TagWord = pValues [++i];
            break;
        }
        case FAFsmConst::PARAM_XWORD:
        {
            m_TagXWord = pValues [++i];
            break;
        }
        case FAFsmConst::PARAM_SEG:
        {
            const int Tag = pValues [++i];
            m_TagSeg = Tag;
            break;
        }
        case FAFsmConst::PARAM_IGNORE:
        {
            m_TagIgnore = pValues [++i];
            break;
        }
        case FAFsmConst::PARAM_MAX_TAG:
        {
            m_MaxTag = pValues [++i];
            break;
        }

        default:
            LogAssert (false);
        }
    } // of for (int i = 0; ...

    /// create an appropriate reaction map, if needed
    if (NULL == pFsmDump) {
        return;
    }

    if (FAFsmConst::TYPE_MOORE_DFA == FsmType) {
        if (!m_pState2Ow) {
            m_pState2Ow = new FAState2Ow_pack_triv;
            LogAssert (m_pState2Ow);
        }
        m_pState2Ow->SetImage (pFsmDump);
        m_pState2OwA = m_pState2Ow;
    } else if (FAFsmConst::TYPE_MOORE_MULTI_DFA == FsmType) {
        if (!m_pState2Ows) {
            m_pState2Ows = new FAState2Ows_pack_triv;
            LogAssert (m_pState2Ows);
        }
        m_pState2Ows->SetImage (pFsmDump);
    } else {
        // wrong FsmType value
        LogAssert (false);
    }

    // calculates functions' initial states
    CalcFnIniStates ();
}