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();
    
    __FCCollection(const __FCCollection&)
    {
        assert(false); // do not allow copy constructor on collections.
    }
 
    __FCCollection& operator=(const __FCCollection&)
    {
        assert(false); // do not allow operator= on collections.
        return *this;
    }
 
protected:
    __FCBase** _pDataArray;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { 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) const;
 
    __FCBase* GetLastItem() const
    {
        return GetItemAt(GetCount() - 1);
    }
 
    __FCBase* operator [] (int index) const
    {
        return GetItemAt(index);
    }
 
        int GetIndexOf(__FCBase* pObject) const;
 
    __FCBase* DetachItemAt(int index);
 
    bool ClearItemAt(int index);
 
    int ToEndFrom(int index, FCIteratorHandler* pIterator);
 
    int ForEach(FCIteratorHandler* pIterator) override;
 
    virtual int ForEachIndex(FCIteratorHandler* pIterator);
 
    __FCBase* FindFirst(FCIteratorHandler* pIterator) override;
 
    __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() const { 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(const __FCBase* pCompareObject) const override
    {
        const __FCCollection* pCompareCollection = dynamic_cast<const __FCCollection *>(pCompareObject);
        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
    void DebugDump() override
    {
        __FCIteratorBase::DebugDump();
        DebugOutInt("Array size: ", _arraysize);
        DebugOutInt("Number of items: ", GetCount());
        for (int i = 0; i < GetCount(); i++)
        {
            __FCBase* pObject = GetItemAt(i);
            DebugOutInt("===> Object item: ", i);
            pObject->DebugDump();
        }
    }
#endif
};
 
 
class FCNumbers : public __FCCollection
{        
        template<typename NUMTYPE>
        std::vector<NUMTYPE> _GetNumberTable() const
        {
            static_assert(std::is_floating_point<NUMTYPE>::value || std::is_integral<NUMTYPE>::value, "NUMTYPE must be either an integer or floating point type");
            std::vector<NUMTYPE> retval(GetCount());
            for (int i = 0; i < GetCount(); i++)
            {
                if constexpr(std::is_floating_point<NUMTYPE>::value)
                    retval[i] = static_cast<NUMTYPE>(GetItemAt(i)->GetFloat());
                else if constexpr(std::is_integral<NUMTYPE>::value)
                    retval[i] = static_cast<NUMTYPE>(GetItemAt(i)->GetInt());
                else
                    assert(false); // should never get here due to static_assert above, but piece o' the rock.
            }
            return retval;
        }
 
        template<typename NUMTYPE>
        void _SetNumberTable(const std::vector<NUMTYPE>& table)
        {
            static_assert(std::is_floating_point<NUMTYPE>::value || std::is_integral<NUMTYPE>::value, "NUMTYPE must be either an integer or floating point type");
            ClearAll();
            for (int i = 0; i < table.size(); i++)
            {
                if constexpr(std::is_floating_point<NUMTYPE>::value)
                    AddFloat(table[i]);
                else if constexpr(std::is_integral<NUMTYPE>::value)
                    AddInt(table[i]);
                else
                    assert(false); // should never get here due to static_assert above, but piece o' the rock.
            }
        }
 
    public:
        const char* ClassName() const override { return "FCNumbers"; }
   
        FCNumbers() : __FCCollection() { }
 
        FCNumber* GetItemAt(int index) const { 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 ClearInt(int intvalue)
                {
                        while (true)
                        {
                                FCNumber* pNumber = FindInt(intvalue);
                                if (!pNumber) return;                           
                                ClearItemAt(GetIndexOf(pNumber));
                        }
                }
 
                void ClearInts(FCNumbers* pNumbers)
                {
                        if (!pNumbers) return;
                        for (int i = 0; i < pNumbers->GetCount(); i++)
                        {
                                ClearInt(pNumbers->GetItemAt(i)->GetInt());
                        }
                }
    
        void AddFloat(double afloat)
        {
            Add(new FCNumber(afloat));
        }
 
        void CopyFrom(FCNumbers* pNumbers);
    
        void SortNumerically(bool upwards);
 
                bool HasIntDuplicates();
    
    std::vector<int> GetIntTable() const
    {
        return _GetNumberTable<int>();
    }
    
    void SetIntTable(const std::vector<int>& table)
    {
        _SetNumberTable<int>(table);
    }
 
    std::vector<double> GetFloatTable() const
    {
        return _GetNumberTable<double>();
    }
    
    void SetFloatTable(const std::vector<double>& table)
    {
        _SetNumberTable<double>(table);
    }
};
 
 
#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() const { return _customtag; }
public:
 
    __FCCollectionData() : __FCCollection()
    {
        _customtag = 0;
    }
 
    const char* ClassName() const override { 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:
    const char* ClassName() const override { return "__FCCollectionEntryDetail"; }
 
    __FCCollectionEntryDetail(FCNoteEntry* pConnectEntry = NULL) : __FCCollectionData()
    {
        SetNoteEntry(pConnectEntry);
    }
 
    void SetNoteEntry(FCNoteEntry* pEntry) { _pNoteEntry = pEntry; }
 
    int LoadAll() override;
 
    virtual void SaveNew();
 
        int LoadAllForEntryNumber(ENTNUM entnum);
 
 
    bool DestroyItemAt(int index);
};
#endif // #ifdef PDK_FRAMEWORK_ENTRIES
 
 
class __FCInciOther;
 
class __FCCollectionInciOther : public __FCCollectionData
{
public:
    const char* ClassName() const override { return "__FCCollectionInciOther"; }
 
    virtual bool DeleteDataForItem(CMPER cmper);
 
    bool SaveDataAs(CMPER cmperfrom,
                        CMPER cmperto);
 
    virtual int LoadAllForItem(CMPER cmper);
 
    virtual bool SaveAllForItem(CMPER cmper);
 
    CMPER SaveAllAsNew();
 
    __FCInciOther* FindItemNo(CMPER cmper, twobyte inci);
};
 
 
class __FCNoInciOther;
 
class __FCCollectionNoInciOther : public __FCCollectionData
{
public:
    const char* ClassName() const override { return "__FCCollectionNoInciOther"; }
 
    __FCNoInciOther* FindItemNo(CMPER cmper);
 
};
 
 
class __FCCollectionGlobal : public __FCCollectionData
{
public:
    const char* ClassName() const override { return "__FCCollectionGlobal"; }
};
 
 
 
 
class __FCCollectionDetail : public __FCCollectionData
{
public:
    const char* ClassName() const override { return "__FCCollectionDetail"; }
 
    __FCCollectionDetail() : __FCCollectionData()
    {
    }
};
 
class __FCCollectionPrefs : public __FCCollectionData
{
public:
    const char* ClassName() const override { return "__FCCollectionPrefs"; }
 
    __FCCollectionPrefs() : __FCCollectionData()
    {
    }
 
};
 
 
 
class __FCCollectionNoInciDetail : public __FCCollectionDetail
{
public:
    const char* ClassName() const override { return "__FCCollectionNoInciDetail"; }
 
    __FCCollectionNoInciDetail() : __FCCollectionDetail()
    {
    }
 
    virtual int LoadAllForItem(CMPER cmper1, CMPER cmper2base = 1);
};
 
class FCSettingsPairs : public __FCCollection
{
public:
    const char* ClassName() const override { 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(const FCString* pString)
    {
        if (!pString) return false;
        FCString* pNewString = new FCString();
        pNewString->SetString(pString);
        Add(pNewString);
        return true;
    }
 
    const char* ClassName() const override { return "FCStrings"; }
 
    FCString* GetItemAt(int index) const { return (FCString*) __FCCollection::GetItemAt(index); }
    
    void InsertStringAt(const FCString *pNewString, int index)
    {
        if (!pNewString) return;
        if (index < 0) return;
        FCString* pString = new FCString(*pNewString);
        __FCCollection::InsertItemAt(pString, 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_CPP
    luabridge::RefCountedPtr<FCString> CreateString_GC(const char* pszSeparator = NULL)
    { return makeLuaSharedPtr(CreateString(pszSeparator)); }
#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_CPP
    luabridge::RefCountedPtr<FCString> CreateRowsString_GC(bool bNewLineAtEnd)
    { return makeLuaSharedPtr(CreateRowsString(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 CopyFromStringTable(const std::vector<std::string> &strings)
    {
        ClearAll();
        for (int i = 0; i < strings.size(); i++)
        {
            FCString* pNewString = new FCString(strings[i].c_str());
            Add(pNewString);
        }
    }
 
    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:
        const char* ClassName() const override { return "FCNumberCollection"; }
};
 
 
#ifdef PDK_FRAMEWORK_ENTRIES
 
class FCNoteEntryCell;
 
class FCNoteEntryCellMetrics : public __FCCollection
{
        bool _loaded;
 
    // This value remains global because it is a global condition in Finale. Whichever concurrently
    // running script sets it, the next internal call to metrics will rebuild them.
        static bool _updatemetrics;
 
 
public:
        const char* ClassName() const override { return "FCNoteEntryCellMetrics"; }
 
        FCNoteEntryCellMetrics();
 
        virtual ~FCNoteEntryCellMetrics()
        {
        }
 
        bool Load(FCNoteEntryCell* pEntryCell);
 
        FCEntryMetrics* FindMetricsForEntry(FCNoteEntry* pEntry);
 
 
        FCEntryMetrics* GetItemAt(int index) const { return (FCEntryMetrics*)__FCCollection::GetItemAt(index); }
};
#endif
 
 
class FCCppGarbageCollector : public __FCCollection
{
public:
        /* The constructor */
        FCCppGarbageCollector() : __FCCollection() {}
 
        __FCBase* GC_Add(__FCBase* pObject)
        {
                if (!pObject) return NULL;
                __FCCollection::Add(pObject);
                return pObject;
        }
};
 
 
class FCRanges : public __FCCollection
{
public:
    const char* ClassName() const override { return "FCRanges"; }
    
    FCRanges() : __FCCollection() { }
    
    FCRange* GetItemAt(int index) const { return (FCRange*) __FCCollection::GetItemAt(index); }
};
 
class FCChordSuffixKeyNumberOffsets : public FCNumbers
{
    CMPER _cmper;
    
public:
    const char* ClassName() const override { return "FCChordSuffixKeyNumberOffsets"; }
    
    FCChordSuffixKeyNumberOffsets() : FCNumbers(), _cmper(0) { }
    
    bool Load(CMPER suffixno);
    
    bool Save();
    
    bool SaveAs(CMPER suffixno)
    {
        _cmper = suffixno;
        return Save();
    }
    
    CMPER GetChordSuffixID() const { return _cmper; }
};
 
#endif  /* FF_BASECOLLECTION_H */