picture-prop-container.cpp

Go to the documentation of this file.

#include "config.h"
#include "libnebular.hpp"
#include "libnebular-plugin.hpp"
#include "utils.hpp"
#include "libnebular-extra.templates.hpp"

#include <map>
#include <sstream>
#include <algorithm>

#include <boost/lexical_cast.hpp>
#include <boost/static_assert.hpp>
#include <boost/functional/hash.hpp>

namespace libnebular{
    using namespace std;

    // @class Blob
    //{

    class Blob::Impl_{
    private:
        friend class Blob;
        
        boost::shared_ptr<char> data;
        bool areDataCanBeReroomed;
        Integer dataSize, dataRoom;

        Impl_():
            areDataCanBeReroomed(true),
            dataSize(0),
            dataRoom(0)
        {}
    public:

        ~Impl_() {}
    };

    char* Blob::getDataReadWrite(){
        if(!isEmpty(pimpl_->data) && !pimpl_->data.unique()){
            // Copy-on-write
            boost::shared_ptr<char> dataOthers = pimpl_->data;
            pimpl_->data = boost::shared_ptr<char>();

            prepareForSize(pimpl_->dataSize);

            std::copy(
                dataOthers.get(),
                dataOthers.get()+pimpl_->dataSize,
                pimpl_->data.get()
            );
        }

        return pimpl_->data.get();
    }

    const char* Blob::getDataReadOnly() const{
        return pimpl_->data.get();
    }

    size_t Blob::getDataHash() const{
        return boost::hash_range(
            getDataReadOnly(),
            getDataReadOnly() + getDataSize()
        );
    }

    Integer Blob::getDataRoom() const{
        return pimpl_->dataRoom;
    }

    void Blob::forsakeData(){
        if(!isEmpty(pimpl_->data) && !pimpl_->data.unique()){
            cleanupData();
        }
    }

    void Blob::cleanupData(){
        pimpl_->data = boost::shared_ptr<char>();
        pimpl_->dataSize = 0;
        pimpl_->dataRoom = 0;
        pimpl_->areDataCanBeReroomed = true;
    }

    Integer Blob::getDataSize() const{
        return pimpl_->dataSize;
    }

    void Blob::setDataSize(Integer newSize){
        if(newSize > pimpl_->dataRoom){
            throw LIBNEBULAR_ERROR("In Blob: before setting new data size you should make sure that there is enough data room");
        }
        pimpl_->dataSize = newSize;
    }

    void Blob::mAlloc(Integer newSize){
        pimpl_->data.reset(
            new char[newSize],
            boost::checked_array_deleter<char>()
        );
        pimpl_->dataRoom = newSize;
        pimpl_->areDataCanBeReroomed = true;
    }
    void Blob::attach(void *newMemory, Integer newDataRoom){
        pimpl_->data.reset(
            static_cast<char*>(newMemory),
            null_deleter()
        );
        pimpl_->dataRoom = newDataRoom;
        pimpl_->areDataCanBeReroomed = false;
    }
    void Blob::prepareForSize(Integer newDataSize){
        if(isCanBeReroomed()){
            mAlloc(newDataSize);
        }else{
            if(newDataSize > getDataRoom()){
                throw LIBNEBULAR_ERROR("Current ProbBlob cannot be reroomed");
            }else{
                // Okay, cannot reroom externally allocated memory.
            }
        }
        setDataSize(newDataSize);
    }

    bool Blob::isCanBeReroomed() const{
        return pimpl_->areDataCanBeReroomed;
    }

    void Blob::assign(Integer newSize, const char* newData){
        prepareForSize(newSize);
        std::copy(newData, newData+newSize, pimpl_->data.get());
    }

    bool Blob::isSubseqFromCurPos(std::istream &inStream) const{
        char *curBlobChar = pimpl_->data.get();
        for(
            Integer index = 0;
            index < getDataSize();
            ++index
        ){
            char buf;
            inStream >> buf;
            if(buf != *curBlobChar){
                return false;
            }

            ++curBlobChar;
        }
        return true;
    }

    Blob::Blob():
        pimpl_(new Impl_)
    {
        BOOST_STATIC_ASSERT( sizeof(char) == 1 );
    }

    Blob::Blob(Integer newSize, const char* newData):
        pimpl_(new Impl_)
    {
        BOOST_STATIC_ASSERT( sizeof(char) == 1 );

        assign(newSize, newData);
    }

    Blob::~Blob() {}

    Blob Blob::createAndMAlloc(Integer newSize){
        Blob newBlob;
        newBlob.mAlloc(newSize);
        return newBlob;
    }
    Blob Blob::createAndAttach(void *newMemory, Integer newDataRoom){
        Blob newBlob;
        newBlob.attach(newMemory, newDataRoom);
        return newBlob;
    }

    // }


    // @class PicturePropContainer
    // {

    class PicturePropContainer::Impl_{
    public:
        class Property{
        private:
            enum ValueType{
                TYPE_NOT_SET,
                TYPE_PROP_STR,
                TYPE_PROP_BLOB
            } valueType;

            struct Attribute{
                bool default_;

                Attribute():
                    default_(false)
                {}

                Attribute(
                    bool newDefault_
                ):
                    default_(newDefault_)
                {}
            } attribute;

            struct Placeholder{
                virtual ~Placeholder() {}

                virtual Placeholder *clone() const = 0;
            };

            template <typename T> struct Holder: public Placeholder{
            public:
                Holder(const T &newValue):
                    held(newValue)
                {}

                virtual Placeholder *clone() const{
                    return new Holder(held);
                }

                T held;
            };

            Placeholder *content;

        public:
            Property():
                valueType(TYPE_NOT_SET),
                attribute(),
                content(NULL)
            {}

            Property(const Property &other):
                valueType(other.valueType),
                attribute(other.attribute),
                content(
                    other.content ?
                    other.content->clone() :
                    NULL
                )
            {}

            Property &swap(Property &rhs){
                std::swap(content, rhs.content);
                std::swap(attribute, rhs.attribute);
                std::swap(valueType, rhs.valueType);
                return (*this);
            }

            Property &operator=(const Property &rhs){
                Property rhsCopy(rhs);
                swap(rhsCopy);
                return (*this);
            }

            Property(
                const String &newValue,
                bool newIsDefault
            ):
                valueType(TYPE_PROP_STR),
                attribute(newIsDefault),
                content(new Holder<String>(newValue))
            {}

            Property(
                const Blob &newValue,
                bool newIsDefault
            ):
                valueType(TYPE_PROP_BLOB),
                attribute(newIsDefault),
                content(new Holder<Blob>(newValue))
            {}

            ~Property(){
                delete content;
            }

            template <typename T> bool isTypedAs() const{
                return false;
            }

            bool isDefault() const{
                return attribute.default_;
            }

            void setDefault(bool newValue = true){
                attribute.default_ = newValue;
            }

            template <typename R> R &getValueRef(){
                if(!isTypedAs<R>()){
                    throw LIBNEBULAR_ERROR("Type of property have been chosen wrong");
                }
                return static_cast< Holder<R>* >(content)->held;
            }

            template <typename R> const R getValue(){
                return getValueRef<R>();
            }

            template <typename R> void setValue(const R &newValue){
                (getValueRef<R>()) = newValue;
            }
        };

    public:
        virtual bool isSet(const String &key) const = 0;
        virtual void unSet(const String &key) = 0;
        virtual Property &getPropertyRef(const String &key) = 0;
        virtual void setProperty(const String &key, const Property &newValue) = 0;

        void setDefault(const String &key, const String &value){
            setProperty(key, Property(value, true));
        }

        virtual PropKeyIterator propKeyBegin() = 0;
        virtual PropKeyIterator propKeyEnd() = 0;

        Impl_() {}
        virtual ~Impl_() {}

        friend class PicturePropContainerSubtreeProxyImpl_;
    };

    class PicturePropContainer::DefaultImpl_: public PicturePropContainer::Impl_{
    public:
        typedef map<String, Property> PropertyMap;
    private:
        PropertyMap propertyMap;
    public:

        virtual bool isSet(const String &key) const{
            return
                propertyMap.find(key) != propertyMap.end();
        }

        virtual void unSet(const String &key){
            size_t numErased =
                propertyMap.erase(key);
            if(numErased < 1){
                throw LIBNEBULAR_ERROR("\"PicturePropContainer\": attempt to access (and unset) non-existent property \"" + key + "\"");
            }
        }

        virtual Property &getPropertyRef(const String &key){
            PropertyMap::iterator property = propertyMap.find(key);
            if(property != propertyMap.end()){
                return property->second;
            }else{
                throw LIBNEBULAR_ERROR("\"PicturePropContainer\": attempt to access to non-existent property \"" + key + "\"");
            }
        }

        virtual void setProperty(const String &key, const Property &newValue){
            PropertyMap::iterator property = propertyMap.find(key);
            if(property != propertyMap.end()){
                property->second = newValue;
            }else{
                propertyMap[key] = newValue;
            }
        }

        virtual PropKeyIterator propKeyBegin();
        virtual PropKeyIterator propKeyEnd();

        DefaultImpl_() {}
        virtual ~DefaultImpl_() {}
    };


    class PicturePropContainer::PropKeyIterator::Impl_{
    private:
        friend class PicturePropContainer::PropKeyIterator;
        
        typedef PicturePropContainer::DefaultImpl_::PropertyMap::iterator BaseIterator;

        BaseIterator i;

    public:
        static PicturePropContainer::PropKeyIterator toPropKeyIterator(
            BaseIterator newPluginListI
        ){
            PicturePropContainer::PropKeyIterator newPluginI;
            newPluginI.pimpl_->i = newPluginListI;
            return newPluginI;
        }
    };

    template <> bool PicturePropContainer::Impl_::Property::isTypedAs<String>() const{
        return valueType == TYPE_PROP_STR;
    }

    template <> bool PicturePropContainer::Impl_::Property::isTypedAs<Blob>() const{
        return valueType == TYPE_PROP_BLOB;
    }

    template <> const String PicturePropContainer::Impl_::Property::getValue<String>(){
        if(!isTypedAs<Blob>()){
            return getValueRef<String>();
        }else{
            std::ostringstream streamOut;
            streamOut << "<Blob with hash value " << "0x" << hex << getValueRef<Blob>().getDataHash() << ">";

            return streamOut.str();
        }
    }

    PicturePropContainer::PropKeyIterator PicturePropContainer::DefaultImpl_::propKeyBegin(){
        return PicturePropContainer::PropKeyIterator::Impl_::toPropKeyIterator(
            propertyMap.begin()
        );
    }
    PicturePropContainer::PropKeyIterator PicturePropContainer::DefaultImpl_::propKeyEnd(){
        return PicturePropContainer::PropKeyIterator::Impl_::toPropKeyIterator(
            propertyMap.end()
        );
    }

    void setDefault(
        PicturePropContainer &p,
        const String &key,
        const String &value
    ){
        p.pimpl_->setDefault(key, value);
    }
    
    void PicturePropContainer::unSet(const String &key){
        pimpl_->unSet(key);
    }

    void PicturePropContainer::move(const String &srcKey, const String &destKey){
        if(srcKey == destKey){
            return;
        }

        pimpl_->setProperty(
            destKey,
            pimpl_->getPropertyRef(srcKey)
        );
        unSet(srcKey);
    }

    bool PicturePropContainer::isSet(const String &key) const{
        return pimpl_->isSet(key);
    }
    bool PicturePropContainer::isDefault(const String &key) const{
        return pimpl_->getPropertyRef(key).isDefault();
    }

    bool PicturePropContainer::isSetAndTrue(const String& key) const{
        return isSet(key) && get<bool>(key);
    }

    void PicturePropContainer::acceptOpt(const String &acceptedKey){
        if(isSet(String("opt/") + acceptedKey)){
            move(String("opt/") + acceptedKey, acceptedKey);
        }
    }

    void PicturePropContainer::setDefaultIfNotSet(const String &key, const String &defaultValue){
        if(!isSet(key)){
            setDefault(*this, key, defaultValue);
        }
    }

    PicturePropContainer::PicturePropContainer():
        pimpl_(new DefaultImpl_)
    {}

    PicturePropContainer::~PicturePropContainer() {}

    String PicturePropContainer::castToPropString(
        const char *value
    ){
        return String(value);
    }

    template<>
    String PicturePropContainer::castToPropString(const bool& arg)
    {
        std::ostringstream tmpOut;
        tmpOut << std::boolalpha << arg;
        return tmpOut.str();
    }

    template<>
    bool PicturePropContainer::castFromPropString(const String& arg)
    {
        std::istringstream tmpOut(arg);
        bool result;
        tmpOut >> std::boolalpha >> result;
        return result;
    }

    template<> const String PicturePropContainer::get<>(
        const String &key
    ) const{
        return pimpl_->getPropertyRef(key).getValue<String>();
    }
    template<> void PicturePropContainer::set<>(
        const String &key, const String &value
    ){
        pimpl_->setProperty(key, Impl_::Property(value, false));
    }
    template<> const Blob PicturePropContainer::get<>(
        const String &key
    ) const{
        return pimpl_->getPropertyRef(key).getValue<Blob>();
    }
    template<> void PicturePropContainer::set<>(
        const String &key, const Blob &value
    ){
        pimpl_->setProperty(key, Impl_::Property(value, false));
    }

    // Template instantiations for conversions "to" and "from" property @c String.

#if !PROCESSED_BY_DOXYGEN
    template String PicturePropContainer::castToPropString(const String &);
    template String PicturePropContainer::castToPropString(const Integer &);
    template String PicturePropContainer::castToPropString(const Real &);
    template String PicturePropContainer::castToPropString(const bool &);

    template String PicturePropContainer::castToPropString(const HexInteger<Integer> &);
    
#endif // PROCESSED_BY_DOXYGEN
    
    template String PicturePropContainer::castFromPropString(const String &);
    template Integer PicturePropContainer::castFromPropString(const String &);
    template Real PicturePropContainer::castFromPropString(const String &);
    template bool PicturePropContainer::castFromPropString(const String &);

    template int16_t PicturePropContainer::castFromPropString(const String &);
    template int32_t PicturePropContainer::castFromPropString(const String &);
    template uint16_t PicturePropContainer::castFromPropString(const String &);
    template uint32_t PicturePropContainer::castFromPropString(const String &);
    
    // }

    // class PicturePropContainer::PropKeyIterator
    // {

    PicturePropContainer::PropKeyIterator::PropKeyIterator():
        pimpl_(new Impl_)
    {}
    PicturePropContainer::PropKeyIterator::~PropKeyIterator() {}

    // @design Exception-safety is weak here, lol
    PicturePropContainer::PropKeyIterator::PropKeyIterator(
        const PicturePropContainer::PropKeyIterator &src
    ):
        pimpl_(new Impl_)
    {
        (*this) = src;
    }
    PicturePropContainer::PropKeyIterator& PicturePropContainer::PropKeyIterator::operator=(
        const PicturePropContainer::PropKeyIterator &src
    ){
        (pimpl_->i) = (src.pimpl_->i);
        return *this;
    }

    PicturePropContainer::PropKeyIterator& PicturePropContainer::PropKeyIterator::operator++(){
        ++( pimpl_->i );
        return *this;
    }
    PicturePropContainer::PropKeyIterator PicturePropContainer::PropKeyIterator::operator++(int){
        PropKeyIterator prevThis = *this;
        ( pimpl_->i )++;
        return prevThis;
    }

    bool PicturePropContainer::PropKeyIterator::operator!=(const PicturePropContainer::PropKeyIterator &b) const{
        return ( pimpl_->i != b.pimpl_->i );
    }
    bool PicturePropContainer::PropKeyIterator::operator==(const PicturePropContainer::PropKeyIterator &b) const{
        return ( pimpl_->i == b.pimpl_->i );
    }
    PicturePropContainer::PropKeyIterator::value_type& PicturePropContainer::PropKeyIterator::operator*(){
        return pimpl_->i->first;
    }
    PicturePropContainer::PropKeyIterator::value_type* PicturePropContainer::PropKeyIterator::operator->(){
        return &(pimpl_->i->first);
    }

    //}
    PicturePropContainer::PropKeyIterator PicturePropContainer::propKeyBegin(){
        return pimpl_->propKeyBegin();
    }
    PicturePropContainer::PropKeyIterator PicturePropContainer::propKeyEnd(){
        return pimpl_->propKeyEnd();
    }

    //}

    class PicturePropContainer::SubtreeProxyImpl_: public PicturePropContainer::Impl_{
    private:
        boost::shared_ptr<PicturePropContainer::Impl_> realSubject;
        String subTreePrefix;

        class SpecialPrefixOrderLess: std::binary_function<const String&, const String&, bool>{
            private:
                const String prefix;

            public:
                SpecialPrefixOrderLess(const String &newPrefix):
                    prefix(newPrefix)
                {}

                bool operator()(const String &a, const String &b){
                    return
                        a.substr(0, prefix.length()) <= prefix &&
                        b.substr(0, prefix.length()) > prefix
                    ;
                }
            };

    public:
        virtual bool isSet(const String &key) const{
            return realSubject->isSet(subTreePrefix+key);
        }

        virtual void unSet(const String &key){
            return realSubject->unSet(subTreePrefix+key);
        }

        virtual Property &getPropertyRef(const String &key){
            return realSubject->getPropertyRef(subTreePrefix+key);
        }

        virtual void setProperty(const String &key, const Property &newValue){
            return realSubject->setProperty(subTreePrefix+key, newValue);
        }

        virtual PropKeyIterator propKeyBegin(){
            PropKeyIterator firstGtThanPrefix = std::lower_bound(
                    realSubject->propKeyBegin(),
                    realSubject->propKeyEnd(),
                    subTreePrefix
            );
            if(
                firstGtThanPrefix != realSubject->propKeyEnd() &&
                firstGtThanPrefix->substr(0, subTreePrefix.length()) == subTreePrefix
            ){
                return firstGtThanPrefix;
            }else{
                return realSubject->propKeyEnd();
            }
        }

        virtual PropKeyIterator propKeyEnd(){
            return std::upper_bound(
                realSubject->propKeyBegin(),
                realSubject->propKeyEnd(),
                subTreePrefix,
                SpecialPrefixOrderLess(subTreePrefix)
            );
        }

        SubtreeProxyImpl_(
            PicturePropContainer &newRealSubject,
            const String &newSubTreePrefix
        ):
            realSubject(newRealSubject.pimpl_),
            subTreePrefix(newSubTreePrefix)
        {}
        virtual ~SubtreeProxyImpl_() {}
    };

    template <class PicturePropContainerBased>
    boost::shared_ptr<PicturePropContainerBased>
    createSubtreeProxy(
        PicturePropContainer &realSubject,
        const String &subTreePrefix
    ){
        boost::shared_ptr<PicturePropContainerBased> proxy(new PicturePropContainerBased);
        proxy->PicturePropContainer::pimpl_ = boost::shared_ptr<PicturePropContainer::Impl_>(
            new PicturePropContainer::SubtreeProxyImpl_(
                realSubject,
                subTreePrefix
            )
        );

        return proxy;
    }


    template boost::shared_ptr<PicturePropContainer> createSubtreeProxy<PicturePropContainer>(
        PicturePropContainer &realSubject,
        const String &subTreePrefix
    );
    template boost::shared_ptr<PictureProps> createSubtreeProxy<PictureProps>(
        PicturePropContainer &realSubject,
        const String &subTreePrefix
    );
    template boost::shared_ptr<Picture> createSubtreeProxy<Picture>(
        PicturePropContainer &realSubject,
        const String &subTreePrefix
    );
}

---