ff_basecollection.h

/*
 * File:   ff_basecollection.h
 * Author: Jari Williamsson
 *
 * Created on den 22 november 2010, 19:35
 */

#ifndef FF_BASECOLLECTION_H
#define FF_BASECOLLECTION_H

#include "ff_base.h"



class __FCCollection : public __FCIteratorBase
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    int _counter;

    int _arraysize;


    void _RequireElement(int no_of_required_elements);

    void _FreeElements();

protected:
    __FCBase** _pDataArray;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "__FCCollection"; }

    __FCCollection() : __FCIteratorBase()
    {
        _arraysize = 0;
        _counter = 0;
        _pDataArray = NULL;
    }

    virtual ~__FCCollection()
    {        
        _FreeElements();     
        if (_pDataArray) delete [] _pDataArray;
        _pDataArray = NULL;
        _counter = 0;
    }

    int GetCount() const { return _counter; }

    void Add(__FCBase *pNewItem);

    bool UniqueAdd(__FCBase *pNewItem)
    {
        if (!ElementExists(pNewItem))
        {
            Add(pNewItem);
            return true;
        }
        return false;
    }

    void InsertItemAt(__FCBase *pNewItem, int index);

    bool ElementExists(__FCBase* pQueryItem);

    void ClearAll()
    {
        _FreeElements();
        _counter = 0;
    }

    void DetachAll()
    {
        _counter = 0;
    }

    __FCBase* GetItemAt(int index);

    __FCBase* GetLastItem()
    {
        return GetItemAt(GetCount() - 1);
    }

    __FCBase* operator [] (int index)
    {
        return GetItemAt(index);
    }

        int GetIndexOf(__FCBase* pObject);

    __FCBase* DetachItemAt(int index);

    bool ClearItemAt(int index);

    int ToEndFrom(int index, FCIteratorHandler* pIterator);

    virtual int ForEach(FCIteratorHandler* pIterator);

    virtual int ForEachIndex(FCIteratorHandler* pIterator);

    virtual __FCBase* FindFirst(FCIteratorHandler* pIterator);

    __FCBase* FindUserData(void* data_to_find);

    bool Sort(FCIteratorHandler* pIterator);

    bool Swap(int index1, int index2)
    {
        if (index1 == index2) return false;
        if (index1 < 0 || index2 < 0) return false;
        if (index1 >= _counter || index2 >= _counter) return false;
        __FCBase* pObjectTemp = _pDataArray[index1];
        _pDataArray[index1] = _pDataArray[index2];
        _pDataArray[index2] = pObjectTemp;
        return true;
    }

    bool IsEmpty() { return (GetCount() == 0); }

    int MoveFrom(__FCCollection* pOtherCollection, bool unique = false)
    {
        int counter = 0;
        while (pOtherCollection->GetCount() > 0)
        {
            if (unique)
               counter += UniqueAdd(pOtherCollection->GetItemAt(0)) ? 1 : 0;
            else
            {
               Add(pOtherCollection->GetItemAt(0));
               counter ++;
            }
            pOtherCollection->DetachItemAt(0);
        }
        return counter;
    }

    bool IsIdentical(__FCCollection* pCompareCollection)
    {
        if (pCompareCollection->GetCount() != GetCount()) return false;
        for (int i = 0; i < GetCount(); i++)
        {
            __FCBase* pCurrent = GetItemAt(i);
            __FCBase* pCompare = pCompareCollection->GetItemAt(i);
            if (!pCurrent->IsIdentical(pCompare)) return false;
        }
        return true;
    }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCIteratorBase::DebugDump();
        DebugOutDigit("Array size: ", _arraysize);
        DebugOutDigit("Number of items: ", GetCount());
        for (int i = 0; i < GetCount(); i++)
        {
            __FCBase* pObject = GetItemAt(i);
            DebugOutDigit("===> Object item: ", i);
            pObject->DebugDump();
        }
    }
#endif
};


class FCNumbers : public __FCCollection
{        
    public:
        FCNumbers() : __FCCollection() { }

        FCNumber* GetItemAt(int index) { return (FCNumber*) __FCCollection::GetItemAt(index); }

        FCNumber* FindInt(int intvalue)
        {
            for (int i = 0; i < GetCount(); i++)
            {
                FCNumber* pNumber = GetItemAt(i);
                if (pNumber->GetInt() == intvalue) return pNumber;
            }
            return NULL;
        }

        FCNumber* AddUniqueInt(int intvalue)
        {
            FCNumber* pNumber = FindInt(intvalue);
            if (pNumber) return pNumber;
            pNumber = new FCNumber(intvalue);
            Add(pNumber);
            return pNumber;
        }
    
        void AddInt(int intvalue)
        {
            Add(new FCNumber(intvalue));
        }
    
        void AddFloat(float afloat)
        {
            FCNumber* pNumber = new FCNumber(0);
            pNumber->SetFloat(afloat);
            Add(pNumber);
        }

        void CopyFrom(FCNumbers* pNumbers);
    
        void SortNumerically(bool upwards);
};


#ifdef PDK_FRAMEWORK_TINYXML

class __FCCollectionTinyXML : public __FCCollection
{
public:
#ifdef PDK_FRAMEWORK_TINYXML

    virtual __FCBase* CreateElement() = 0;
#endif
    
    void StoreCollectionToXML(tinyxml2::XMLElement* pParentNode, const char* pszNameString)
    {
        pParentNode->DeleteChildren();
        for (int i = 0; i < GetCount(); i++)
        {
            tinyxml2::XMLElement* pItemNode = pParentNode->GetDocument()->NewElement(pszNameString);
            pParentNode->InsertEndChild(pItemNode);
            pItemNode->SetAttribute("CollectionIdx", i + 1);
            __FCBase* pObject = GetItemAt(i);
            pObject->StoreToXML(pItemNode); /* Call virtual method to store object data */
        }
    }

    void ReadCollectionFromXML(tinyxml2::XMLElement* pParentNode, const char* pszNameString)
    {
        ClearAll();
        
        tinyxml2::XMLElement* pChildNode = pParentNode->FirstChildElement(pszNameString);
        while (pChildNode)
        {            
            __FCBase* pObject = CreateElement();

            /* Call virtual method to read object data */
            if (pObject->ReadFromXML(pChildNode))
            {
                Add(pObject);
            }
            else
                delete pObject;
            
            pChildNode = pChildNode->NextSiblingElement(pszNameString);
        }
    }
};
#endif

class __FCCollectionData : public __FCCollection
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        EXTAG _customtag;
protected:
    virtual __FCBaseData* CreateElement() = 0;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    EXTAG GetCustomTag() { return _customtag; }
public:

    __FCCollectionData() : __FCCollection()
    {
        _customtag = 0;
    }

    virtual const char* ClassName() { return "__FCCollectionData"; }

    virtual int LoadAll();

    virtual bool SaveAll()
    {
        for (int i = 0; i < GetCount(); i++)
        {
            __FCBaseData* pObject = (__FCBaseData*) _pDataArray[i];
            pObject->SetCustomTag(_customtag);
            if (!pObject->Save()) return false;
        }
        return true;
    }

    void SetCustomTag(EXTAG tag) { _customtag = tag; }
};

#ifdef PDK_FRAMEWORK_ENTRIES
class FCNoteEntry;

class __FCCollectionEntryDetail : public __FCCollectionData
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
protected:
    FCNoteEntry* _pNoteEntry;  /* Used for LoadAll */
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "__FCCollectionEntryDetail"; }

    __FCCollectionEntryDetail(FCNoteEntry* pConnectEntry = NULL) : __FCCollectionData()
    {
        SetNoteEntry(pConnectEntry);
    }

    void SetNoteEntry(FCNoteEntry* pEntry) { _pNoteEntry = pEntry; }

    virtual int LoadAll();

    virtual void SaveNew();

        int LoadAllForEntryNumber(ENTNUM entnum);


    bool DestroyItemAt(int index);
};
#endif // #ifdef PDK_FRAMEWORK_ENTRIES


class __FCInciOther;

class __FCCollectionInciOther : public __FCCollectionData
{
public:
    virtual const char* ClassName() { return "__FCCollectionInciOther"; }

    virtual bool DeleteDataForItem(CMPER cmper);

    bool SaveDataAs(CMPER cmperfrom,
                        CMPER cmperto);

    virtual int LoadAllForItem(CMPER cmper);

    virtual bool SaveAllForItem(CMPER cmper);

    __FCInciOther* FindItemNo(CMPER cmper, twobyte inci);
};


class __FCNoInciOther;

class __FCCollectionNoInciOther : public __FCCollectionData
{
public:
    virtual const char* ClassName() { return "__FCCollectionNoInciOther"; }

    __FCNoInciOther* FindItemNo(CMPER cmper);

};


class __FCCollectionGlobal : public __FCCollectionData
{
public:
    virtual const char* ClassName() { return "__FCCollectionGlobal"; }
};




class __FCCollectionDetail : public __FCCollectionData
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#ifdef PDK_FRAMEWORK_ENTRIES
    FCNoteEntry* _pNoteEntry;  /* Used for LoadAll */
#endif
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "__FCCollectionDetail"; }

    __FCCollectionDetail() : __FCCollectionData()
    {
    }
};

class __FCCollectionPrefs : public __FCCollectionData
{
public:
    virtual const char* ClassName() { return "__FCCollectionPrefs"; }

    __FCCollectionPrefs() : __FCCollectionData()
    {
    }

};



class __FCCollectionNoInciDetail : public __FCCollectionDetail
{
public:
    virtual const char* ClassName() { return "__FCCollectionNoInciDetail"; }

    __FCCollectionNoInciDetail() : __FCCollectionDetail()
    {
    }

    virtual int LoadAllForItem(CMPER cmper1, CMPER cmper2base = 1);
};

class FCSettingsPairs : public __FCCollection
{
public:
    virtual const char* ClassName() { return "FCSettingsPairs"; }

    FCSettingsPair* FindPrefixedKey(const char* pszPrefix, int indexnumber)
    {
        FCString trystring;
        trystring.SetCString(pszPrefix);
        trystring.AppendInteger(indexnumber);
       for (int i = 0; i < GetCount(); i++)
       {
           FCSettingsPair* pPair = (FCSettingsPair*) GetItemAt(i);
           if (trystring.CompareNoCase(pPair->GetKeyString()) == 0)
           {
               return pPair;
           }
       }
        return NULL;
    }

    FCSettingsPair* FindKey(FCString* pKeyString)
    {
       for (int i = 0; i < GetCount(); i++)
       {
           FCSettingsPair* pPair = (FCSettingsPair*) GetItemAt(i);
           if (pKeyString->CompareNoCase(pPair->GetKeyString()) == 0)
           {
               return pPair;
           }
       }
        return NULL;
    }

    FCSettingsPair* AddKeyValue(FCString* pKeyString, FCString* pValueString)
    {
        FCSettingsPair* pFoundPair = FindKey(pKeyString);
        if (pFoundPair)
        {
            pFoundPair->SetValueString(pValueString);
            return pFoundPair;
        }
        FCSettingsPair* pNewPair = new FCSettingsPair(pKeyString, pValueString);
        Add(pNewPair);
        return pNewPair;
    }


    bool RetrieveBoolValue(FCString* pKeyString, bool* pValue)
    {
        FCSettingsPair* pKey = FindKey(pKeyString);
        if (!pKey) return false;
        *pValue = pKey->GetValueString()->IsEqual("1");
        return true;
    }

    bool RetrieveIntValue(FCString* pKeyString, int* pValue, int min = -1, int max = -1)
    {
        FCSettingsPair* pKey = FindKey(pKeyString);
        if (!pKey) return false;
        int value = pKey->GetValueString()->GetInteger();
        if (min < max)
        {
            /* Check for max/min values */
            if (value < min) value = min;
            if (value > max) value = max;
        }
        *pValue = value;
        return true;
    }

    void StoreBoolValue(FCString* pKeyString, bool boolvalue)
    {
        FCString valuestring;
        valuestring.SetInteger(boolvalue ? 1 : 0);
        AddKeyValue(pKeyString, &valuestring);
    }

    void StoreIntValue(FCString* pKeyString, int intvalue)
    {
        FCString valuestring;
        valuestring.SetInteger(intvalue);
        AddKeyValue(pKeyString, &valuestring);
    }
};


class FCStrings : public __FCCollection
{
public:
    FCStrings() : __FCCollection()
    {
    }

    bool AddCopy(FCString* pString)
    {
        if (!pString) return false;
        FCString* pNewString = new FCString();
        pNewString->SetString(pString);
        Add(pNewString);
        return false;
    }

    virtual const char* ClassName() { return "FCStrings"; }

    FCString* GetItemAt(int index) { return (FCString*) __FCCollection::GetItemAt(index); }

#ifdef PDK_FRAMEWORK_ENIGMASTRINGS

    bool ContainEnigmaFont()
    {
        for (int i = 0; i < GetCount(); i++)
        {
            FCString* pString = (FCString*) GetItemAt(i);
            if (pString->IsEnigmaFont()) return true;
        }
        return false;
    }
#endif

    FCSettingsPairs* CreateSettingsPairs()
    {
        FCSettingsPairs* pSettingsPairs = new FCSettingsPairs();
        for (int i = 0; i < GetCount(); i++)
        {
            FCString* pString = (FCString*) GetItemAt(i);
            int separatorposition = pString->FindFirst("=");
            if (separatorposition < 1) continue;
            FCString keystring, valuestring;
            keystring.SetString(pString);
            valuestring.SetString(pString);
            keystring.TruncateAt(separatorposition);
            valuestring.DeleteCharactersAt(0, separatorposition + 1);

            FCSettingsPair* pPair = new FCSettingsPair(&keystring, &valuestring);
            pSettingsPairs->Add(pPair);            
        }
        return pSettingsPairs;
    }

    FCString* CreateString(const char* pszSeparator = NULL)
    {
        FCString* pReturnString = new FCString;
        for (int i = 0; i < GetCount(); i++)
        {
            FCString* pString = (FCString*) GetItemAt(i);
            if (!pString) continue;
            pReturnString->AppendString(pString);
            if (pszSeparator && (i < (GetCount() - 1)))
            {
                pReturnString->AppendCString(pszSeparator);
            }
        }
        return pReturnString;
    }

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateString_GC(const char* pszSeparator = NULL);
#endif

    FCString* CreateRowsString(bool bNewLineAtEnd)
    {
        FCString* pReturnString = new FCString;
        for (int i = 0; i < GetCount(); i++)
        {
            FCString* pString = (FCString*) GetItemAt(i);
            if (pString) pReturnString->AppendString(pString);
            if (i < (GetCount() - 1))
            {
                pReturnString->AppendCString(pReturnString->GetEOL());
            }            
        }
        if (bNewLineAtEnd) pReturnString->AppendCString(pReturnString->GetEOL());
        return pReturnString;
    }

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateRowsString_GC(bool bNewLineAtEnd);
#endif

    FCString* Find(FCString* pFindString)
    {
        if (!pFindString) return NULL;
        for (int i = 0; i < GetCount(); i++)
        {
            FCString* pString = (FCString*) GetItemAt(i);
            if (!pString) continue;
            if (pString->IsEqualString(pFindString)) return pString;
        }
        return NULL;
    }

    FCString* FindNocase(FCString* pFindString)
    {
        if (!pFindString) return NULL;
        FCString findstring;
        findstring.SetString(pFindString);
        findstring.ToLowerCase();
        for (int i = 0; i < GetCount(); i++)
        {
            if (!GetItemAt(i)) continue;
            FCString string;
            string.SetString(GetItemAt(i));
            string.ToLowerCase();
            if (string.IsEqualString(&findstring)) return GetItemAt(i);
        }
        return NULL;
    }

    void CopyFrom(FCStrings* pSourceStrings)
    {
        if (!pSourceStrings) return;
        ClearAll();
        for (int i = 0; i < pSourceStrings->GetCount(); i++)
        {
            FCString* pSourceString = pSourceStrings->GetItemAt(i);
            if (pSourceString)
            {
                FCString* pNewString = new FCString();
                pNewString->SetString(pSourceString);
                Add(pNewString);
            }
            else
                Add(NULL);
        }
    }

    void TrimWhitespaceAll()
    {
        for (int i = 0; i < GetCount(); i++)
        {
            FCString* pString = GetItemAt(i);
            if (pString) pString->TrimWhitespace();
        }
    }

    void ClearEmptyStrings()
    {
        for (int i = GetCount() - 1; i >= 0; i--)
        {
            FCString* pString = GetItemAt(i);
            if (!pString)
            {
                ClearItemAt(i);
            }
            else if (pString->IsEmpty())
            {
                ClearItemAt(i);
            }
        }
    }

    void SortAlphabetical();

    void ParseEnigmaFontInfo(int index, FCFontInfo* pFontInfo);

#ifdef PDK_FRAMEWORK_STREAMS

    bool LoadSymbolFonts();
#endif

    bool LoadFolderFiles(FCString* pFolderString);

    bool LoadSubfolders(FCString* pFolderString);
    
    bool LoadSystemFontNames();
};


class FCNumberCollection : public __FCCollection
{
    public:
        virtual const char* ClassName() { return "FCNumberCollection"; }
};


#endif  /* FF_BASECOLLECTION_H */