ScalarField.h

Go to the documentation of this file.

#ifndef SCALARFIELD_H_
#define SCALARFIELD_H_

#include <typeinfo>

#include "Field.h"

template<typename T, bool is_scalar >
class ScalarFieldImpl : public Field
    {}
;

template<typename T>
class ScalarFieldImpl<T, true> : public Field
{

public:
    static ValueType Type;

    ScalarFieldImpl<T, true>()
    {}
    ;

    ScalarFieldImpl<T, true>(
        const string & name,
        const string & description,
        const int & offset,
        const string & units = "unspecific",
        const Field::AccessType & access = Field::readwrite,
        const double & lb = std::numeric_limits<double>::quiet_NaN(),
        const double & ub = std::numeric_limits<double>::quiet_NaN()
    )
    {
        this->name = name;
        this->description = description;
        this->units = units;
        this->access = access;
        this->lb = lb;
        this->ub = ub;
        this->offset = offset;
        this->size = sizeof(T);
        initValueType();
        Field::type = ScalarFieldImpl<T,true>::Type;
    };

    virtual ~ScalarFieldImpl<T, true>()
    {}
    ;

    virtual ScalarFieldImpl<T, true> *clone(void) const
    {
        return new ScalarFieldImpl<T, true>( *this );
    };

    virtual double getValue( SimObject *o ) const
    {
        return (double)( *( (T *)( ((char *)o)+offset ) ) );
    };

    virtual void setValue( SimObject *o, double v ) const
    {
        *( (T *)( ((char *)o)+offset ) ) = (T)(v);
    };


    static void initValueType()
    {
        if (typeid(double) == typeid(T))
            Type = Field::double_t;
        else if (typeid(float) == typeid(T))
            Type = Field::float_t;
        else if (typeid(int) == typeid(T))
            Type = Field::int_t;       
    };
    
};

template<typename T>
Field::ValueType ScalarFieldImpl<T, true>::Type = Field::unknown_t;


template<typename T>
class ScalarFieldImpl<T, false> : public Field
{
public:

    ScalarFieldImpl<T, false >(
        const string & name,
        const string & description,
        const int & offset,
        const string & units = "unspecific",
        const Field::AccessType & access = Field::readwrite,
        const double & lb = std::numeric_limits<double>::quiet_NaN(),
        const double & ub = std::numeric_limits<double>::quiet_NaN()
    )
    {}
    ;

    virtual ~ScalarFieldImpl<T, false>()
    {}
    ;

    virtual ScalarFieldImpl<T, false> *clone(void) const
    {
        return new ScalarFieldImpl<T, false>( *this );
    };

    virtual double getValue( SimObject *o ) const
    {
        return std::numeric_limits<double>::quiet_NaN();
    };

    virtual void setValue( SimObject *o, double v ) const
    {
        /* NOOP */
    };

    virtual Field::ValueType valueType()
    {
        return Field::unknown_t;
    }

};

template<typename T>
class ScalarField : public ScalarFieldImpl< T, std::numeric_limits<T>::is_specialized >
{
public:
    ScalarField(
        const string & name,
        const string & description,
        const int & offset,
        const string & units = "unspecific",
        const Field::AccessType & access = Field::readwrite,
        const double & lb = std::numeric_limits<double>::quiet_NaN(),
        const double & ub = std::numeric_limits<double>::quiet_NaN()
    ) : ScalarFieldImpl< T, std::numeric_limits<T>::is_specialized >( name, description, offset, units, access, lb, ub )
    {}
    ;
};

#endif /*SCALARFIELD_H_*/

---