lib/parameters.h

#ifndef __PARAMETERS_H__
#define __PARAMETERS_H__

#include <set>
#include <map>
#include <list>
#include <string>
#include <utility>
#include <stdint.h>
#include <math.h>

#include "stm_export.h"

namespace spectral
{

enum
{
    PARAM_TYPE_NONE = 0,        // Invalid.
    PARAM_TYPE_BOOL,            // Boolean
    PARAM_TYPE_INT,             // signed integer
    PARAM_TYPE_FLOAT,           // IEEE float
    PARAM_TYPE_ENUM,            // Enumerated type.
    PARAM_TYPE_CHROMATICITY     // An xy pair.
};

// Data types

// Simple xy float class.  Could use std::pair<>, but this is a bit less opaque.
class Chromaticity
{
public:
    Chromaticity()
        : m_x(0)
        , m_y(0)
    {
    } 
    Chromaticity(float x, float y) 
        : m_x(x), m_y(y)
    {}

    Chromaticity(const Chromaticity &other)
    {
        other.GetXY(m_x, m_y);
    }

    Chromaticity &operator=(const Chromaticity &other)
    {
        other.GetXY(m_x, m_y);
        return *this;
    }
    void GetXY(float &x, float &y) const
    {
        x = m_x;
        y = m_y;
    }
private:
    float m_x, m_y;
};

// Internal parameter references.
class FloatParameter
{
public:
    FloatParameter()
        : m_value(0)
        , m_min(0)
        , m_max(0)
    {
    }
    FloatParameter(float min, float max, float value)
        : m_value(value)
        , m_min((min<max)?min:max)
        , m_max((min>max)?min:max)
    {
    }
    void GetValue(float &) const;
    void GetRange(float &, float &) const;
    bool SetValue(float value);

private:
    float m_value, m_min, m_max;
};

class IntParameter
{
public:
    IntParameter()
        : m_value(0)
        , m_min(0)
        , m_max(0)
    {
    }
    IntParameter(int32_t min, int32_t max, int32_t value)
        : m_value(value)
        , m_min((min<max)?min:max)
        , m_max((min>max)?min:max)
    {
    }
    void GetValue(int32_t &) const;
    void GetRange(int32_t &, int32_t &) const;
    bool SetValue(int32_t value);

private:
    int32_t m_value, m_min, m_max;
};

class EnumParameter
{
public:
    EnumParameter();
    EnumParameter(const EnumParameter &other);
    EnumParameter(const std::list<std::pair<uint32_t, std::string> > &,
                  uint32_t);

    void GetRange(std::list<std::pair<uint32_t, std::string> > &) const;
    void GetValue(uint32_t &, std::string &) const;
    bool SetValue(uint32_t value);

private:
    void SetRange(const std::list<std::pair<uint32_t, std::string> > &);
    uint32_t m_value;
    std::map<uint32_t, std::string> m_range;
};

// Parameter interface.
class STM_EXPORT Parameters
{
public:
    Parameters();
    ~Parameters();

    // General status.
    void SetDirty(void) { m_dirty = true; }
    void SetClean(void) { m_dirty = false; }
    bool IsDirty(void) const { return m_dirty; }

    uint32_t GetParameterType(std::string name) const;
    void GetParameterNames(std::list<std::string> &names) const;

    // Boolean parameters.
    bool AddParameter(std::string name, bool value);
    bool SetParameter(std::string name, bool value);
    bool GetParameter(std::string name, bool &value) const;

    // Floating point parameters.
    bool AddParameter(std::string name, float min, float max, float value);
    bool SetParameter(std::string name, float value);
    bool GetParameter(std::string name, float &value) const;
    bool GetRange(std::string name, float &min, float &max) const;

    // Integer parameters.
    bool AddParameter(std::string name, int32_t min, int32_t max, 
                      int32_t value);
    bool SetParameter(std::string name, int32_t value);
    bool GetParameter(std::string name, int32_t &value) const;
    bool GetRange(std::string name, int32_t &min, int32_t &max) const;

    // Enum parameters.
    bool AddParameter(std::string name, 
                      const std::list<std::pair<uint32_t, std::string> > &,
                      uint32_t value);
    bool SetParameter(std::string name, uint32_t);
    bool GetParameter(std::string name, uint32_t &, std::string &) const;
    bool GetRange(std::string name, 
                  std::list<std::pair<uint32_t, std::string> > &) const;

    // White point parameters.
    bool AddParameter(std::string name, Chromaticity value);
    bool SetParameter(std::string name, Chromaticity value);
    bool GetParameter(std::string name, Chromaticity &value) const;

private:   
    std::list<std::string> m_names;
    std::map<std::string, uint32_t>       m_allParams;
    std::map<std::string, bool>           m_boolParams;
    std::map<std::string, IntParameter>   m_intParams;
    std::map<std::string, FloatParameter> m_floatParams;
    std::map<std::string, EnumParameter>  m_enumParams;
    std::map<std::string, Chromaticity>   m_chromaParams;
    
    bool m_dirty;
};

}

#endif

---