valueVectorFunction.hpp

Go to the documentation of this file.

#ifndef ValueVectorFunctionHppIncluded
#define ValueVectorFunctionHppIncluded



#include "cbls/frames/index.hpp"


openKangarooSpace



template <typename value, typename metric = value, VectorType vectorType = FactorVector>
class ValueVectorFunction : public Function
{
    public:


        typedef value ValueType;                                                    
        typedef metric MetricType;                                                  

        virtual Wrap ExecWrappedValue() const override final;                       
        virtual Wrap SimulWrappedValue() const override final;                      
        virtual Dim VectorFieldCount() const override final;                        
        virtual Wrap ExecWrappedVectorField(Order const MaxiOrMini,
                            Serial const FieldSerial) const override final;         

        virtual ValueRecord<value> const * ExprValueRecord() const override final;  
        virtual VectorRecord<metric> const * ExprVectorRecord
                            (Order const MaxiOrMini) const override final;          
        virtual VectorType ExprVectorType() const override final;                   
        virtual Serial ValueTypeSerial() const override final;                      
        virtual Serial MetricTypeSerial() const override final;                     

        value ExecValue() const;                                                    
        value SimulValue() const;                                                   
        Order MetricOptiOrder() const;                                              
        metric ExecVectorField(Order MaxiOrMini, Serial const FieldSerial) const;   


    protected:


        virtual ~ValueVectorFunction();                                                                     
        ValueVectorFunction(System * const pSystem, Order const MaxiOrMini, Dim const ParamCount);          
        ValueVectorFunction(ValueVectorFunction<value,metric,vectorType> && that) noexcept = delete;        
        ValueVectorFunction(ValueVectorFunction<value,metric,vectorType> const & that) = delete;            
        ValueVectorFunction<value,metric,vectorType> & operator =
                                (ValueVectorFunction<value,metric,vectorType> && that) noexcept = delete;  
        ValueVectorFunction<value,metric,vectorType> & operator =
                                (ValueVectorFunction<value,metric,vectorType> const & that) = delete;      



        ValueRecord<value> *    mExprValueRecord;                       
        VectorRecord<metric> *  mExprVectorRecord;                      
        Order const mMetricOptiOrder;                                   

        void defineExprValueRecord();                                   
        void defineExprVectorRecord(Dim const FieldCount);              



        virtual Wrap ExecWrappedScalar(Order const MaxiOrMini) const;  


        #if ComputeLazy

        virtual void setupUndoPatrons() override final;                         
        virtual void undoVectors(Serial const ParamSerial) override;            

        #endif // ComputeLazy


        protected:

            virtual void syncExecClock();       
            virtual void syncSimulClock();      

};



template<typename value, typename metric, VectorType vectorType>
inline ValueVectorFunction<value,metric,vectorType>::ValueVectorFunction(System * const pSystem,
            Order const MaxiOrMini, Dim const ParamCount) :
        Function(pSystem, ParamCount), mExprValueRecord(nullptr),
        mExprVectorRecord(nullptr), mMetricOptiOrder(MaxiOrMini)
{
    WatchError
    setExprModel(identifier<ValueVectorFunction<value,metric,vectorType> >());
    CatchError
}


template<typename value, typename metric, VectorType vectorType>
inline ValueVectorFunction<value,metric,vectorType>::~ValueVectorFunction()
{
    WatchError
    if (mExprValueRecord) delete mExprValueRecord;
    if (mExprVectorRecord) delete mExprVectorRecord;
    CatchError
}



template<typename value, typename metric, VectorType vectorType>
inline Wrap ValueVectorFunction<value,metric,vectorType>::ExecWrappedValue() const
{
    WatchError
    return Wrap(mExprValueRecord->ExecData());
    CatchError
}



template<typename value, typename metric, VectorType vectorType>
inline Wrap ValueVectorFunction<value,metric,vectorType>::SimulWrappedValue() const
{
    WatchError
    return Wrap(mExprValueRecord->SimulData(SysMaster->SimulClock()));
    CatchError
}


template<typename value, typename metric, VectorType vectorType>
inline Dim ValueVectorFunction<value,metric,vectorType>::VectorFieldCount() const
{
    WatchError
    return mExprVectorRecord->FieldCount();
    CatchError
}


template<typename value, typename metric, VectorType vectorType>
inline Wrap ValueVectorFunction<value,metric,vectorType>::ExecWrappedVectorField
    (Order const MaxiOrMini, Serial const FieldSerial) const
{
    WatchError
    Warn(MaxiOrMini != mMetricOptiOrder, kExprVectorNotDefined);
    return Wrap(mExprVectorRecord->Field(FieldSerial).ExecData());
    CatchError
}



template<typename value, typename metric, VectorType vectorType>
inline value ValueVectorFunction<value,metric,vectorType>::ExecValue() const
{
    WatchError
    return mExprValueRecord->ExecData();
    CatchError
}



template<typename value, typename metric, VectorType vectorType>
inline value ValueVectorFunction<value,metric,vectorType>::SimulValue() const
{
    WatchError
    return mExprValueRecord->SimulData(SysMaster->SimulClock());
    CatchError
}


template<typename value, typename metric, VectorType vectorType>
inline metric ValueVectorFunction<value,metric,vectorType>::ExecVectorField
        (Order MaxiOrMini, Serial const FieldSerial) const
{
    WatchError
    Warn(MaxiOrMini != mMetricOptiOrder, kExprVectorNotDefined);
    return mExprVectorRecord->Field(FieldSerial).ExecData();
    CatchError
}



template<typename value, typename metric, VectorType vectorType>
inline VectorType ValueVectorFunction<value,metric,vectorType>::ExprVectorType() const
{
    WatchError
    return vectorType;
    CatchError
}


template<typename value, typename metric, VectorType vectorType>
inline Order ValueVectorFunction<value,metric,vectorType>::MetricOptiOrder() const
{
    WatchError
    return mMetricOptiOrder;
    CatchError
}



template<typename value, typename metric, VectorType vectorType>
inline Serial ValueVectorFunction<value,metric,vectorType>::ValueTypeSerial() const
{
    WatchError
    return DataTypeMeta<value>::TypeSerial;
    CatchError
}



template<typename value, typename metric, VectorType vectorType>
inline Serial ValueVectorFunction<value,metric,vectorType>::MetricTypeSerial() const
{
    WatchError
    return DataTypeMeta<metric>::TypeSerial;
    CatchError
}



template<typename value, typename metric, VectorType vectorType>
inline ValueRecord<value> const * ValueVectorFunction<value,metric,vectorType>::ExprValueRecord() const
{
    WatchError
    return mExprValueRecord;
    CatchError
}



template<typename value, typename metric, VectorType vectorType>
inline VectorRecord<metric> const * ValueVectorFunction<value,metric,vectorType>::ExprVectorRecord(Order const MaxiOrMini) const
{
    WatchError
    if (MaxiOrMini == mMetricOptiOrder)
        return mExprVectorRecord;
    else
        return nullptr;
    CatchError
}



template<typename value, typename metric, VectorType vectorType>
inline void ValueVectorFunction<value,metric,vectorType>::defineExprValueRecord()
{
    WatchError
    mExprValueRecord = new ValueRecord<value>;
    CatchError
}



template<typename value, typename metric, VectorType vectorType>
inline void ValueVectorFunction<value,metric,vectorType>::defineExprVectorRecord(Dim const FieldCount)
{
    WatchError
    mExprVectorRecord = new VectorRecord<metric>(FieldCount);
    CatchError
}



template<typename value, typename metric, VectorType vectorType>
inline void ValueVectorFunction<value,metric,vectorType>::syncExecClock()
{
    WatchError
    if (mExprValueRecord) mExprValueRecord->syncExecClock();
    if (mExprVectorRecord) mExprVectorRecord->syncExecClock();
    Function::syncExecClock();
    CatchError
}


template<typename value, typename metric, VectorType vectorType>
inline void ValueVectorFunction<value,metric,vectorType>::syncSimulClock()
{
    WatchError
    if (mExprValueRecord) mExprValueRecord->syncSimulClock();
    Function::syncSimulClock();
    CatchError
}



template<typename value, typename metric, VectorType vectorType>
inline Wrap ValueVectorFunction<value,metric,vectorType>::ExecWrappedScalar(Order const MaxiOrMini) const
{
    WatchError
    Throw(kExprScalarNotDefined);
    CatchError
}



#if ComputeLazy

template<typename value, typename metric, VectorType vectorType>
inline void ValueVectorFunction<value,metric,vectorType>::setupUndoPatrons()
{
    WatchError
    setupScalarUndoPatrons();
    setupVectorUndoPatrons();
    CatchError
}
#endif  //ComputeLazy



#if ComputeLazy

template<typename value, typename metric, VectorType vectorType>
inline void ValueVectorFunction<value,metric,vectorType>::undoVectors(Serial const ParamSerial)
{
    WatchError
    Throw(kVectorUndoNotDefined);
    CatchError
}
#endif  //ComputeLazy



closeKangarooSpace


#endif//ValueVectorFunctionHppIncluded