StaircaseFunction.hh

#ifndef GRAIL_STEP_FUNCTION_H
#define GRAIL_STEP_FUNCTION_H
 
#include "Curve.hh"
 
namespace grail
{
    namespace curves
    {
        struct StepData
        {
            float value = 0.0f;
            float startPoint = 0.0f;
            bool inclusiveStartPoint = false;
        };
 
        template <typename ContextType>
        class StaircaseFunction final : public Curve<ContextType>
        {
        public:
            StaircaseFunction(std::shared_ptr<utility::Evaluator<ContextType>> childEvaluator,
                              const std::vector<StepData>& data)
                : Curve<ContextType>{childEvaluator}, data{data}
            {
                #ifndef NDEBUG
                assert(data.size() >= 1);
                float previousX = data[0].startPoint;
                for(size_t i = 1; i < data.size(); ++i)
                {
                    assert(previousX < data[i].startPoint);
                    previousX = data[i].startPoint;
                }
                #endif //NDEBUG
            }
 
            virtual float Sample(float argument) const override final
            {
                for(std::size_t i = data.size() - 1; i > 0; --i)
                {
                    if(argument > data[i].startPoint || (argument == data[i].startPoint && data[i].inclusiveStartPoint))
                    {
                        return data[i].value;
                    }
                }
                return data[0].value;
            }
 
            std::vector<StepData>& GetData() { return data; }
            const std::vector<StepData>& GetData() const { return data; }
 
            virtual EvaluatorType GetEvaluatorType() const override final { return EvaluatorType::CURVE_STAIRCASE; }
 
        private:
            std::vector<StepData> data{};
        };
    }
}
#endif // GRAIL_STEP_FUNCTION_H