Parameter.h

Go to the documentation of this file.

#ifndef FACE_CONTOUR_DETECTOR_FILTERS_PARAMETER_H_
#define FACE_CONTOUR_DETECTOR_FILTERS_PARAMETER_H_

#include <vector>
#include <string>
#include <cassert>
#include <sstream>

#include <iostream>

namespace face_contour_detector {
        namespace filters {
                enum ParameterType {
                        TBOOL, 
                        TINT, 
                        TDOUBLE, 
                        TSTRING 
                };
                class Parameter {
                public:
                        Parameter(const std::string& name, bool* ptr) : m_name(name), m_type(TBOOL), m_valuePtrB(ptr), m_valuePtrI(0), m_valuePtrD(0), m_valuePtrS(0) {}
                        Parameter(const std::string& name, int* ptr) : m_name(name), m_type(TINT), m_valuePtrB(0), m_valuePtrI(ptr), m_valuePtrD(0), m_valuePtrS(0) {}
                        Parameter(const std::string& name, int* ptr, int rulerMinimum, int rulerMaximum) : m_name(name), m_type(TINT), m_valuePtrB(0), m_valuePtrI(ptr), m_valuePtrD(0), m_valuePtrS(0) {
                                std::stringstream minS;
                                minS<<rulerMinimum;
                                m_rulerMinimum = minS.str();
                                std::stringstream maxS;
                                maxS<<rulerMaximum;
                                m_rulerMaximum = maxS.str();
                        }
                        Parameter(const std::string& name, double* ptr) : m_name(name), m_type(TDOUBLE), m_valuePtrB(0), m_valuePtrI(0), m_valuePtrD(ptr), m_valuePtrS(0) {
                        }
                        Parameter(const std::string& name, double* ptr, double rulerMinimum, double rulerMaximum) : m_name(name), m_type(TDOUBLE), m_valuePtrB(0), m_valuePtrI(0), m_valuePtrD(ptr), m_valuePtrS(0) {
                                std::stringstream minS;
                                minS<<rulerMinimum;
                                m_rulerMinimum = minS.str();
                                std::stringstream maxS;
                                maxS<<rulerMaximum;
                                m_rulerMaximum = maxS.str();
                        }
                        Parameter(const std::string& name, std::string* ptr) : m_name(name), m_type(TSTRING), m_valuePtrB(0), m_valuePtrI(0), m_valuePtrD(0), m_valuePtrS(ptr) {}
                        Parameter(const Parameter& other) :  m_name(other.m_name), m_type(other.m_type), m_rulerMinimum(other.m_rulerMinimum), m_rulerMaximum(other.m_rulerMaximum), m_valuePtrB(other.m_valuePtrB), m_valuePtrI(other.m_valuePtrI), m_valuePtrD(other.m_valuePtrD), m_valuePtrS(other.m_valuePtrS) {}

                        const std::string& GetName() const { return m_name; }
                        ParameterType GetType() const { return m_type; }

                        bool* GetBoolValuePtr() const { assert(m_valuePtrB != 0); return m_valuePtrB; }
                        int* GetIntValuePtr() const { assert(m_valuePtrI != 0); return m_valuePtrI; }
                        double* GetDoubleValuePtr() const { assert(m_valuePtrD != 0); return m_valuePtrD; }
                        std::string* GetStringValuePtr() const { assert(m_valuePtrS != 0); return m_valuePtrS; }
                        std::string GetRulerMinimum() { return m_rulerMinimum; }
                        std::string GetRulerMaximum() { return m_rulerMaximum; }

                private:
                        std::string m_name;
                        ParameterType m_type;

                        std::string m_rulerMinimum;
                        std::string m_rulerMaximum;

                        //NOTE: this could be just a single pointer that could be changed with casting, could be optimized later
                        bool* m_valuePtrB;
                        int* m_valuePtrI;
                        double* m_valuePtrD;
                        std::string* m_valuePtrS;
                };
        }
}
#endif /* FACE_CONTOUR_DETECTOR_FILTERS_PARAMETER_H_ */