PionBlob.hpp

// -----------------------------------------------------------------------
// pion-common: a collection of common libraries used by the Pion Platform
// -----------------------------------------------------------------------
// Copyright (C) 2007-2009 Atomic Labs, Inc.  (http://www.atomiclabs.com)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//

#ifndef __PION_PIONBLOB_HEADER__
#define __PION_PIONBLOB_HEADER__

#include <string>
#include <boost/detail/atomic_count.hpp>
#include <boost/functional/hash.hpp>
#include <pion/PionConfig.hpp>


namespace pion {    // begin namespace pion


template <typename CharType, typename AllocType>
class PionBlob {
protected:

    struct BlobData {
        BlobData(AllocType& blob_alloc, const std::size_t len) :
            m_alloc_ptr(&blob_alloc), m_len(len), m_copies(0)
        {
            *((CharType*)(this) + sizeof(struct BlobData) + len) = '\0';
        }
        
        inline const CharType *get(void) const {
            return ((CharType*)(this) + sizeof(struct BlobData));
        }
    
        inline CharType *get(void) {
            return ((CharType*)(this) + sizeof(struct BlobData));
        }
    
        AllocType * const               m_alloc_ptr;

        const std::size_t               m_len;

        boost::detail::atomic_count     m_copies;
    };

    BlobData *          m_blob_ptr;


    static inline BlobData *create(AllocType& blob_alloc, const std::size_t len) {
        BlobData *blob_ptr = new (blob_alloc.malloc(len+sizeof(struct BlobData)+1))
            BlobData(blob_alloc, len);
        return blob_ptr;
    }

    inline void release(void) {
        if (m_blob_ptr) {
            if (m_blob_ptr->m_copies == 0) {
                m_blob_ptr->m_alloc_ptr->free(m_blob_ptr, m_blob_ptr->m_len+sizeof(struct BlobData)+1);
            } else {
                --m_blob_ptr->m_copies;
            }
            m_blob_ptr = NULL;
        }
    }

    inline BlobData *grab(void) const {
        if (m_blob_ptr) {
            ++m_blob_ptr->m_copies;
            return m_blob_ptr;
        } else {
            return NULL;
        }
    }
    
    
public:

    struct BlobParams {
        BlobParams(AllocType& blob_alloc, const CharType *ptr, const std::size_t len)
            : m_alloc(blob_alloc), m_ptr(ptr), m_len(len)
        {}
        // data parameters for constructing a PionBlob
        AllocType&          m_alloc;
        const CharType *    m_ptr;
        std::size_t         m_len;
    };

    virtual ~PionBlob() {
        release();
    }

    PionBlob(void) :
        m_blob_ptr(NULL)
    {}

    PionBlob(const PionBlob& blob) :
        m_blob_ptr(blob.grab())
    {}

    PionBlob(const BlobParams& p) :
        m_blob_ptr(NULL)
    {
        m_blob_ptr = create(p.m_alloc, p.m_len);
        memcpy(m_blob_ptr->get(), p.m_ptr, p.m_len);
    }

    PionBlob(AllocType& blob_alloc, const CharType* ptr, const std::size_t len) :
        m_blob_ptr(NULL)
    {
        m_blob_ptr = create(blob_alloc, len);
        memcpy(m_blob_ptr->get(), ptr, len);
    }

    PionBlob(AllocType& blob_alloc, const std::string& str) :
        m_blob_ptr(NULL)
    {
        m_blob_ptr = create(blob_alloc, str.size());
        memcpy(m_blob_ptr->get(), str.c_str(), str.size());
    }

    inline PionBlob& operator=(const PionBlob& blob) {
        release();
        m_blob_ptr = blob.grab();
        return *this;
    }
    
    inline void set(const BlobParams& p) {
        release();
        m_blob_ptr = create(p.m_alloc, p.m_len);
        memcpy(m_blob_ptr->get(), p.m_ptr, p.m_len);
    }

    inline void set(AllocType& blob_alloc, const CharType* ptr, const std::size_t len) {
        release();
        m_blob_ptr = create(blob_alloc, len);
        memcpy(m_blob_ptr->get(), ptr, len);
    }

    inline void set(AllocType& blob_alloc, const std::string& str) {
        release();
        m_blob_ptr = create(blob_alloc, str.size());
        memcpy(m_blob_ptr->get(), str.c_str(), str.size());
    }

    inline CharType *reserve(AllocType& blob_alloc, const std::size_t len) {
        release();
        m_blob_ptr = create(blob_alloc, len);
        return m_blob_ptr->get();
    }

    inline const CharType *get(void) const {
        return (m_blob_ptr ? m_blob_ptr->get() : "");
    }

    inline std::size_t size(void) const {
        return (m_blob_ptr ? (m_blob_ptr->m_len) : 0);
    }

    inline std::size_t length(void) const {
        return size();
    }
    
    inline bool empty(void) const {
        return (m_blob_ptr == NULL || m_blob_ptr->m_len == 0);
    }
    
    inline long use_count(void) const {
        return (m_blob_ptr == NULL ? 0 : m_blob_ptr->m_copies + 1);
    }

    inline bool unique(void) const {
        return (m_blob_ptr == NULL || m_blob_ptr->m_copies == 0);
    }
    
    inline void clear(void) { release(); }

    inline void reset(void) { release(); }

    inline bool operator==(const PionBlob& blob) const {
        if (size() != blob.size())
            return false;
        return (empty() || m_blob_ptr==blob.m_blob_ptr || memcmp(get(), blob.get(), m_blob_ptr->m_len)==0);
    }

    inline bool operator==(const std::string& str) const {
        if (size() != str.size())
            return false;
        return (empty() || memcmp(get(), str.c_str(), m_blob_ptr->m_len)==0);
    }

    inline bool operator!=(const PionBlob& blob) const {
        return ! (this->operator==(blob));
    }

    inline bool operator!=(const std::string& str) const {
        return ! (this->operator==(str));
    }

    inline bool operator<(const PionBlob& blob) const {
        const std::size_t len = (size() < blob.size() ? size() : blob.size());
        if (len > 0) {
            const int val = memcmp(get(), blob.get(), len);
            if (val < 0)
                return true;
            if (val > 0)
                return false;
        }
        return (size() < blob.size());
    }
        
    inline bool operator>(const PionBlob& blob) const {
        const std::size_t len = (size() < blob.size() ? size() : blob.size());
        if (len > 0) {
            const int val = memcmp(get(), blob.get(), len);
            if (val > 0)
                return true;
            if (val < 0)
                return false;
        }
        return (size() > blob.size());
    }

    inline bool operator<(const std::string& str) const {
        const std::size_t len = (size() < str.size() ? size() : str.size());
        if (len > 0) {
            const int val = memcmp(get(), str.c_str(), len);
            if (val < 0)
                return true;
            if (val > 0)
                return false;
        }
        return (size() < str.size());
    }

    inline bool operator>(const std::string& str) const {
        const std::size_t len = (size() < str.size() ? size() : str.size());
        if (len > 0) {
            const int val = memcmp(get(), str.c_str(), len);
            if (val > 0)
                return true;
            if (val < 0)
                return false;
        }
        return (size() > str.size());
    }
};


template <typename CharType, typename AllocType>
static inline std::size_t hash_value(const PionBlob<CharType,AllocType>& blob) {
    return (blob.empty() ? 0 : boost::hash_range(blob.get(), blob.get() + blob.size()));
}


struct HashPionIdBlob {
    inline unsigned long getValue(unsigned char c) const {
        unsigned long result;
        switch(c) {
        case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
            result = (c - 48);
            break;
        case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
            result = (c - 87);
            break;
        case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
            result = (c - 55);
            break;
        default:
            result = 0;
            break;
        }
        return result;
    }

    template <typename CharType, typename AllocType>
    inline std::size_t operator()(const PionBlob<CharType,AllocType>& blob) const {
        if (blob.size() != 36)  // sanity check
            return hash_value(blob);

        const char * const data = blob.get();
        unsigned long n;
        std::size_t seed = 0;

        // calculate first ulong value
        n = (getValue(data[0]) << 28);
        n |= (getValue(data[1]) << 24);
        n |= (getValue(data[2]) << 20);
        n |= (getValue(data[3]) << 16);
        n |= (getValue(data[4]) << 12);
        n |= (getValue(data[5]) << 8);
        n |= (getValue(data[6]) << 4);
        n |= getValue(data[7]);
        boost::hash_combine(seed, n);

        // calculate second ulong value
        n = (getValue(data[9]) << 28);
        n |= (getValue(data[10]) << 24);
        n |= (getValue(data[11]) << 20);
        n |= (getValue(data[12]) << 16);
        n |= (getValue(data[14]) << 12);
        n |= (getValue(data[15]) << 8);
        n |= (getValue(data[16]) << 4);
        n |= getValue(data[17]);
        boost::hash_combine(seed, n);
        
        // calculate third ulong value
        n = (getValue(data[19]) << 28);
        n |= (getValue(data[20]) << 24);
        n |= (getValue(data[21]) << 20);
        n |= (getValue(data[22]) << 16);
        n |= (getValue(data[24]) << 12);
        n |= (getValue(data[25]) << 8);
        n |= (getValue(data[26]) << 4);
        n |= getValue(data[27]);
        boost::hash_combine(seed, n);

        // calculate third ulong value
        n = (getValue(data[28]) << 28);
        n |= (getValue(data[29]) << 24);
        n |= (getValue(data[30]) << 20);
        n |= (getValue(data[31]) << 16);
        n |= (getValue(data[32]) << 12);
        n |= (getValue(data[33]) << 8);
        n |= (getValue(data[34]) << 4);
        n |= getValue(data[35]);
        boost::hash_combine(seed, n);

        return seed;
    }

#ifdef _MSC_VER
    //This code is needed for stdext::hash_map

    enum {
        bucket_size = 4,    // 0 < bucket_size
        min_buckets = 8     // min_buckets = 2 ^^ N, 0 < N
    };

    template <typename CharType, typename AllocType>
    bool operator()(const PionBlob<CharType, AllocType>& _Keyval1, const PionBlob<CharType, AllocType>& _Keyval2) const {
        return _Keyval1 < _Keyval2;
    }
#endif
};


}   // end namespace pion

#endif