Storage.h

Go to the documentation of this file.

#pragma once
 
#include <stdexcept>
 
#include "../Animation.h"
 
namespace Gorgon { namespace Animation {
 
    template<class T_>
    class basic_StorageInjection {
    };
    
    template<class A_>
    class basic_Storage : public virtual Provider, public basic_StorageInjection<A_> {
    public:
 
        basic_Storage() = default;
 
        basic_Storage(A_ &anim, bool owner = false) : anim(&anim), isowned(owner) { }
 
        basic_Storage(const basic_Storage &) = delete;
 
        basic_Storage(basic_Storage &&other) : anim(other.anim), isowned(other.isowned) {
            other.isowned = false;
            other.anim  = nullptr;
        }
        
        //types are derived not to type the same code for every class
        virtual auto MoveOutProvider() -> decltype(*this) override {
            auto ret = new basic_Storage(std::move(*this));
            
            return *ret;
        }
 
        basic_Storage &operator =(const basic_Storage &) = delete;
 
        basic_Storage &operator =(basic_Storage &&other) {
            Remove();
            isowned = other.isowned;
            anim = other.anim;
            other.isowned = false;
            other.anim = nullptr;
 
            return *this;
        }
 
        bool HasAnimation() const {
            return anim != nullptr;
        }
 
        A_ &GetAnimation() const {
            if(anim)
                return *anim;
            else
                throw std::runtime_error("Storage contains no animation");
        }
        
        A_ &operator *() const {
            return GetAnimation();
        }
        
        A_ *operator ->() const {
            return &GetAnimation();
        }
 
        void SetAnimation(A_ &value, bool owner = false) {
            Remove();
 
            anim = &value;
            this->isowned = owner;
        }
 
        void SetAnimation(A_ &&value) {
            Remove();
 
            anim = &value.MoveOutProvider();
            this->isowned = true;
        }
 
        void Remove() {
            if(isowned)
                delete anim;
 
            isowned = false;
            anim = nullptr;
        }
        
        A_ *Release() {
            auto temp = anim;
            
            isowned = false;
 
            Remove();
 
            return temp;
        }
        
        bool IsOwner() const {
            return isowned;
        }
 
        virtual typename A_::AnimationType &CreateAnimation(ControllerBase &timer) const override {
            if(anim)
                return dynamic_cast<typename A_::AnimationType &>(anim->CreateAnimation(timer));
            else
                throw std::runtime_error("Storage contains no animation");
        }
 
        virtual typename A_::AnimationType &CreateAnimation(bool create=true) const override {
            if(anim)
                return dynamic_cast<typename A_::AnimationType &>(anim->CreateAnimation(create));
            else
                throw std::runtime_error("Storage contains no animation");
        }
        
    private:
        A_ *anim = nullptr;
        bool isowned = false;
    };
 
    template<class Target_, class Original_>
    basic_Storage<Target_> AnimationCast(basic_Storage<Original_> &&original) {
        basic_Storage<Target_> target;
 
        if(!original.HasAnimation())
            return target;
        
 
        bool owned = original.IsOwner();
        Target_ *anim = dynamic_cast<Target_*>(original.Release());
        if(!anim)
            throw std::runtime_error("Animation types are not compatible");
        
        target.SetAnimation(*anim, owned);
 
        return target;
    }
 
    using Storage = basic_Storage<const Provider>;
 
} }