cel_blob.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// (C) 2003-2006 Celartem Technology Inc. All rights reserved.
//----------------------------------------------------------------------------

#ifndef _cel_blob_h_
#define _cel_blob_h_

#include "cel_types.h"
#include "cel_datatraits.h"
#include "cel_string.h"
#include "cel_misc.h"
#include <cstring>

namespace Celartem
{
    template<size_t _SIZE, bool NEED_SECURE_CLEANUP = false> struct Blob
    {
        enum {SIZE = _SIZE};
        
        // trick for reducing compilation error
        static const size_t SIZE_NO_WARN = SIZE ? SIZE : 1;

        u8 bin[SIZE_NO_WARN];
        
        Blob()
        {
            if(SIZE)
                std::memset(bin, 0, SIZE_NO_WARN);
        }
        
        Blob(const u8* inBin)
        {
            if(SIZE)
                std::memcpy(bin, inBin, SIZE_NO_WARN);
        }
        
        Blob(const Blob& inBin)
        {
            if(SIZE)
                std::memcpy(bin, inBin.bin, SIZE_NO_WARN);
        }
        
        ~Blob()
        {
            // FIXME: we had better use some optimization-proof zeromemory here
            if(NEED_SECURE_CLEANUP)
                clear();
        }
        
        Blob& operator=(const u8* inBin)
        {
            if(SIZE)
                std::memcpy(bin, inBin, SIZE_NO_WARN);
            return *this;
        }

        Blob& operator=(const Blob& inBin)
        {
            if(SIZE)
                std::memcpy(bin, inBin.bin, SIZE_NO_WARN);
            return *this;
        }
        
        operator const u8*() const
        {
            return bin;
        }

        operator u8*()
        {
            return bin;
        }
        
        size_t getSize() const
        {
            return SIZE;
        }

        void clear()
        {
            if(SIZE)
                std::memset(bin, 0, SIZE_NO_WARN);
        }

        bool isAllZero() const
        {
            for(size_t i = 0; i < SIZE; i++)
                if(bin[i] != 0)
                    return false;
            return true;
        }

        bool operator==(const Blob& inBin) const
        {
            return compare(inBin) == 0;
        }

        bool operator!=(const Blob& inBin) const
        {
            return compare(inBin) != 0;
        }
        
        bool operator<=(const Blob& inBin) const
        {
            return compare(inBin) <= 0;
        }
        
        bool operator<(const Blob& inBin) const
        {
            return compare(inBin) < 0;
        }

        bool operator>=(const Blob& inBin) const
        {
            return compare(inBin) >= 0;
        }
    
        bool operator>(const Blob& inBin) const
        {
            return compare(inBin) > 0;
        }

        int compare(const Blob& inBin) const
        {
            if(SIZE)
                return std::memcmp(bin, inBin.bin, SIZE_NO_WARN);
            return 0;
        }
    };
    
    template<size_t SIZE> struct DataTraits<Blob<SIZE> >
    {
        static const CopyPolicy copyPolicy = byMemcpy;
        static const StoragePolicy storagePolicy = byCopyBytes;
        static const bool isPOD = false;
    };
}

#endif // _cel_blob_h_

---

This document is automatically generated using doxygen 1.5.4 at Fri Jun 27 18:21:54 2008.