new.cc

#include <string.h>
#include <errno.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <algorithm>
#include <unordered_map>
#include <iostream>
#include <expat.h>
#include <cstring>

// Define UINT32 if it's not already defined
#ifndef UINT32
#define UINT32 unsigned int
#endif

#define EQUAL 0

#define SHT_NUM_OF_SEM 2
#define SHT_SEM_FLG SEM_UNDO
#define SHT_SEM_SET -1
#define SHT_SEM_RESET 1

#ifdef XML_LARGE_SIZE
#if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400
#define XML_FMT_INT_MOD "I64"
#else
#define XML_FMT_INT_MOD "ll"
#endif
#else
#define XML_FMT_INT_MOD "l"
#endif

#ifndef XMLCALL
#if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__)
#define XMLCALL __cdecl
#elif defined(__GNUC__)
#define XMLCALL __attribute__((cdecl))
#else
#define XMLCALL
#endif
#endif

using namespace std;

class KeyHash
{
public:
    size_t operator()(const char *s) const
    {
        unsigned int h = 0;
        for (; *s; ++s)
            h = 5 * h + *s;

        return size_t(h);
    }
};

class KeyEqual
{
public:
    bool operator()(const char *s1, const char *s2) const
    {
        return (strcmp(s1, s2) == EQUAL);
    }
};

enum HashTableError
{
    SHT_FAILURE = 0,
    SHT_SUCCESS,
    SHT_OVERFLOW,
    SHT_KEY_ALREADY_EXIST,
    SHT_NO_DATA_FOUND
};

class HashTable
{
protected:
    typedef struct
    {
        char mKey[256];   // Adjust the key size as needed
        char mValue[256]; // Adjust the value size as needed
        int mNextIdx;
    } DataNode;

    typedef struct
    {
        int mNextFreeIdx;
        int mLastFreeIdx;
        int mNumOfRecords;
    } NodeMgmtQueueHeader;

    typedef struct
    {
        NodeMgmtQueueHeader *HeaderPtr;
        int *mpFreeNodeArray;
    } NodeMgmtQueue;

    typedef KeyHash hasher;
    typedef KeyEqual keyEqual;

    int *mpIndexTablePtr;
    DataNode *mpDataPoolPtr;
    NodeMgmtQueue *mpNodeMgmtQueuePtr;
    NodeMgmtQueueHeader *mpNodeMgmtQueueHeaderPtr;

    hasher hash;
    keyEqual equal;
    int mMaxPoolSize;
    int mMaxIndex;
    float mLoadFactor;
    int mSemId;
    struct sembuf mSet;
    struct sembuf mReset;

public:
    HashTable(int bucketCount, float loadFactor, int semId)
    {
        mMaxPoolSize = bucketCount + 2;
        mLoadFactor = loadFactor;
        mMaxIndex = (int)(mMaxPoolSize * mLoadFactor);
        mpNodeMgmtQueuePtr = new NodeMgmtQueue();
    }

    int SetSemaphoreId(int semId)
    {
        mSemId = semget(semId, SHT_NUM_OF_SEM, 0666 | IPC_CREAT);
        if (-1 == mSemId)
        {
            return SHT_FAILURE;
        }
        return SHT_SUCCESS;
    }

    int SetBucketCount(int bucketCount)
    {
        mMaxPoolSize = bucketCount + 2;
        mMaxIndex = (int)(mMaxPoolSize * mLoadFactor);
        return SHT_SUCCESS;
    }

    int SetLoadFactor(float loadFactor)
    {
        mLoadFactor = loadFactor;
        mMaxIndex = (int)(mMaxPoolSize * mLoadFactor);
        return SHT_SUCCESS;
    }

    int GetHashTableSize()
    {
        int lIndexTableSize;
        int lDataPoolSize;
        int lNodeMgmtQueueSize;
        int lTotalSize;

        lIndexTableSize = mMaxIndex * sizeof(int);
        lDataPoolSize = sizeof(DataNode) * (mMaxPoolSize + 1);
        lNodeMgmtQueueSize = sizeof(NodeMgmtQueueHeader) + (sizeof(int) * (mMaxPoolSize + 1));
        lTotalSize = lIndexTableSize + lDataPoolSize + lNodeMgmtQueueSize;

        return lTotalSize;
    }

    int SetHashMemoryPtr(void *PoolPtr, bool init)
    {
        int i;

        if (PoolPtr == NULL)
        {
            return SHT_FAILURE;
        }

        mpIndexTablePtr = (int *)PoolPtr;
        mpDataPoolPtr = (DataNode *)(mpIndexTablePtr + mMaxIndex);
        mpNodeMgmtQueueHeaderPtr = (NodeMgmtQueueHeader *)(mpDataPoolPtr + (mMaxPoolSize + 1));
        mpNodeMgmtQueuePtr->HeaderPtr = mpNodeMgmtQueueHeaderPtr;
        mpNodeMgmtQueuePtr->mpFreeNodeArray = (int *)(mpNodeMgmtQueueHeaderPtr + 1);

        if (init)
        {
            for (i = 0; i < mMaxIndex; i++)
            {
                mpIndexTablePtr[i] = 0;
            }

            for (i = 0; i <= mMaxPoolSize; i++)
            {
                mpDataPoolPtr[i].mNextIdx = 0;
                memset(&(mpDataPoolPtr[i].mKey), 0, sizeof(mpDataPoolPtr[i].mKey));
                memset(&(mpDataPoolPtr[i].mValue), 0, sizeof(mpDataPoolPtr[i].mValue));
                mpNodeMgmtQueuePtr->mpFreeNodeArray[i] = i;
            }

            mpNodeMgmtQueuePtr->HeaderPtr->mNextFreeIdx = 1;
            mpNodeMgmtQueuePtr->HeaderPtr->mLastFreeIdx = 1;
            mpNodeMgmtQueuePtr->HeaderPtr->mNumOfRecords = 0;
        }

        return SHT_SUCCESS;
    }

    int Insert(const char *key, const char *value)
    {
        int lHashValue = 0;
        int lFreeIdx = 0;
        int lIndexValue = 0;
        int lLastOccupiedIdx = 0;

        SetSem();

        lHashValue = hash(key);
        lIndexValue = lHashValue % mMaxIndex;

        if (mpNodeMgmtQueuePtr->mpFreeNodeArray[mpNodeMgmtQueuePtr->HeaderPtr->mNextFreeIdx] == 0)
        {
            UINT32 lTempIndex = mpNodeMgmtQueuePtr->HeaderPtr->mNextFreeIdx;

            if (mpNodeMgmtQueuePtr->HeaderPtr->mNumOfRecords == mMaxPoolSize)
            {
                ResetSem();
                return SHT_OVERFLOW;
            }

            UpdateNodeMgmtQueueIdx(&(mpNodeMgmtQueuePtr->HeaderPtr->mNextFreeIdx));
            while (mpNodeMgmtQueuePtr->mpFreeNodeArray[mpNodeMgmtQueuePtr->HeaderPtr->mNextFreeIdx] == 0)
            {
                if (lTempIndex == mpNodeMgmtQueuePtr->HeaderPtr->mNextFreeIdx)
                {
                    ResetSem();
                    return SHT_OVERFLOW;
                }

                UpdateNodeMgmtQueueIdx(&(mpNodeMgmtQueuePtr->HeaderPtr->mNextFreeIdx));
            }
        }
        else
        {
            lFreeIdx = mpNodeMgmtQueuePtr->mpFreeNodeArray[mpNodeMgmtQueuePtr->HeaderPtr->mNextFreeIdx];
            mpNodeMgmtQueuePtr->mpFreeNodeArray[mpNodeMgmtQueuePtr->HeaderPtr->mNextFreeIdx] = 0;
            UpdateNodeMgmtQueueIdx(&(mpNodeMgmtQueuePtr->HeaderPtr->mNextFreeIdx));
            mpNodeMgmtQueuePtr->HeaderPtr->mNumOfRecords++;
        }

        if (mpIndexTablePtr[lIndexValue] == 0)
        {
            mpIndexTablePtr[lIndexValue] = lFreeIdx;
            strcpy(mpDataPoolPtr[lFreeIdx].mKey, key);
            strcpy(mpDataPoolPtr[lFreeIdx].mValue, value);
            mpDataPoolPtr[lFreeIdx].mNextIdx = 0;
        }
        else
        {
            lLastOccupiedIdx = mpIndexTablePtr[lIndexValue];
            while (equal(mpDataPoolPtr[lLastOccupiedIdx].mKey, key) || mpDataPoolPtr[lLastOccupiedIdx].mNextIdx != 0)
            {
                if (equal(mpDataPoolPtr[lLastOccupiedIdx].mKey, key))
                {
                    mpNodeMgmtQueuePtr->mpFreeNodeArray[mpNodeMgmtQueuePtr->HeaderPtr->mLastFreeIdx] =
                        lFreeIdx;
                    UpdateNodeMgmtQueueIdx(&(mpNodeMgmtQueuePtr->HeaderPtr->mLastFreeIdx));
                    mpNodeMgmtQueuePtr->HeaderPtr->mNumOfRecords--;
                    ResetSem();
                    return SHT_KEY_ALREADY_EXIST;
                }
                else
                {
                    lLastOccupiedIdx = mpDataPoolPtr[lLastOccupiedIdx].mNextIdx;
                }
            }
            strcpy(mpDataPoolPtr[lFreeIdx].mKey, key);
            strcpy(mpDataPoolPtr[lFreeIdx].mValue, value);
            mpDataPoolPtr[lLastOccupiedIdx].mNextIdx = lFreeIdx;
            mpDataPoolPtr[lFreeIdx].mNextIdx = 0;
        }

        ResetSem();
        return SHT_SUCCESS;
    }

    // Define other member functions here
};

class XmlParser
{
    // Define XML parsing functions here
};

int main()
{
    // Define your main program logic here
    return 0;
}

for (UINT8 lByteIndex = 0; lByteIndex < lAddrLen; lByteIndex += 2, lWriteIdx++)
{
    param[lWriteIdx] = BYTE_RESET_VAL;
    if ('\0' == address[lByteIndex + 1])
    {
        param[lWriteIdx] = NIBBLE_FILLER;
    }
    else
    {
        switch (address[lByteIndex + 1])
        {
        case '*':
            param[lWriteIdx] = 0xA0;
            break;
        case '#':
            param[lWriteIdx] = 0xB0;
            break;
        case 'a':
            param[lWriteIdx] = 0xC0;
            break;
        case 'b':
            param[lWriteIdx] = 0xD0;
            break;
        case 'c':
            param[lWriteIdx] = 0xE0;
            break;
        case 'f':
            param[lWriteIdx] = 0xF0;
            break;
        default:
            param[lWriteIdx] = ((address[lByteIndex + 1] - ASCII_OFFSET) &
                                LOWER_NIBBLE_MASK)
                               << ONE_NIBBLE_SHIFT;
            break;
        }
    }
    switch (address[lByteIndex])
    {
    case '*':
        param[lWriteIdx] |= 0x0A;
        break;
    case '#':
        param[lWriteIdx] |= 0x0B;
        break;
    case 'a':
        param[lWriteIdx] |= 0x0C;
        break;
    case 'b':
        param[lWriteIdx] |= 0x0D;
        break;
    case 'c':
        param[lWriteIdx] |= 0x0E;
        break;
    case 'f':
        param[lWriteIdx] |= 0x0F;
        break;
    default:
        param[lWriteIdx] |= ((address[lByteIndex] - ASCII_OFFSET) &
                             LOWER_NIBBLE_MASK);
        break;
    }
}