Storages.h

См. документацию.

/* This file is part of the UniSet project
 * Copyright (c) 2009 Free Software Foundation, Inc.
 * Copyright (c) 2009 Ivan Donchevskiy
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
// --------------------------------------------------------------------------
// --------------------------------------------------------------------------

#ifndef Storages_H_
#define Storages_H_

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>

#define EMPTY_BLOCK -5
#define EMPTY_ELEM -1

#define key_size 20

struct StorageAttr
{
    int k_size, inf_size,size,block_number;
    int lim, seekpos;
} __attribute__((__packed__));

struct CycleStorageAttr
{
    int size, inf_size, seekpos;
} __attribute__((__packed__));

struct TableStorageElem
{
    char status;
    char key[key_size];
} __attribute__((__packed__));

struct TableBlockStorageElem
{
    int count;
} __attribute__((__packed__));

struct CycleStorageElem
{
    char status;
} __attribute__((__packed__));

class TableStorage
{
    FILE *file;
    int size,seekpos, inf_size;
    int head;
    public:
        TableStorage(const char* name, int inf_sz, int sz, int seek);
        ~TableStorage();
        int addRow(char* key, char* val);
        int delRow(char* key);
        char* findKeyValue(char* key, char* val);
};

class TableBlockStorage
{
    public:
        TableBlockStorage();

        TableBlockStorage(const char* name, int byte_sz, int key_sz, int inf_sz, int inf_count, int block_num, int block_lim, int seek, bool create=false);

        ~TableBlockStorage();

        bool open(const char* name, int byte_sz, int inf_sz, int key_sz, int inf_count, int block_num, int block_lim, int seek);
        bool create(const char* name, int byte_sz, int inf_sz, int key_sz, int inf_count, int block_num, int block_lim, int seek);

        bool addRow(void* key, void* val);

        bool delRow(void* key);

        void* findKeyValue(void* key, void* val);

        int getCurBlock(void);

        inline int getByteSize() { return (size*full_size + sizeof(StorageAttr)); }

        bool checkAttr( int key_sz, int inf_sz, int sz, int block_num, int block_lim, int seek );

    protected:
        FILE *file;
        int inf_size;
    private:
        int max,cur_block;
        TableBlockStorageElem* mem;
        int k_size, lim,seekpos;
        int size,block_size,block_number,full_size;
        void filewrite(int seek, bool needflush=true);
        bool copyToNextBlock();
        bool keyCompare(int i, void* key);
        void* keyPointer(int num);
        void* valPointer(int num);
        TableBlockStorageElem* elemPointer(int num);
};

class CycleStorage
{
    public:

        class CycleStorageIterator
        {
            public:
                typedef CycleStorageIterator Self;
                CycleStorageIterator():
                    str(NULL), cs(NULL), current(0) {}
                CycleStorageIterator(CycleStorage* cstor)
                {
                    cs = cstor;
                    current = 0;
                }
                CycleStorageIterator(CycleStorage* cstor, int num)
                {
                    cs = cstor;
                    if( num<0 || num>=cs->getSize() ) current = 0;
                    current = num;
                }

                void* operator *() const
                {
                    return str;
                }

                Self& operator++();
                Self operator++(int);

                Self& operator--();
                Self operator--(int);

                inline bool operator==(const Self& other) const
                {
                    if( str==NULL || other.str==NULL )
                    {
                        if( str==NULL && other.str==NULL )
                            return true;
                        else
                            return false;
                    }
                    if( memcmp(str, other.str, cs->getInfSize())==0 )
                        return true;
                    return false;
                }

                inline bool operator!=(const Self& other) const
                {
                    if( str==NULL || other.str==NULL )
                    {
                        if( str==NULL && other.str==NULL )
                            return false;
                        else
                            return true;
                    }
                    if( memcmp(str, other.str, cs->getInfSize())==0 )
                        return false;
                    return true;
                }
            private:
                void* str;
                CycleStorage* cs;
                int current;
        };

        typedef CycleStorageIterator iterator;

        CycleStorage();

        CycleStorage(const char* name, int byte_sz, int inf_sz, int inf_count, int seek,bool create=false);

        ~CycleStorage();

        bool open(const char* name, int byte_sz, int inf_sz, int inf_count, int seek);
        bool create(const char* name, int byte_sz, int inf_sz, int inf_count, int seek);
        bool isOpen(){ return (file!=NULL); }


        bool addRow(void* str);

        bool delRow(int row);

        bool delAllRows(void);

        void* readRow(int num, void* str);

        int getIter(void);

        bool setSize(int count);

        inline int getByteSize() { return (size*full_size + sizeof(CycleStorageAttr)); }
        inline int getSize(){ return size; }
        inline int getInfSize(){ return inf_size; }
        inline int getFullSize(){ return full_size; }

        bool checkAttr(int inf_sz, int inf_count, int seek);

        inline int getHead(){ return head; }
        inline int getTail(){ return tail; }

        iterator begin()
        {
            return iterator(this);
        }

        iterator end()
        {
            return iterator(this,this->getTail());
        }

    protected:
        FILE *file;
        int inf_size;
        int head,tail;
    private:
        int size,seekpos, iter;
        int full_size;
        void filewrite(CycleStorageElem* jrn,int seek, bool needflush=true);
        void* valPointer(void* pnt);
        bool findHead();
};

#endif