BundleProperty.hpp

#ifndef __FIBER_BUNDLEPROPERTY_HPP
#define __FIBER_BUNDLEPROPERTY_HPP
 
#include "Bundle.hpp"
 
namespace Fiber
{
 
class   GridSelector;
class   BUNDLE_API BundleProperty;
 
BUNDLE_API bool hasProperty(const GridSelector&, const BundleProperty&);
 
class   BUNDLE_API BundleProperty
{
 
public:
        BundleProperty()
        {}
 
        virtual ~BundleProperty() = 0;
 
        friend BUNDLE_API bool hasProperty(      BundlePtr, const BundleProperty&);
        friend BUNDLE_API bool hasProperty(const Bundle&  , const BundleProperty&);
 
//      friend BUNDLE_API bool hasProperty(const GridSelector&, const BundleProperty&);
 
        virtual bool checkSlice(Slice&S, const string&GridName) const = 0;
 
        class   BUNDLE_API Anything;
};
 
class   BUNDLE_API BundleProperty::Anything : public BundleProperty
{
public:
        ~Anything();
 
        bool checkSlice(Slice&S, const string&GridName) const override;
};
 
class   BUNDLE_API GridProperty : public BundleProperty
{
public:
        ~GridProperty() = 0;
 
        bool checkSlice(Slice&S, const string&GridName) const override;
 
        virtual bool checkGrid(const Grid&S) const = 0;
};
 
class   BUNDLE_API SkeletonExistence : public GridProperty, public SkeletonID
{
public:
        SkeletonExistence(int Dimensionality, int theIndexDepth)
        : SkeletonID(Dimensionality, theIndexDepth)
        {}
 
        SkeletonExistence(const SkeletonID&sid)
        : SkeletonID(sid)
        {}
 
        ~SkeletonExistence();
 
        bool checkGrid(const Grid&S) const override;
};
 
using   hasSkeleton = SkeletonExistence;
 
template< class GridType >
class   hasSkeletonOfGridType : public virtual GridProperty
{
 
public:
        bool    checkGrid(const Grid&G) const override
        {
                hasSkeleton hs( GridType::ID()  );
                return hs.checkGrid( G );
        }
};
 
class   BUNDLE_API isUniformCartesianGrid : public GridProperty
{
 
public:
        bool checkGrid(const Grid&G) const override;
 
        ~isUniformCartesianGrid();
};
 
 
class   BUNDLE_API isFragmentedUniformCartesianGrid : public GridProperty
{
 
public:
        bool checkGrid(const Grid&G) const override;
 
        ~isFragmentedUniformCartesianGrid();
};
 
 
template <int Dimensions>
class   isRegularGrid : public GridProperty
{
 
public:
        bool checkGrid(const Grid&G) const override
        {
                if (RefPtr<Representation> R = G.getCartesianRepresentation())
                {
                        if (RefPtr<Field> Positions = R->getPositions() )
                        {
                        int     PositionDims = Positions->Dims();
                                if (PositionDims == Dimensions)
                                        return true;
 
                                // no information available?
                                // in that case assume it's fitting.
                                if (PositionDims == -1)
                                        return true;
 
                                return false;
                        }
                }
                return false;
        }
};
 
class   BUNDLE_API isCurvilinearGrid : public GridProperty
{
 
public:
        bool checkGrid(const Grid&G) const override;
        ~isCurvilinearGrid();
};
 
 
class   BUNDLE_API hasCartesianCoordinates : public GridProperty
{
 
public:
        bool checkGrid(const Grid&G) const override;
 
        ~hasCartesianCoordinates();
};
 
class   BUNDLE_API hasExplicitCartesianCoordinates : public GridProperty
{
 
public:
        bool checkGrid(const Grid&G) const override;
 
        ~hasExplicitCartesianCoordinates();
};
 
 
template <class FirstProperty, class SecondProperty>
struct  AND : FirstProperty, SecondProperty
{
        bool checkSlice(Slice&S, const string&GridName) const override
        {
                return  FirstProperty::checkSlice(S, GridName) &&
                        SecondProperty::checkSlice(S, GridName);
        }
};
 
template <class FirstProperty, class SecondProperty>
struct  OR : FirstProperty, SecondProperty
{
        bool checkSlice(Slice&S, const string&GridName) const override
        {
                return  FirstProperty::checkSlice(S, GridName) ||
                        SecondProperty::checkSlice(S, GridName);
        }
};
 
template <class SomeProperty>
struct NOT : SomeProperty
{
        bool checkSlice(Slice&S, const string&GridName) const override
        {
                return  !SomeProperty::checkSlice(S, GridName);
        }
};
 
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_BUNDLEPROPERTY_HPP */