CreativeArray.hpp

#ifndef __FIELD_CREATIVE_MULTIARRAY_HPP
#define __FIELD_CREATIVE_MULTIARRAY_HPP "Created 30.08.2004 12:12:12 by bzfbenge"

#include "FieldAPI.h"
#include <memcore/Ageable.hpp>
#include "MemArray.hpp"

namespace Fiber
{
        using MemCore::RefPtr;
        using MemCore::CreatorBase;
        using MemCore::Creator;

class   FIELD_API CreativeArray : public Creator<MemBase>
{
public:
        CreativeArray(const RefPtr<MemBase>&Mb, const RefPtr<MemCore::Cache>&Cache); 

        ~CreativeArray();
};


template <int N>
inline void setSizeInterface(const RefPtr<CreativeArrayBase>&CAB, const MultiIndex<N>&FragmentSize)
{
        if (!CAB) return;

        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->size(); 

        return 0;       
}

inline RefPtr<SizeInterface> getSize(const RefPtr<CreativeArrayBase>&CAB)
{
        if (!CAB)
                return MemCore::NullPtr();

        return MemCore::interface_cast<SizeInterface>(CAB);
}

template <int 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); 
                //{
                //bool tmp = SI->get(MI); 
                        //std::cout << "getDimension() tmp: " << MI << std::endl;
                //return tmp; 
                //return SI->get(MI); 
        //}
        return false;   
}

template <int N>
struct setDimensions
{
static  bool setSizeInterface(const RefPtr<CreativeArrayBase>&DC)
        {
                if (!DC)
                        return false;

        RefPtr<MemBase> MemData = DC->create();
                if (!MemData)
                        return false;

        RefPtr<MemArrayBase<N> > MemDataN = MemData;
                if (!MemDataN)
                        return false;

        MultiIndex<N> Dims = MemDataN->Size();
                ::Fiber::setSizeInterface( DC, Dims );

                return true;
        }
};

template <int N>
inline  bool makeSizeInterface(MultiIndex<N>&Dims, const RefPtr<CreativeArrayBase>&DC)
{
        if (!DC)
                return false; 

RefPtr<MemBase> MemData = DC->create(); 
        if (!MemData)
                return false; 

RefPtr<MemArrayBase<N> > MemDataN = MemData; 
        if (!MemDataN)
                return false; 

        Dims = MemDataN->Size();
        setSizeInterface( DC, Dims ); 

        return true;
}

template <int N>
inline bool makeDimensions(MultiIndex<N>&Dims, const RefPtr<CreativeArrayBase>&DC)
{
        if (!DC)
                return false; 

        if (getDimensions(Dims, DC) )
                //{
                //printf("makeDimensions::getDimensions()\n");fflush(stdout);
                return true; 
                //} 
        //printf("makeDimensions::makeSizeInterface()");fflush(stdout);
        return makeSizeInterface(Dims, DC);
}

extern FIELD_API index_t NumberOfElements(const RefPtr<CreativeArrayBase>&CAB);

extern FIELD_API MemCore::memsize_t getMemoryUsage(const CreativeArrayBase&CAB);


} // namespace Fiber


#endif /* __FIELD_CREATIVE_MULTIARRAY_HPP */