MHO_UnaryOperator.hh

Go to the documentation of this file.

#ifndef MHO_UnaryOperator_HH__
#define MHO_UnaryOperator_HH__
 
#include "MHO_Operator.hh"
 
#include <tuple>
 
namespace hops
{
 
//
template< class XArgType > class MHO_UnaryOperator: public MHO_Operator
{
    public:
        MHO_UnaryOperator()
        {
            fInPlace = false;
            std::get< 0 >(fInPlaceArgs) = nullptr;
            std::get< 0 >(fOutOfPlaceArgs) = nullptr;
            std::get< 1 >(fOutOfPlaceArgs) = nullptr;
        };
 
        virtual ~MHO_UnaryOperator(){};
 
        void SetArgs(XArgType* in)
        {
            fInPlace = true;
            fInPlaceArgs = std::make_tuple(in);
        }
 
        //out-of-place operation, result stored in out, input unmodified
        void SetArgs(const XArgType* in, XArgType* out)
        {
            fInPlace = false;
            fOutOfPlaceArgs = std::make_tuple(in, out);
        };
 
        virtual bool Initialize() override
        {
            if(fInPlace)
            {
                return InitializeInPlace(std::get< 0 >(fInPlaceArgs));
            }
            else
            {
                return InitializeOutOfPlace(std::get< 0 >(fOutOfPlaceArgs), std::get< 1 >(fOutOfPlaceArgs));
            }
        }
 
        virtual bool Execute() override
        {
            if(fInPlace)
            {
                return ExecuteInPlace(std::get< 0 >(fInPlaceArgs));
            }
            else
            {
                return ExecuteOutOfPlace(std::get< 0 >(fOutOfPlaceArgs), std::get< 1 >(fOutOfPlaceArgs));
            }
        }
 
    protected:
        virtual bool InitializeInPlace(XArgType* /*in*/) { return true; }
 
        virtual bool InitializeOutOfPlace(const XArgType* /*in*/, XArgType* /*out*/) { return true; }
 
        virtual bool ExecuteInPlace(XArgType* in) = 0;
 
        virtual bool ExecuteOutOfPlace(const XArgType* in, XArgType* out)
        {
            out->Copy(*in);
            return ExecuteInPlace(out);
        }
 
        //place for args to be stored for derived class to pick them up/modify
        bool fInPlace;
        std::tuple< XArgType* > fInPlaceArgs;
        std::tuple< const XArgType*, XArgType* > fOutOfPlaceArgs;
};
 
} // namespace hops
 
#endif