BinaryOperator.hpp

#ifndef __FIBER_FIELD_BINARY_OPERATOR_HPP
#define __FIBER_FIELD_BINARY_OPERATOR_HPP
 
#include "ComputationalField.hpp"
 
namespace Fiber
{
 
 
template <class Operator, class PrimaryValueType,
          class SecondaryValueType = PrimaryValueType,
          class ResultValueType    = PrimaryValueType>
struct  BinaryOperator
{
        RefPtr<Field>   SecondaryField;
 
        typedef PrimaryValueType        primary_value_type;
        typedef SecondaryValueType      secondary_value_type;
 
        typedef ResultValueType         result_type;
 
        BinaryOperator( const RefPtr<Field>&theSecondaryField )
        : SecondaryField(theSecondaryField)
        {}
 
        template <Dims_t Dims>
        bool    computeFragment(MemArray<Dims, result_type>&Result,
                                const MemArray<Dims, primary_value_type>&PrimaryArray,
                                const RefPtr<FragmentID>&myFragmentID)
        {
        typedef MemArray<Dims, secondary_value_type> SecondaryArray_t;
 
                assert( SecondaryField );
 
                if (RefPtr<SecondaryArray_t>
                    pSecondaryArray = SecondaryField->getData(myFragmentID) )
                {
                const MultiArray<Dims, secondary_value_type>
                        &SecondaryArray = *pSecondaryArray;
 
                MultiIndex<Dims> Size = Result.Size();
                MultiIndex<Dims> Index;
 
                do
                {
                        Operator::ternary(Result[ Index ], PrimaryArray[ Index ], SecondaryArray[ Index ] );
                }
                while( Index.inc(Size) );
 
                return true;
                }
                return false;
        }
};
 
} // namespace Fiber
 
 
#endif // __FIBER_FIELD_BINARY_OPERATOR_HPP