CreativeArrayBase.hpp

#ifndef __FIBER_CREATIVEARRAYBASE_HPP
#define __FIBER_CREATIVEARRAYBASE_HPP
 
#include "FieldAPI.h"
#include <memcore/RefPtr.hpp>
#include <memcore/Interface.hpp>
#include <memcore/Persistencer.hpp>
#include <memcore/Cacheable.hpp>
#include <memcore/Cache.hpp>
#include <memcore/Creator.hpp>
#include <memcore/Chunk.hpp>
 
#include <typeinfo>
#include "FiberType.hpp"
#include "MemBase.hpp"
#include "BinderBase.hpp"
#include "Ownable.hpp"
#include <memcore/Attributes.hpp>
 
namespace Fiber
{
 
class   FIELD_API SaveableAttributes : public MemCore::Attributes
{
public:
        mutable MemCore::Ageable LastSavedAttributes;
 
        ~SaveableAttributes();
 
        void    attributesHaveBeenSaved() const
        {
                LastSavedAttributes.touch();
        }
 
        bool    attributesNeedSaving() const
        {
                return AttributeModificationAge.isYoungerThan( LastSavedAttributes );
        }
};
 
 
struct  CreativeArrayBaseContainerBase
{
        MemCore::Ageable
                newestFragmentCreator    =  MemCore::Ageable::InfinitelyOld(),
                newestFragmentAttributes =  MemCore::Ageable::InfinitelyOld(),
                newestFragmentRange      =  MemCore::Ageable::InfinitelyOld(),
                newestLastSavedCreator   =  MemCore::Ageable::InfinitelyOld();
};
 
 
class   FIELD_API CreativeArrayBase : public MemCore::CreatorBase<MemBase>
                                    , public Ownable<CreativeArrayBase, CreativeArrayBaseContainerBase>
                                    , public SaveableAttributes
{
protected:
 
        ~CreativeArrayBase();
 
        FiberTypeIndex          myFiberTypeIndex;
        MemCore::WeakPtr<FiberTypeBase> myFiberTypeBase;
 
public:
        mutable Ageable LastSaved;
 
        mutable AgeRelativeToBinder LastSavedTimes;
 
        enum    class   CreationFailure
        {
                None,
                OutOfMemory,
                CannotOpen,
                CannotRead,
                CannotSave,
                Timeout,
                Unknown
        }
                Error = CreationFailure::None;
 
static  bool    retryCreation(CreativeArrayBase&);
 
        CreativeArrayBase(const MemCore::WCachePtr&theCache);
 
        Ageable&touch() throw();
 
        const Ageable&touchAttributes() const;
        const Ageable&updateAttributeAge(const Ageable&A) const;
 
        void    extremeUnction();
 
        bool    needsSaving() const
        {
                return isYoungerThan(LastSaved);
        }
 
        void    hasBeenSaved() const
        {
                LastSaved.update( *this );
                attributesHaveBeenSaved();
        }
 
        void    addDataMetaInfo(const MemCore::RefPtr<MemBase>&D);
 
        const FiberTypeIndex&getFiberTypeIndex() const
        {
                return myFiberTypeIndex;
        }
 
        auto    value_type_size() const
        {
                return  getFiberTypeIndex().value_type_size();
        }
 
 
        RefPtr<FiberTypeBase>   getFiberType() const;
 
        void    setFiberType(const RefPtr<FiberTypeBase>&FTB);
 
        template <class ...T>
        bool    isType() const
        {
                if (RefPtr<FiberTypeBase> ftb = getFiberType() )
                        return ftb->isType<T...>();
 
                return false;
        }
 
        void    addMetaInfo(const DynamicSize&theSize,
                            const RefPtr<FiberTypeBase>&theDataType);
 
        void    addMetaInfo(int nDimensions,
                            const RefPtr<FiberTypeBase>&theDataType);
 
 
        RefPtr<BinderBase>
                getBinder() const;
 
 
        void    save(const MemCore::RefPtr<MemBase>&D) const;
 
#if     0
        template <class RefType>
        Creature::ReasonForReleasal release_ptr_with_possible_saving(RefPtr<RefType>&Data, bool needsSaving) const
        {
                if (!Data)
                        return successfully_released;
 
                {
                VerboseSection(100, ' ');
 
                        {
                MemCore::RefPtr<MemBase> D = Data;
                                if (needsSaving)
                                {
//                      Verbose(110) << "   CreativeArrayBase is saving data for " << D;
                                        save(D);
                                }
 
                                /*
                                  One strong reference for the stored data type
                                  another strong reference for the local copy here.
                                */
                                if (Data.strong_refs()>2)
                                {
                                        Verbose(110) << "   CreativeArrayBase was unable to release data object " << D;
                                        return temporarily_unreleasable;
                                }
 
                                Verbose(110) << "   CreativeArrayBase is releasing data object " << D;
                                Data = nullptr;
                        }
                        Verbose(110) << "   --> CreativeArrayBase has RELEASED data object " << Data;
                }
 
                return successfully_released;
        }
#endif
};
 
inline RefPtr<MemBase> getMemBase(const MemCore::WeakPtr<CreativeArrayBase>&MemDataCreator)
{
        if (MemDataCreator)
                return MemDataCreator->create();
 
        return  nullptr;
}
 
inline RefPtr<MemCore::ChunkBase> getChunk(const MemCore::WeakPtr<CreativeArrayBase>&MemDataCreator)
{
        if (MemDataCreator)
                return getChunk(MemDataCreator->create() );
 
        return  nullptr;
}
 
inline RefPtr<MemBase> operator-(const MemCore::WeakPtr<CreativeArrayBase>&MemDataCreator)
{
        return getMemBase( MemDataCreator );
}
 
inline RefPtr<MemCore::ChunkBase> operator+(const MemCore::WeakPtr<CreativeArrayBase>&MemDataCreator)
{
        return -(-MemDataCreator);
}
 
 
template <Dims_t N>
inline void setSizeInterface(const RefPtr<CreativeArrayBase>&CAB, const MultiIndex<N>&FragmentSize)
{
        if (!CAB) return;
 
        CAB->addInterface( new SizeInterface( FragmentSize ) );
}
 
template <Dims_t N>
inline void setSizeInterface(CreativeArrayBase&CAB, const MultiIndex<N>&FragmentSize)
{
        CAB.addInterface( new SizeInterface( FragmentSize ) );
}
 
inline int getRank(const RefPtr<CreativeArrayBase>&CAB)
{
        if (!CAB)
                return 0;
 
RefPtr<SizeInterface> SI = MemCore::interface_cast<SizeInterface>(CAB);
        if (SI)
                return SI->getRank();
 
        return 0;
}
 
extern FIELD_API RefPtr<SizeInterface> getSize(const CreativeArrayBase&CAB);
extern FIELD_API RefPtr<SizeInterface> makeSize(CreativeArrayBase&CAB);
 
inline RefPtr<SizeInterface> getSize(const RefPtr<CreativeArrayBase>&CAB)
{
        if (!CAB) return nullptr;
        return getSize(*CAB);
}
 
inline RefPtr<SizeInterface> makeSize(const RefPtr<CreativeArrayBase>&CAB)
{
        if (!CAB) return nullptr;
        return makeSize(*CAB);
}
 
inline  index_t getNumberOfElements(const RefPtr<CreativeArrayBase>&CAB)
{
        if (RefPtr<SizeInterface> S = getSize( CAB ) )
                return S->getNumberOfElements();
 
        return 0;
}
 
inline  index_t getNumberOfElements(CreativeArrayBase&CAB)
{
        if (RefPtr<SizeInterface> S = getSize( CAB ) )
                return S->getNumberOfElements();
 
        return 0;
}
 
 
template <Dims_t N>
inline bool getDimensions(MultiIndex<N>&MI, const RefPtr<CreativeArrayBase>&CAB)
{
        if (!CAB)
                return false;
 
RefPtr<SizeInterface> SI = MemCore::interface_cast<SizeInterface>(CAB);
        if (SI)
                return SI->get(MI);
 
        return false;
}
 
extern FIELD_API MemCore::memsize_t getMemoryUsage(const CreativeArrayBase&CAB);
 
 
} // namespace Fiber
 
 
#endif /* __FIBER_CREATIVEARRAYBASE_HPP */