weightedvalue.h

Go to the documentation of this file.

/* === S Y N F I G ========================================================= */
/* ========================================================================= */

/* === S T A R T =========================================================== */

#ifndef __SYNFIG_WEIGHTEDVALUE_H
#define __SYNFIG_WEIGHTEDVALUE_H

/* === H E A D E R S ======================================================= */

#include "real.h"
#include "type.h"
#include "value.h"

/* === M A C R O S ========================================================= */

/* === T Y P E D E F S ===================================================== */

/* === C L A S S E S & S T R U C T S ======================================= */

namespace synfig {

template<typename T>
class WeightedValue
{
public:
    typedef T ValueType;
    Real weight;
    ValueType value;
    WeightedValue(): weight(), value() { }
    explicit WeightedValue(Real weight): weight(weight), value() { }
    explicit WeightedValue(Real weight, const ValueType &value): weight(weight), value(value) { }
};

namespace types_namespace {
    class TypeWeightedValueBase: public Type
    {
    public:
        virtual Type& get_contained_type() = 0;
        virtual ValueBase create_weighted_value(Real weight, const ValueBase &value) = 0;
        virtual Real extract_weight(const ValueBase &value) = 0;
        virtual ValueBase extract_value(const ValueBase &value) = 0;
    };

    template<typename T>
    class TypeWeightedValue: public TypeWeightedValueBase
    {
        static String to_string(const WeightedValue<T> &x) {
            return etl::strprintf("Weight (%f) %s", x.weight, value_to_string(x.value).c_str());
        }
        void initialize_vfunc(Description &description)
        {
            Type &type = get_type_alias(T()).type;
            type.initialize();

            Type::initialize_vfunc(description);
            description.name = "weighted_" + type.description.name;
            description.local_name = N_("weighted") + String(" ") + type.description.local_name;
            register_all_but_compare<WeightedValue<T>, TypeWeightedValue<T>::to_string>();
        }
        Type& get_contained_type() { return get_type_alias(T()).type; }
        ValueBase create_weighted_value(Real weight, const ValueBase &value)
            { return WeightedValue<T>(weight, value.get(T())); };
        Real extract_weight(const ValueBase &value)
            { return value.get(WeightedValue<T>()).weight; };
        ValueBase extract_value(const ValueBase &value)
            { return value.get(WeightedValue<T>()).value; };
    public:
        static TypeWeightedValue instance;
    };

    template<typename T>
    TypeWeightedValue<T> TypeWeightedValue<T>::instance;

    template<typename T>
    TypeAlias< WeightedValue<T> > get_type_alias(WeightedValue<T> const&) { return TypeAlias< WeightedValue<T> >(TypeWeightedValue<T>::instance); }
}


}; // END of namespace synfig

#endif