Blob.h

/* Copyright (C) 2007 by Tommi Maekitalo
   Copyright (C) 2007-2026 by Marc Duerner
   SPDX-License-Identifier: LGPL-2.1-or-later WITH mif-exception
*/
 
#ifndef PT_BLOB_H
#define PT_BLOB_H
 
#include <Pt/SmartPtr.h>
#include <Pt/RefCounted.h>
#include <cstddef>
#include <cstring>
#include <cstdlib>
 
namespace Pt {
 
namespace Db {

class IBlob : public RefCounted
{
    public:
        virtual ~IBlob() {}

        virtual void assign(const char* data, std::size_t len) = 0;

        virtual IBlob* create() const = 0;

        virtual void destroy() = 0;

        std::size_t size() const
        { return _size; }

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

        bool operator==(const IBlob& other) const
        {
            return _size == other._size &&
                ( std::strncmp(_data, other._data, _size) == 0 );
        }
 
    protected:
        IBlob()
        : _data(0)
        , _size(0)
        { }
 
        char* _data;
        std::size_t _size;
};

class BlobImpl : public IBlob
{
    public:
        BlobImpl()
        { }
 
        ~BlobImpl()
        {
            delete[] _data;
        }
 
        virtual void assign(const char* data, std::size_t len)
        {
            if (len == 0)
            {
                delete[] _data;
                _data = 0;
                _size = 0;
                return;
            }
 
            if( len > this->size() )
            {
                delete[] _data;
                _data = new char[len];
            }
 
            std::memcpy(_data, data, len);
            _size = len;
        }
 
        virtual IBlob* create() const
        { return new BlobImpl(); }
 
        virtual void destroy()
        { delete this; }
 
        static BlobImpl* emptyInstance()
        {
            static BlobImpl empty(1);
            return &empty;
        }
 
    protected:
        BlobImpl(std::size_t n)
        { RefCounted::addRef(); }
};
 

static struct BlobStaticInitializer
{
    BlobStaticInitializer()
    {
        BlobImpl::emptyInstance();
    }
} pt_blob_static_initializer;
 

class Blob
{
    template <typename T>
    struct Release
    {
        void destroy(T* blob)
        { blob->destroy(); }
    };
 
    SmartPtr<IBlob, InternalRefCounted<IBlob>, Release<IBlob> > m_data;
 
public:
    Blob()
    : m_data( BlobImpl::emptyInstance() )
    { }

    Blob(const char* data, std::size_t len)
    : m_data( new BlobImpl() )
    {
        m_data->assign(data, len);
    }

    explicit Blob(IBlob* b)
    : m_data(b)
    { }

    void assign(const char* data, std::size_t len)
    {
        // copy-on-write
        if ( m_data->refs() > 1 )
        {
            m_data.reset( m_data->create() );
        }
 
        m_data->assign(data, len);
    }

    bool operator==(const Blob& b) const
    {
        return *m_data == *b.m_data;
    }

    bool operator!=(const Blob& b) const
    {
        return !operator==(b);
    }

    const char* data() const
    {
        return  m_data->data();
    }

    std::size_t size() const
    {
        return m_data->size();
    }
};
 
} // namespace Db
 
} // namespace Pt
 
#endif //PT_BLOB_H