Instance.h

Go to the documentation of this file.

#pragma once
 
#include "../Animation.h"
 
namespace Gorgon { namespace Animation {
    
    template<class T_>
    class basic_InstanceInjection {
    };
    
    template<class A_>
    class basic_Instance : public virtual Base, public basic_InstanceInjection<A_> {
    public:
        
        basic_Instance() = default;
        
        basic_Instance(A_ &instance, bool owner = true) : instance(&instance), isowned(owner) { }
 
        basic_Instance(const basic_Instance &) = delete;
 
        basic_Instance(basic_Instance &&other) : instance(other.instance), isowned(other.isowned) {
            other.isowned = false;
            other.instance  = nullptr;
        }
        
        basic_Instance &operator =(const basic_Instance &) = delete;
 
        basic_Instance &operator =(basic_Instance &&other) {
            Remove();
            isowned = other.isowned;
            instance = other.instance;
            other.isowned = false;
            other.instance = nullptr;
 
            return *this;
        }
        
        basic_Instance &operator =(A_ &instance) {
            Remove();
            isowned = true;
            this->instance = &instance;
 
            return *this;
        }
 
        bool HasAnimation() const {
            return instance != nullptr;
        }
        
        A_ &GetAnimation() const {
            if(instance)
                return *instance;
            else
                throw std::runtime_error("Instance contains no animation");
        }
        
        A_ &operator *() const {
            return GetAnimation();
        }
        
        A_ *operator ->() const {
            return &GetAnimation();
        }
        
        void SetAnimation(A_ &value, bool owner = true) {
            Remove();
 
            instance = &value;
            this->isowned = owner;
        }
        
        void Remove() {
            if(isowned)
                instance->DeleteAnimation();
 
            isowned = false;
            instance = nullptr;
        }
        
        A_ *Release() {
            auto temp = instance;
            
            isowned = false;
 
            Remove();
 
            return temp;
        }
        
        bool IsOwner() const {
            return isowned;
        }
 
        
    private:
        A_ *instance = nullptr;
        bool isowned = false;
    };
    
 
    template<class Target_, class Original_>
    basic_Instance<Target_> AnimationCast(basic_Instance<Original_> &&original) {
        basic_Instance<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 Instance = basic_Instance<const Base>;
    
} }