snippet.h

Go to the documentation of this file.

#pragma once

// Standard C++ includes
#include <functional>
#include <string>
#include <vector>

//----------------------------------------------------------------------------
// Macros
//----------------------------------------------------------------------------
#define DECLARE_SNIPPET(TYPE, NUM_PARAMS)               \
private:                                                \
    static TYPE *s_Instance;                            \
public:                                                 \
    static const TYPE *getInstance()                    \
    {                                                   \
        if(s_Instance == NULL)                          \
        {                                               \
            s_Instance = new TYPE;                      \
        }                                               \
        return s_Instance;                              \
    }                                                   \
    typedef Snippet::ValueBase<NUM_PARAMS> ParamValues; \


#define IMPLEMENT_SNIPPET(TYPE) TYPE *TYPE::s_Instance = NULL

#define SET_PARAM_NAMES(...) virtual StringVec getParamNames() const override{ return __VA_ARGS__; }
#define SET_DERIVED_PARAMS(...) virtual DerivedParamVec getDerivedParams() const override{ return __VA_ARGS__; }

//----------------------------------------------------------------------------
// Snippet::ValueBase
//----------------------------------------------------------------------------
namespace Snippet
{
template<size_t NumVars>
class ValueBase
{
public:
    // **NOTE** other less terrifying forms of constructor won't complain at compile time about
    // number of parameters e.g. std::array<double, 4> can be initialized with <= 4 elements
    template<typename... T>
    ValueBase(T&&... vals) : m_Values(std::vector<double>{{std::forward<const double>(vals)...}})
    {
        static_assert(sizeof...(vals) == NumVars, "Wrong number of values");
    }

    //----------------------------------------------------------------------------
    // Public API
    //----------------------------------------------------------------------------
    const std::vector<double> &getValues() const
    {
        return m_Values;
    }

    //----------------------------------------------------------------------------
    // Operators
    //----------------------------------------------------------------------------
    double operator[](size_t pos) const
    {
        return m_Values[pos];
    }

private:
    //----------------------------------------------------------------------------
    // Members
    //----------------------------------------------------------------------------
    std::vector<double> m_Values;
};

//----------------------------------------------------------------------------
// NewModels::ValueBase<0>
//----------------------------------------------------------------------------
template<>
class ValueBase<0>
{
public:
    // **NOTE** other less terrifying forms of constructor won't complain at compile time about
    // number of parameters e.g. std::array<double, 4> can be initialized with <= 4 elements
    template<typename... T>
    ValueBase(T&&... vals)
    {
        static_assert(sizeof...(vals) == 0, "Wrong number of values");
    }

    //----------------------------------------------------------------------------
    // Public API
    //----------------------------------------------------------------------------
    std::vector<double> getValues() const
    {
        return {};
    }
};

//----------------------------------------------------------------------------
// Snippet::Base
//----------------------------------------------------------------------------
class Base
{
public:
    virtual ~Base()
    {
    }
    
    //----------------------------------------------------------------------------
    // Typedefines
    //----------------------------------------------------------------------------
    typedef std::function<double(const std::vector<double> &, double)> DerivedParamFunc;
    typedef std::vector<std::string> StringVec;
    typedef std::vector<std::pair<std::string, std::string>> StringPairVec;
    typedef std::vector<std::pair<std::string, std::pair<std::string, double>>> NameTypeValVec;
    typedef std::vector<std::pair<std::string, DerivedParamFunc>> DerivedParamVec;

    //----------------------------------------------------------------------------
    // Declared virtuals
    //----------------------------------------------------------------------------
    virtual StringVec getParamNames() const{ return {}; }

    virtual DerivedParamVec getDerivedParams() const{ return {}; }
};

//----------------------------------------------------------------------------
// Snippet::Init
//----------------------------------------------------------------------------
template<typename SnippetBase>
class Init
{
public:
    Init(const SnippetBase *snippet, const std::vector<double> &params)
        : m_Snippet(snippet), m_Params(params)
    {
    }

    //----------------------------------------------------------------------------
    // Public API
    //----------------------------------------------------------------------------
    const SnippetBase *getSnippet() const{ return m_Snippet; }
    const std::vector<double> &getParams() const{ return m_Params; }
    const std::vector<double> &getDerivedParams() const{ return m_DerivedParams; }

    void initDerivedParams(double dt)
    {
        auto derivedParams = m_Snippet->getDerivedParams();

        // Reserve vector to hold derived parameters
        m_DerivedParams.reserve(derivedParams.size());

        // Loop through derived parameters
        for(const auto &d : derivedParams) {
            m_DerivedParams.push_back(d.second(m_Params, dt));
        }
    }

private:
    //----------------------------------------------------------------------------
    // Members
    //----------------------------------------------------------------------------
    const SnippetBase *m_Snippet;
    std::vector<double> m_Params;
    std::vector<double> m_DerivedParams;
};
}   // namespace Snippet