DynamicSize.hpp

//
// $Id: DynamicSize.hpp,v 1.5 2008/03/10 20:20:50 werner Exp $
//
#ifndef __FIBER_DYNAMICSIZE_HPP
#define __FIBER_DYNAMICSIZE_HPP

#include "FieldAPI.h"
#include <memcore/RefPtr.hpp>
#include <memcore/Interface.hpp>
#include <vector/MultiIndex.hpp>

namespace Fiber
{

class FIELD_API DynamicSize
{
        int     rank;
        index_t *dims;

protected: 
        DynamicSize(int N, const DynamicSize&L, const DynamicSize&R);

public:
        template <int N>
        DynamicSize(const MultiIndex<N>&MI)
        : rank(N)
        {
                dims = new index_t[ N ]; 
                for(int i=0; i<N; i++)
                        dims[i] = MI[i];
        }

        template <class T>
        DynamicSize(int N, const T values[])
        : rank(N)
        {
                dims = new index_t[ N ]; 
                for(int i=0; i<N; i++)
                        dims[i] = values[i];
        } 

        DynamicSize(int N)
        : rank(N)
        {
                if (N>0)
                {
                        dims = new index_t[ N ]; 
                        for(int i=0; i<N; i++)
                                dims[i] = 1;
                } 
                else
                        dims = 0;
        }

        DynamicSize()
        : rank(0)
        , dims(0)
        {}

        DynamicSize(const DynamicSize&DS);

        ~DynamicSize();

        DynamicSize&operator=(const DynamicSize&DS);

        bool operator!=(const DynamicSize&DS);

        index_t nElements() const
        {
                if (!dims) return 0;

        index_t N = 1; 
                for(int i=0; i<rank; i++)
                {
                        N *= dims[i];
                } 
                return N;
        }

        int     size() const
        {
                return rank;
        }

        int Rank() const
        {
                return rank;
        }

        int dimensionality() const
        {
                return rank;
        }

        index_t operator[](int i) const
        {
                if (!dims) 
                        return 0;

                if (i>=0 && i<rank)
                        return dims[i]; 
                else
                        return 1;       
        } 

        const index_t *dims_ptr() const
        {
                return dims;
        } 

        bool setSize(int i, index_t what)
        {
                if (!dims) 
                        return false;

                if (i>=0 && i<rank)
                {
                        dims[i] = what; 
                        return true;
                } 

                return 1;       
        } 

        template <int N>
        bool get(MultiIndex<N>&MI) const
        {
                if (rank != N)
                        return false;

                for(int i=0; i<N; i++)
                        MI[i] = dims[i]; 

                return true;
        }
};

class FIELD_API SizeInterface : public MemCore::Interface<SizeInterface>, public DynamicSize
{
        SizeInterface(int rank, const SizeInterface&L, const SizeInterface&R);

public:
        template <int N>
        SizeInterface(const MultiIndex<N>&MI)
        : DynamicSize(MI)
        {} 

        SizeInterface(int N)
        : DynamicSize(N)
        {}

        SizeInterface(const SizeInterface&DS);

        ~SizeInterface();

        using DynamicSize::size;
        using DynamicSize::operator[];
        using DynamicSize::operator!=;
        using DynamicSize::operator=; 

        friend  MemCore::RefPtr<SizeInterface> operator+(const MemCore::RefPtr<SizeInterface>&L,
                                                         const MemCore::RefPtr<SizeInterface>&R);
};

} /* namespace Fiber */ 

#endif /* __FIBER_DYNAMICSIZE_HPP */