Normalize function module

#include "appdevel/normalizeModuleMacros.hpp"
#include "appdevel/moduleFrameMacros.hpp"

class MyNormalizeFunction
        :public _Wolframe::types::NormalizeFunction
{
public:
        MyNormalizeFunction( const std::vector<_Wolframe::types::Variant>& arg)
        {
                // ... the WF_NORMALIZER* template needs a constructor with this signature
        }

        virtual const char* name() const
        {
                // ... return the identifier of the function here
        }
        virtual _Wolframe::types::Variant execute( const _Wolframe::types::Variant& i) const
        {
                // ... execure this function on the input variant here
        }
        virtual _Wolframe::types::NormalizeFunction* copy() const
        {
                // ... return a copy of this here
        }
};

WF_MODULE_BEGIN( "My normalizer", "my normalizer module")
 WF_NORMALIZER( "mynormalize",  MyNormalizeFunction)
WF_MODULE_END

If your normalizer functions use common resources, you can declare them as follows:

class MyResources
        :public _Wolframe::types::NormalizeResourceHandle
{
        // ... put your common data structure (normalizer resources) decrarations here
};

The MyNormalizeFunction has a slighly different constructor signature required. The first parameter is the base resource handle reference. The consructor can use a dynamic_cast to get his resource object: :

MyNormalizeFunction::MyNormalizeFunction( _Wolframe::types::NormalizeResourceHandle* reshnd, const std::vector<_Wolframe::types::Variant>& arg)
{
        MyResources* myreshnd = dynamic_cast<MyResources*>(reshnd);
        // ... do other initializations
}

We then declare the resources and the function with the following macro after WF_MODULE_BEGIN:

WF_NORMALIZER_RESOURCE( MyResources)
WF_NORMALIZER_WITH_RESOURCE( "mynormalize",  MyNormalizeFunction, MyResources)