arr.h

// Copyright (c) 2014 Yasser Asmi
// Released under the MIT License (http://opensource.org/licenses/MIT)

#ifndef _ARR_H
#define _ARR_H

#include "util.h"
#include "var.h"
#include "str.h"

namespace jvar
{

class BArray
{
public:
    typedef int (*Compare)(const void*, const void*);

    BArray(size_t elemsize, Compare comp) :
        mMemPtr(NULL),
        mElemSize((int)elemsize),
        mMaxLen(0),
        mComp(comp),
        mCountLocal(0),
        mFlags(0)
    {
        mCountPtr = &mCountLocal;
    }
    ~BArray()
    {
    }
    inline BArray(const BArray& src)
    {
        copyFrom((BArray&)src, false, false);
    }
    inline BArray(BArray& src)
    {
        copyFrom(src, false, false);
    }
    inline BArray& operator=(const BArray& src)
    {
        copyFrom((BArray&)src, false, false);
        return *this;
    }
    inline BArray& operator=(const BArray* src)
    {
        copyFrom((BArray&)*src, false, false);
        return *this;
    }

    void useFixedMem(void* memptr, int* countptr, int maxlen);

    void clear();

    void* insert(int pos, const void* elem);

    inline void* append(const void* elem)
    {
        return insert(length(), elem);
    }

    inline void* add(const void* elem)
    {
        return addOrModify(elem, false);
    }

    void* addOrModify(const void* elem, bool modifyfound = true);

    bool remove(int pos);

    bool remove(const void* elem);

    void* find(const void* elem);

    inline void* get(int pos)
    {
        return (char*)mMemPtr + pos * mElemSize;
    }

    inline int length()
    {
        return *mCountPtr;
    }

    inline bool full()
    {
        return (*mCountPtr >= mMaxLen);
    }

    inline void sort(Compare comp = NULL)
    {
        if (comp == NULL)
        {
            comp = mComp;
        }
        assert(comp);
        qsort(mMemPtr, *mCountPtr, mElemSize, comp);
    }

    inline bool findPos(const void* findelem, int& pos)
    {
        return binSearch(findelem, pos);
    }

    inline void reserve(int elemcount)
    {
        if (elemcount > mMaxLen)
        {
            ensureAlloc(elemcount);
        }
    }

private:
    void* mMemPtr;
    int mElemSize;
    int* mCountPtr;
    int mMaxLen;
    Compare mComp;
    int mCountLocal;
    Buffer mBuf;

public:
    uint mFlags;

public:
    enum
    {
        FLAG_FIXEDBUF = 0x1
    };

protected:
    void copyFrom(BArray& src, bool alloconly, bool move);
    bool binSearch(const void* findelem, int& pos);
    void ensureAlloc(int desiredlen);


};

template <class T>
class Iter
{
public:
    Iter() :
        mPos(-1),
        mObj(NULL),
        mKey(NULL)
    {
    }
    inline T* operator->()
    {
        return mObj;
    }
    inline T& operator*()
    {
        return *mObj;
    }
    inline T* operator&()
    {
        return mObj;
    }
    inline int pos()
    {
        return mPos;
    }
    inline const char* key()
    {
        return mKey;
    }

public:
    int mPos;
    T* mObj;
    const char* mKey;
};


template <class T>
class ObjArray : public BArray
{
public:
    inline ObjArray() :
        BArray(sizeof(T), NULL),
        mSupportImpl(NULL)
    {
    }

    inline ObjArray(Compare comp) :
        BArray(sizeof(T), comp),
        mSupportImpl(NULL)
    {
    }

    inline ObjArray(const ObjArray& src) :
        BArray(sizeof(T), NULL)
    {
        copyFrom((ObjArray&)src);
    }

    inline ObjArray(ObjArray& src) :
        BArray(sizeof(T), NULL)
    {
        copyFrom(src);
    }

    inline ObjArray& operator=(const ObjArray& src)
    {
        copyFrom((ObjArray&)src);
        return *this;
    }
    inline ObjArray& operator=(const ObjArray* src)
    {
        copyFrom(*src);
        return *this;
    }

    ~ObjArray()
    {
        // Call the destructor for all objects in the array.

        for (int i = 0; i < BArray::length(); i++)
        {
            T* obj = (T*)BArray::get(i);
            obj->~T();
        }

        delete mSupportImpl;
    }

    inline T* insert(int pos)
    {
        T* obj = (T*)BArray::insert(pos, NULL);

        // Inplace new the object using default constructor.

        return new(obj) T();
    }

    inline T* insertCustom(int pos)
    {

        return (T*)BArray::insert(pos, NULL);
    }

    inline T* append()
    {
        T* obj = (T*)BArray::append(NULL);

        // Inplace new the object using default constructor.

        return new(obj) T();
    }

    T* addOrModify(const T* keyelem, bool modifyfound = true)
    {
        int pos;

        if (BArray::binSearch(keyelem, pos))
        {
            if (modifyfound)
            {
                return get(pos);
            }
            else
            {
                return NULL;
            }
        }

        T* obj = (T*)BArray::insert(pos, NULL);

        // Inplace new the object using copy constructor.

        return new(obj) T(*keyelem);
    }

    inline T* add(const T* keyelem)
    {
        return addOrModify(keyelem, false);
    }

    inline bool remove(const T* keyelem)
    {
        int pos;
        if (!binSearch(keyelem, pos))
        {
            return false;
        }
        return remove(pos);
    }

    inline bool remove(int pos)
    {
        T* obj = get(pos);
        if (obj == NULL)
        {
            return NULL;
        }

        // Call the destructor.

        obj->~T();

        // Delete the item from the array.

        return BArray::remove(pos);
    }

    inline T* find(const T* elem)
    {
        return (T*)BArray::find(elem);
    }

    inline T* get(int pos)
    {
        // Bounds check.

        if ((uint)pos >= length())
        {
            return NULL;
        }
        return (T*)BArray::get(pos);
    }

    bool forEach(Iter<T>& iter)
    {
        iter.mPos++;
        if (iter.mPos < length())
        {
            iter.mObj = get(iter.mPos);

            // Key is not available

            return true;
        }
        return false;
    }

    bool forEachReverse(Iter<T>& iter)
    {
        if (iter.mPos == -1)
        {
            iter.mPos = length();
        }
        iter.mPos--;
        if (iter.mPos >= 0)
        {
            iter.mObj = get(iter.mPos);
            // Key is not available
            return true;
        }
        return false;
    }

    inline InterfaceImpl* setSupportImpl(InterfaceImpl* impl)
    {
        delete mSupportImpl;
        mSupportImpl = impl;
        return mSupportImpl;
    }

    inline InterfaceImpl* getSupportImpl()
    {
        return mSupportImpl;
    }
protected:
    InterfaceImpl* mSupportImpl;
private:

    void copyFrom(ObjArray& src)
    {
        // Init the base array, alloc memory but do not copy the elements

        BArray::copyFrom(src, true, false);

        // Call the copy constructors

        for (int i = 0; i < BArray::length(); i++)
        {
            T* obj = (T*)BArray::get(i);
            T* srcobj = (T*)src.get(i);

            // Inplace new the object using its copy constructor.

            new(obj) T(*srcobj);
        }

        // Make a copy of the support interface.

        if (src.mSupportImpl)
        {
            delete mSupportImpl;
            mSupportImpl = src.mSupportImpl->newImpl();
        }
    }
};


template <class T>
class PropArray
{
public:
    PropArray() :
        mData(NULL),
        mIndex(NULL),
        mSupp(NULL)
    {
        mData.reserve(INITSIZE);
        mIndex.reserve(INITSIZE);
    }

    ~PropArray()
    {
    }

    T* addOrModify(const char* keyname, bool modifyfound = true)
    {
        // Find the item in the index.
        int pos;

        if (indexFindPos(keyname, pos))
        {
            // Key was found in the index, return the item pointed to by the key.  If not allowed
            // to update the existing item, return NULL.

            if (modifyfound)
            {
                DataElem* dat = indexGet(pos);
                if (dat)
                {
                    return &(dat->value);
                }
            }
            return NULL;
        }

        // Insert a new data element at the end (this will call default constructor).
        // Record the current length into the key that will be added to the index.

        int addloc = mData.length();

        DataElem* dat = mData.insert(addloc);

        // Set the key in the data object.

        dat->key.set(keyname);

        // Now, add the key to the index at the position determined by binary search earlier.

        int* index = mIndex.insert(pos);
        if (index)
        {
            *index = addloc;
        }

        // return a pointer to the value portion.

        return &(dat->value);
    }

    inline T* add(const char* keyname)
    {
        return addOrModify(keyname, false);
    }

    inline bool remove(const char* keyname)
    {
        int pos;
        if (indexFindPos(keyname, pos))
        {
            int* index = mIndex.get(pos);
            if (index)
            {
                mIndex.remove(pos);
                return mData.remove(*index);
            }
        }
        return false;
    }

    inline T* get(const char* keyname)
    {
        int pos;
        if (indexFindPos(keyname, pos))
        {
            DataElem* dat = indexGet(pos);
            if (dat)
            {
                return &(dat->value);
            }
        }

        return NULL;
    }

    inline T* get(int pos)
    {
        DataElem* dat = mData.get(pos);
        if (dat)
        {
            return &(dat->value);
        }
        return NULL;
    }

    inline const char* getKey(int pos)
    {
        DataElem* dat = mData.get(pos);
        if (dat)
        {
            return dat->key.get();
        }
        return NULL;
    }

    inline int length()
    {
        return mData.length();
    }

    bool forEachSort(Iter<T>& iter)
    {
        iter.mPos++;
        if (iter.mPos < mIndex.length())
        {
            DataElem* dat = indexGet(iter.mPos);
            if (dat)
            {
                iter.mObj = &(dat->value);
                iter.mKey = dat->key.get();
                return true;
            }
        }
        return false;
    }

    bool forEach(Iter<T>& iter)
    {
        iter.mPos++;
        if (iter.mPos < mData.length())
        {
            DataElem* dat = mData.get(iter.mPos);
            if (dat)
            {
                iter.mObj = &(dat->value);
                iter.mKey = dat->key.get();
                return true;
            }
        }
        return false;
    }

    inline void clear()
    {
        mData.clear();
        mIndex.clear();
        mClassName.clear();
        mSupp = NULL;
    }

    inline void setClassName(const char* name)
    {
        mClassName.set(name);
    }
    inline const char* getClassName()
    {
        return mClassName.get();
    }

    inline void setSuppData(void* supp)
    {
        mSupp = supp;
    }
    inline void* getSuppData()
    {
        return mSupp;
    }
    inline InterfaceImpl* setSupportImpl(InterfaceImpl* impl)
    {
        return mData.setSupportImpl(impl);
    }

    inline InterfaceImpl* getSupportImpl()
    {
        return mData.getSupportImpl();
    }
private:
    enum
    {
        INITSIZE = 2,   //TODO: consider making this 0
        FIXEDSTRSIZE = 24
    };

    typedef FixedStr<FIXEDSTRSIZE> PropKeyStr;
    struct DataElem
    {
        PropKeyStr key;
        T value;
    };

    ObjArray<DataElem> mData;
    ObjArray<int> mIndex;
    PropKeyStr mClassName;
    void* mSupp;

private:

    bool indexFindPos(const char* findelem, int& pos)
    {
        if (mIndex.length() == 0 || findelem == NULL)
        {
            pos = 0;
            return false;
        }

        int low = 0;
        int high = mIndex.length() - 1;
        while (low <= high)
        {
            int mid = (low + high) / 2;

            // Get the keyName which is stored at this index position
            // in the data array.

            DataElem* dat = indexGet(mid);

            int res = strcmp(dat->key.get(), findelem);

            if (res == 0)
            {
                pos = mid;
                return true;
            }
            else if (res < 0)
            {
                low = mid + 1;
            }
            else
            {
                high = mid - 1;
            }
        }

        pos = low;
        return false;
    }

    inline DataElem* indexGet(int pos)
    {
        int* index = mIndex.get(pos);
        if (index)
        {
            return mData.get(*index);
        }
        return NULL;
    }
};


class StrArray : public ObjArray<std::string>
{
public:
    StrArray() :
        ObjArray(StrArray::compare)
    {
    }

    inline std::string* add(const char* keyelem)
    {
        std::string s(keyelem);
        return ObjArray<std::string>::add(&s);
    }
    inline bool remove(const char* keyelem)
    {
        std::string s(keyelem);
        return ObjArray<std::string>::remove(&s);
    }
    inline std::string* find(const char* elem)
    {
        std::string s(elem);
        return ObjArray<std::string>::find(&s);
    }

public:
    static
    int compare(const void* e1, const void* e2)
    {
        const std::string* s1 = (std::string*)e1;
        const std::string* s2 = (std::string*)e2;

        return s1->compare(s2->c_str());
    }
};


class KeywordArray
{
public:
    struct Entry
    {
        const char* keyword;
        uint value;
    };

    KeywordArray(const Entry* arr, size_t arrsize) :
        mArr(arr),
        mArrSize(arrsize)
    {
        assert(arr && arrsize != 0);
    }

    uint toValue(const char* keyword)
    {
        assert(keyword);
        for (size_t i = 0; i < mArrSize; i++)
        {
            if (strcasecmp(keyword, mArr[i].keyword) == 0)
            {
                return mArr[i].value;
            }
        }
        return (uint)-1;
    }

    const char* toKeyword(uint value)
    {
        for (size_t i = 0; i < mArrSize; i++)
        {
            if (value == mArr[i].value)
            {
                return mArr[i].keyword;
            }
        }
        return NULL;
    }

private:
    const Entry* mArr;
    size_t mArrSize;
};

} // jvar

#endif // _ARR_H