AttributeBlob.h

Go to the documentation of this file.

// $Id: AttributeBlob.h 114 2006-04-30 18:01:54Z bingmann $

#ifndef VGS_AttributeBlob_H
#define VGS_AttributeBlob_H

#include <stdlib.h>
#include <assert.h>

#include <utility>
#include <string>

#include "GraphTypes.h"
#include "AnyType.h"
#include "AttributeProperties.h"

namespace VGServer {

template <typename AllocPolicy>
class TpAttributeBlob
{
private:
    typedef TpAttributeBlob<AllocPolicy>        thistype;

    char *_data;

    unsigned int _size;

    //virtual unsigned int realloc_size(unsigned int current_capacity, unsigned int min_new_capacity) = 0;

public:
    inline TpAttributeBlob()
        : _data(NULL), _size(0)
    {
    }

    explicit inline TpAttributeBlob(unsigned int n)
        : _data(NULL), _size(0)
    {
        alloc(n);
    }

    explicit inline TpAttributeBlob(const void *data, unsigned int len)
        : _data(NULL), _size(0)
    {
        copy(0, data, len);
    }

    inline TpAttributeBlob(const thistype &other)
        : _data(NULL), _size(0)
    {
        copy(0, other.data(), other.size());
    }

    inline thistype& operator=(const thistype &other)
    {
        copy(0, other.data(), other.size());
        return *this;
    }

    inline virtual ~TpAttributeBlob() {
        dealloc();
    }

    inline const char *data() const
    { return _data; }

    inline char *data()
    { return _data; }

    inline const char *data(unsigned int i) const
    { return _data + i; }

    inline unsigned int size() const
    { return _size; }

    inline bool empty() const
    { return size() == 0; }

    inline void alloc(unsigned int n)
    { if (_size < n) _alloc(n); }

    void _alloc(unsigned int n)
    {
        if (_size < n)
        {
            unsigned int newcap = AllocPolicy::realloc_size(_size, n);
            assert(n <= newcap);

            _data = static_cast<char*>(realloc(_data, newcap));
            //printf("TpAttributeBlob::realloc: %u\n", _size);

            // TODO: remove this debug tool
            for(unsigned int i = _size; i < newcap; i++)
                _data[i] = i;

            _size = newcap;
        }
    }

    void clear()
    { _size = 0; }

    inline void dealloc()
    {
        if (_data) free(_data);
        _data = NULL;
        _size = 0;
    }

    inline const char *detach() {
        const char *data = _data;
        _data = NULL;
        _size = 0;
        return data;
    }

    inline std::pair<const char*, unsigned int> detach_pair()
    {
        std::pair<const char*, unsigned int> pair(_data, _size);
        _data = NULL;
        _size = 0;
        return pair;
    }

    inline std::string getRange(unsigned int i, unsigned int len) const
    { assert(i+len < _size); return std::string(data(i), len); }

    inline void swap(thistype &other)
    {
        std::swap(_data, other._data);
        std::swap(_size, other._size);
    }

    // *** Read Functions

    inline char operator[](unsigned int i) const
    {
        assert(i < _size);
        return _data[i];
    }

    inline bool getBool(unsigned int i, unsigned int bitnum) const
    {
        i += bitnum / 8;
        bitnum %= 8;
        assert(i < _size);

        return (_data[i] & (1 << bitnum)) != 0;
    }

    template <typename T>
    inline T get(unsigned int i) const
    {
        assert(i + sizeof(T)-1 < _size);
        return *reinterpret_cast<T*>(_data+i);
    }

    inline std::string getString(unsigned int i) const
    {
        unsigned char slen = get<unsigned char>(i);
        assert(i + sizeof(char)-1 + slen < _size);
        return std::string(_data + i + 1, slen);
    }

    inline std::string getLongstring(unsigned int i) const
    {
        unsigned int slen = get<unsigned int>(i);
        assert(i + sizeof(int)-1 + slen < _size);
        return std::string(_data + i + 4, slen);
    }

    void getAnyType(unsigned int i, AnyType &v) const;

    // *** Write Functions

    inline void copy(unsigned int i, const void *indata, unsigned int inlen)
    {
        alloc(i + inlen);
        memcpy(_data + i, indata, inlen);
    }

    inline void zero(unsigned int i, unsigned int len)
    {
        alloc(i + len);
        memset(_data + i, 0, len);
    }

    inline void move(unsigned int src, unsigned int dst, unsigned int len)
    {
        alloc(dst + len);
        assert(src + len <= _size);
        memmove(_data + dst, _data + src, len);
    }

    inline void putBool(unsigned int i, unsigned int bitnum, bool v)
    {
        i += bitnum / 8;
        bitnum %= 8;
        alloc(i + 1);

        if (v) {
            _data[i] |= (1 << bitnum);
        }
        else {
            _data[i] &= ~(1 << bitnum);
        }
    }

    template <typename ValTp>
    inline void put(unsigned int i, ValTp v)
    {
        alloc(i + sizeof(ValTp));
        *reinterpret_cast<ValTp*>(_data+i) = v;
    }

    inline void putString(unsigned int i, const std::string &s)
    {
        alloc(i + 1 + s.size());
        put<unsigned char>(i, static_cast<unsigned char>(s.size()));
        memcpy(_data+i+1, s.data(), s.size());
    }

    inline void putLongstring(unsigned int i, const std::string &s)
    {
        alloc(i + 4 + s.size());
        put<unsigned int>(i, static_cast<unsigned int>(s.size()));
        memcpy(_data+i+4, s.data(), s.size());
    }

    void putAnyType(unsigned int i, const AnyType &v);

    unsigned int getAttrChainLength(unsigned int chidx, const AttributePropertiesList &attrlist) const;

    class AnyType getAttrChainValue(unsigned int chidx, unsigned int attrid, const AttributePropertiesList &attrlist) const;

    bool putAttrChainValue(const AttributePropertiesList &attrlist,
                                  unsigned int attrid, const AnyType &value);

};

// *** Three Specializations of the Template Class

class AttributeBigBlobPolicy
{
public:
    static unsigned int realloc_size(unsigned int cap, unsigned int minnewcap)
    {
        // place to adapt the buffer growing algorithm as need.
        while(cap < minnewcap)
        {
            if (cap < 256) cap = 512;
            else if (cap < 1024*1024) cap = 2*cap;
            else cap += 1024*1024;
        }
        return cap;
    }
};

typedef TpAttributeBlob<AttributeBigBlobPolicy> AttributeBigBlob;

class AttributeVertexTinyBlobPolicy
{
public:
    static unsigned int realloc_size(unsigned int cap, unsigned int minnewcap)
    {
        // place to adapt the buffer growing algorithm as need.
        while(cap < minnewcap)
        {
            if (cap < 8) cap = 8;
            else if (cap < 1024) cap = 2*cap;
            else cap += 1024;
        }
        return cap;
    }
};

typedef TpAttributeBlob<AttributeVertexTinyBlobPolicy> AttributeVertexTinyBlob;

struct AttributeEdgeTinyBlobPolicy
{
    static unsigned int realloc_size(unsigned int cap, unsigned int minnewcap)
    {
        // place to adapt the buffer growing algorithm as need.
        while(cap < minnewcap)
        {
            if (cap < 8) cap = 8;
            else if (cap < 1024) cap = 2*cap;
            else cap += 1024;
        }
        return cap;
    }
};

typedef TpAttributeBlob<AttributeEdgeTinyBlobPolicy> AttributeEdgeTinyBlob;

} // namespace VGServer

#endif // VGS_ByteOutBuffer_H

---