Ownable.hpp

#ifndef __FIBER_OWNED_HPP
#define __FIBER_OWNED_HPP
 
#include "FieldAPI.h"
#include <memcore/RefPtr.hpp>
#include <memcore/Interface.hpp>
#include <memcore/Verbose.hpp>
#include <memcore/Ageable.hpp>
 
#include <unordered_set>
 
namespace Fiber
{
 
class   FIELD_API OwnerBase
{
public:
        OwnerBase();
 
        ~OwnerBase();
 
        virtual bool processOwnership(MemCore::Intercube&Output,
                                      const MemCore::Intercube&Input) const = 0;
 
        bool    processOwnership(MemCore::Intercube&OutputAndInput) const
        {
                return processOwnership(OutputAndInput, OutputAndInput);
        }
 
        template <class ItemType>
        using   Item = MemCore::InterfaceData<ItemType>;
 
 
        virtual void x_updateOwnershipAge(const MemCore::Ageable&) = 0;
};
 
struct  ChildrenProperties
{
        MemCore::Ageable
                youngestChildAge  =  MemCore::Ageable::InfinitelyOld();
};
 
 
template <class Domain, class ContainerBase = ChildrenProperties>
class   Ownable : public virtual OwnerBase
{
public:
 
        class   Container : public MemCore::ReferenceBase<Container>
                          , public virtual OwnerBase
                          , public ContainerBase
        {
        public:
                Container()
                : MemCore::ReferenceBase<Container>(this)
                {}
 
                class   PassThrough : public MemCore::Interface<PassThrough>
                {
                public:
                        MemCore::WeakPtr<Container> myContainer;
 
                        PassThrough(const MemCore::WeakPtr<Container>&theContainer)
                        : myContainer( theContainer )
                        {}
                };
 
                void    recognizeOwnership(MemCore::Intercube&Output)
                {
                        Output.addInterface(new PassThrough( this->self() ) );
                }
 
inline  static  MemCore::WeakPtr<Container> getOwnershipPassThroughItem(const MemCore::Intercube&Ic)
                {
                        if (MemCore::RefPtr<PassThrough> PT = MemCore::interface_cast<PassThrough>(Ic))
                        {
                                return PT->myContainer;
                        }
                        return  nullptr;
                }
        };
 
        std::unordered_set<MemCore::WeakPtr<Container> >        Owners;
 
 
        void    x_updateOwnershipAge(const MemCore::Ageable&theNewAge) override
        {
                for(auto oIt : Owners)
                {
                        if (const MemCore::WeakPtr<Container> myContainer = oIt)
                        {
                                myContainer->x_updateOwnershipAge(theNewAge);
                        }
                }
        }
 
        void    insertOwner(const Container&theOwner)
        {
                Owners.insert( theOwner.self() );
        }
 
 
        bool    insertOwner(const MemCore::WeakPtr<Container>&theOwner)
        {
                if (theOwner)
                {
                        insertOwner( *theOwner );
                        return true;
                }
                return false;
        }
 
        void    addOwner(const Container&theOwner, const MemCore::Ageable&theNewAge)
        {
                insertOwner( theOwner );
                x_updateOwnershipAge( theNewAge );
        }
 
        void    addOwner(const MemCore::WeakPtr<Container>&theOwner, const MemCore::Ageable&theNewAge)
        {
                if (insertOwner( theOwner ) )
                        x_updateOwnershipAge( theNewAge );
        }
 
        Ownable()
        {}
 
        Ownable(const Ownable&)
        {}
 
        Ownable&operator=(const Ownable&)
        {
                return *this;
        }
 
        Ownable(const MemCore::WeakPtr<Container>&theOwner, const MemCore::Ageable&theNewAge)
        {
                if (theOwner)
                        addOwner( theOwner, theNewAge );
        }
 
        Ownable(const Container&theOwner, const MemCore::Ageable&theNewAge)
        {
                addOwner( theOwner.self(), theNewAge );
        }
 
        MemCore::WeakPtr<Container> getPrimaryOwner() const
        {
                for(auto oIt : Owners)
                {
                        if (oIt)
                                return oIt;
                }
 
                return ::MemCore::NullPtr();
        }
 
        size_t  getNumberOfValidOwners() const
        {
        size_t  NumberOfValidOwners = 0;
                for(auto oIt : Owners)
                {
                        if (oIt)
                                NumberOfValidOwners++;
                }
 
                return NumberOfValidOwners;
        }
 
        bool    processOwnership(MemCore::Intercube&Output, const MemCore::Intercube&Input) const override
        {
                Verbose(200) << "   -- Checking " << this->Owners.size() << " owners for " << typeid(*this);
 
                for(auto oIt : Owners)
                {
                        if (const MemCore::WeakPtr<Container> myContainer = oIt)
                        {
                                Verbose(200) << "    -- processing owner " << myContainer;
 
                                myContainer->recognizeOwnership(Output);
                                if (!myContainer->processOwnership(Output, Input ) )
                                        return false;
                        }
                }
                return true;
        }
};
 
 
 
template <class OwnedObjectType, class ContainerBase = ChildrenProperties>
using OwnerOf = typename Ownable<OwnedObjectType, ContainerBase>::Container;
 
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_OWNED_HPP */