Data.h

Go to the documentation of this file.

#pragma once
 
#include "Base.h"
#include "Reader.h"
#include "DataItems.h"
#include "../TMP.h"
 
#include <functional>
 
namespace Gorgon { namespace Resource {
    
    class File;
    
    class Data : public Base {
 
        template <class T_, class R_, int IND_>
        void append(const T_ &values, const std::string &prefix, const R_ &reflectionobj) {
            Append(prefix+reflectionobj.Names[IND_], values.*(R_::template Member<IND_>::MemberPointer()) );
        }
 
 
        template <class T_, class R_, int ...S_>
        void append(const T_ &values, const std::string &prefix, const R_ &reflectionobj, TMP::Sequence<S_...>) {
            char dummy[] ={0, (append<T_, R_, S_>(values, prefix, reflectionobj),'\0')...};
        }
 
        template <class T_, class O_, class R_, int IND_>
        typename std::enable_if<!std::is_base_of<Base, typename std::remove_pointer<O_>::type>::value, void>::type
        namedtransform(T_ &values, const std::string &prefix, const R_ &reflectionobj) const {
            values.*(R_::template Member<IND_>::MemberPointer())=GetItem(prefix+reflectionobj.Names[IND_]).template Get<O_>();
        }
 
        template <class T_, class R_, int ...S_>
        void namedtransform(T_ &values, const std::string &prefix, const R_ &reflectionobj, TMP::Sequence<S_...>) const {
            char dummy[] ={0, (namedtransform<T_, typename R_::template Member<S_>::Type, R_, S_>(values, prefix, reflectionobj),'\0')...};
        }
 
        template <class T_, class O_, class R_, int IND_>
        typename std::enable_if<std::is_base_of<Base, typename std::remove_pointer<O_>::type>::value, void>::type
        namedtransform(T_ &values, const std::string &prefix, const R_ &reflectionobj) {
            values.*(R_::template Member<IND_>::MemberPointer())=&GetItem(prefix+reflectionobj.Names[IND_]).template GetObject<typename std::remove_pointer<O_>::type>();
            dynamic_cast<ObjectData&>(GetItem(prefix+reflectionobj.Names[IND_])).Release();
        }
 
        template <class T_, class O_, class R_, int IND_>
        typename std::enable_if<!std::is_base_of<Base, typename std::remove_pointer<O_>::type>::value, void>::type
        namedtransform(T_ &values, const std::string &prefix, const R_ &reflectionobj) {
            values.*(R_::template Member<IND_>::MemberPointer())=GetItem(prefix+reflectionobj.Names[IND_]).template Get<O_>();
        }
 
        template <class T_, class R_, int ...S_>
        void namedtransform(T_ &values, const std::string &prefix, const R_ &reflectionobj, TMP::Sequence<S_...>) {
            char dummy[] ={0, (namedtransform<T_, typename R_::template Member<S_>::Type, R_, S_>(values, prefix, reflectionobj),'\0')...};
        }
 
    public:
        using Iterator = Containers::Collection<DataItem>::Iterator;
 
        using ConstIterator = Containers::Collection<DataItem>::ConstIterator;
 
        Data() { }
        
        template<class T_, class R_ = typename T_::ReflectionType>
        explicit Data(const T_ &values, const R_ &reflectionobj = T_::Reflection()) {
            Append(values, reflectionobj);
        }
        
        template<class T_, class R_ = typename T_::ReflectionType>
        Data(const T_ &values, const std::string &prefix, const R_ &reflectionobj = T_::Reflection()) {
            Append(values, prefix, reflectionobj);
        }
        
        virtual GID::Type GetGID() const override { 
            return GID::Data;
        }
        
        template<class T_, class R_ = typename T_::ReflectionType>
        typename std::enable_if<R_::IsGorgonReflection, void>::type 
        Append(const T_ &values, const R_ &reflectionobj = T_::Reflection()) {
            static_assert(R_::IsGorgonReflection, "The template argument R_ for this constructor should be reflection type of the struct.");
            
            Append(values, "", reflectionobj);
        }
        
        template<class T_, class R_ = typename T_::ReflectionType>
        typename std::enable_if<R_::IsGorgonReflection, void>::type  
        Append(const T_ &values, const std::string &prefix, const R_ &reflectionobj = T_::Reflection()) {
            static_assert(R_::IsGorgonReflection, "The template argument R_ for this constructor should be reflection type of the struct.");
 
            append(values, prefix, reflectionobj, typename TMP::Generate<R_::MemberCount>::Type());
        }
 
        template<class T_>
        typename std::enable_if<!std::is_base_of<Base, T_>::value && !T_::ReflectionType::IsGorgonReflection, void>::type
        Append(T_ value) {
            Insert(value, items.GetCount());
        }
 
        template<class T_>
        typename std::enable_if<std::is_base_of<Base, T_>::value, void>::type
        Append(T_ &value) {
            Insert(value, items.GetCount());
        }
 
        template<class T_>
        typename std::enable_if<!std::is_base_of<Base, T_>::value, void>::type 
        Append(const std::string &name, T_ value) {
            Insert(name, value, items.GetCount());
        }
 
        template<class T_>
        typename std::enable_if<std::is_base_of<Base, T_>::value, void>::type
        Append(const std::string &name, T_ &value) {
            Insert(name, value, items.GetCount());
        }
 
        void Insert(int value, int before) {
            Insert("#"+String::From(items.GetCount()), value, before);
        }
        
        void Insert(const std::string &name, int value, int before) {
            items.Insert(new IntegerData(name, value), before);
        }
 
        void Insert(float value, int before) {
            Insert("#"+String::From(items.GetCount()), value, before);
        }
 
        void Insert(const std::string &name, float value, int before) {
            items.Insert(new FloatData(name, value), before);
        }
 
        void Insert(const std::string &value, int before) {
            Insert("#"+String::From(items.GetCount()), value, before);
        }
 
        void Insert(const std::string &name, const std::string &value, int before) {
            items.Insert(new TextData(name, value), before);
        }
 
        void Insert(const char *value, int before) {
            Insert("#"+String::From(items.GetCount()), value, before);
        }
 
        void Insert(const std::string &name, const char *value, int before) {
            items.Insert(new TextData(name, value), before);
        }
 
        void Insert(Geometry::Point value, int before) {
            Insert("#"+String::From(items.GetCount()), value, before);
        }
 
        void Insert(const std::string &name, Geometry::Point value, int before) {
            items.Insert(new PointData(name, value), before);
        }
 
        void Insert(Geometry::Pointf value, int before) {
            Insert("#"+String::From(items.GetCount()), value, before);
        }
 
        void Insert(const std::string &name, Geometry::Pointf value, int before) {
            items.Insert(new PointfData(name, value), before);
        }
 
        void Insert(Geometry::Size value, int before) {
            Insert("#"+String::From(items.GetCount()), value, before);
        }
 
        void Insert(const std::string &name, Geometry::Size value, int before) {
            items.Insert(new SizeData(name, value), before);
        }
 
        void Insert(Geometry::Rectangle value, int before) {
            Insert("#"+String::From(items.GetCount()), value, before);
        }
 
        void Insert(const std::string &name, Geometry::Rectangle value, int before) {
            items.Insert(new RectangleData(name, value), before);
        }
 
        void Insert(Geometry::Bounds value, int before) {
            Insert("#"+String::From(items.GetCount()), value, before);
        }
 
        void Insert(const std::string &name, Geometry::Bounds value, int before) {
            items.Insert(new BoundsData(name, value), before);
        }
 
        void Insert(Geometry::Margin value, int before) {
            Insert("#"+String::From(items.GetCount()), value, before);
        }
 
        void Insert(const std::string &name, Geometry::Margin value, int before) {
            items.Insert(new MarginData(name, value), before);
        }
 
        void Insert(Base *value, int before) {
            Insert("#"+String::From(items.GetCount()), value, before);
        }
 
        void Insert(const std::string &name, Base *value, int before) {
            items.Insert(new ObjectData(name, value), before);
        }
 
        void Insert(Base &value, int before) {
            Insert(&value, before);
        }
 
        void Insert(const std::string &name, Base &value, int before) {
            Insert(name, &value, before);
        }
 
        template<class T_, class R_ = typename T_::ReflectionType>
        T_ NamedTransform_KeepObjects(const R_ &reflectionobj = T_::Reflection()) const {
            return NamedTransform_KeepObjects<T_, R_>("", reflectionobj);
        }
        
        template<class T_, class R_ = typename T_::ReflectionType>
        T_ NamedTransform_KeepObjects(const std::string &prefix, const R_ &reflectionobj = T_::Reflection()) const {
            T_ t;
            namedtransform<T_, R_>(t, prefix, reflectionobj, typename TMP::Generate<R_::MemberCount>::Type());
            
            return t;
        }
 
        template<class T_, class R_ = typename T_::ReflectionType>
        T_ NamedTransform(const R_ &reflectionobj = T_::Reflection()) {
            return NamedTransform<T_, R_>("", reflectionobj);
        }
        
        template<class T_, class R_ = typename T_::ReflectionType>
        T_ NamedTransform(const std::string &prefix, const R_ &reflectionobj = T_::Reflection()) {
            T_ t;
            namedtransform<T_, R_>(t, prefix, reflectionobj, typename TMP::Generate<R_::MemberCount>::Type());
            
            return t;
        }
        
        template<class T_>
        T_ Get(int index) const {
            static_assert(std::is_same<T_, int>::value, "Unknown data type.");
        }
        
        template<class T_>
        T_ Get(const std::string &name) const {
            static_assert(std::is_same<T_, int>::value, "Unknown data type.");
        }
 
        template<class T_>
        T_ &GetObject(int index) const {
            auto &item=dynamic_cast<ObjectData&>(items[index]);
 
            return item.Get<T_>();
        }
 
        template<class T_>
        T_ &GetObject(const std::string &name) const {
            Utils::NotImplemented();
        }
 
        ConstIterator begin() const {
            return items.begin();
        }
 
        ConstIterator end() const {
            return items.end();
        }
 
        Iterator begin() {
            return items.begin();
        }
 
        Iterator end() {
            return items.end();
        }
 
        DataItem &GetItem(int index) const {
            return items[index];
        }
        
        DataItem &GetItem(const std::string &name) const {
            for(auto &item : items) {
                if(item.Name==name) return item;
            }
 
            throw std::runtime_error("Cannot find the item requested: "+name);
        }
        
        int FindIndex(const std::string &name) const {
            int ind=0;
            for(auto &item : items) {
                if(item.Name==name) return ind;
                ind++;
            }
 
            return -1;
        }
        
        int GetCount() const {
            return items.GetCount();
        }
        
        void Remove(int index) {
            items.Delete(index);
        }
 
        void Remove(const std::string &name) {
            int ind = FindIndex(name);
 
            if(ind==-1) {
                throw std::runtime_error("Cannot find the item with the name: "+name);
            }
 
            Remove(ind);
        }
 
        DataItem &Release(int index) {
            auto &item = items[index];
 
            items.Remove(index);
 
            return item;
        }
 
        DataItem &Release(const std::string &name) {
            int ind = FindIndex(name);
 
            if(ind==-1) {
                throw std::runtime_error("Cannot find the item with the name: "+name);
            }
 
            return Release(ind);
        }
 
        void Add(DataItem &item) {
            items.Add(item);
        }
        
        void Insert(DataItem &item, int before) {
            items.Insert(item, before);
        }
        
        static Data *LoadResource(std::weak_ptr<File> file, std::shared_ptr<Reader> reader, unsigned long totalsize);
        
    protected:
        ~Data() {
            items.Destroy();
        }
 
    private:
        virtual void save(Writer &writer) const;
        
        Containers::Collection<DataItem> items;
        
        
    };
 
    template<>
    inline int Data::Get<int>(int index) const {
        auto &item=dynamic_cast<IntegerData&>(items[index]);
 
        return item.Get();
    }
 
    template<>
    inline float Data::Get<float>(int index) const {
        auto &item=dynamic_cast<FloatData&>(items[index]);
 
        return item.Get();
    }
 
    template<>
    inline std::string Data::Get<std::string>(int index) const {
        auto &item=dynamic_cast<TextData&>(items[index]);
 
        return item.Get();
    }
 
    template<>
    inline Geometry::Point Data::Get<Geometry::Point>(int index) const {
        auto &item=dynamic_cast<PointData&>(items[index]);
 
        return item.Get();
    }
 
    template<>
    inline Geometry::Pointf Data::Get<Geometry::Pointf>(int index) const {
        auto &item=dynamic_cast<PointfData&>(items[index]);
 
        return item.Get();
    }
 
    template<>
    inline Geometry::Size Data::Get<Geometry::Size>(int index) const {
        auto &item=dynamic_cast<SizeData&>(items[index]);
 
        return item.Get();
    }
 
    template<>
    inline Geometry::Rectangle Data::Get<Geometry::Rectangle>(int index) const {
        auto &item=dynamic_cast<RectangleData&>(items[index]);
 
        return item.Get();
    }
 
    template<>
    inline Geometry::Bounds Data::Get<Geometry::Bounds>(int index) const {
        auto &item=dynamic_cast<BoundsData&>(items[index]);
 
        return item.Get();
    }
 
    template<>
    inline Geometry::Margin Data::Get<Geometry::Margin>(int index) const {
        auto &item=dynamic_cast<MarginData&>(items[index]);
 
        return item.Get();
    }
 
 
} }