SegmentationParameter.h

Go to the documentation of this file.

/*
 * SegmentationParameter.h
 *
 * Helper class to hold a segmentation parameter with its description.
 *
 *  Created on: Dec 16, 2013
 *      Author: Christian Grefe, CERN
 */

#ifndef DDSegmentation_SEGMENTATIONPARAMETER_H_
#define DDSegmentation_SEGMENTATIONPARAMETER_H_

#include <sstream>
#include <string>
#include <typeinfo>
#include <vector>

namespace DD4hep {
namespace DDSegmentation {


inline std::vector<std::string> splitString(const std::string& s, char delimiter = ' ') {
        std::vector<std::string> elements;
        std::stringstream ss(s);
        std::string item;
        while (std::getline(ss, item, delimiter)) {
                elements.push_back(item);
        }
        return elements;
}

template<typename TYPE> struct TypeName {
        static const char* name() {
                return typeid(TYPE).name();
        }
};

template<> struct TypeName<int> {
        static const char* name() {
                return "int";
        }
};

template<> struct TypeName<float> {
        static const char* name() {
                return "float";
        }
};

template<> struct TypeName<double> {
        static const char* name() {
                return "double";
        }
};

template<> struct TypeName<std::string> {
        static const char* name() {
                return "string";
        }
};

template<> struct TypeName<std::vector<int> > {
        static const char* name() {
                return "intvec";
        }
};

template<> struct TypeName<std::vector<float> > {
        static const char* name() {
                return "floatvec";
        }
};

template<> struct TypeName<std::vector<double> > {
        static const char* name() {
                return "doublevec";
        }
};

template<> struct TypeName<std::vector<std::string> > {
        static const char* name() {
                return "stringvec";
        }
};

class SegmentationParameter {
public:
        enum UnitType {
                NoUnit, LengthUnit, AngleUnit
        };
        virtual ~SegmentationParameter() {
        }
        const std::string& name() const {
                return _name;
        }
        const std::string& description() const {
                return _description;
        }
        UnitType unitType() const {
                return _unitType;
        }
        virtual std::string type() const = 0;
        virtual std::string value() const = 0;
        virtual void setValue(const std::string& value) = 0;
        virtual std::string defaultValue() const = 0;
        bool isOptional() const {
                return _isOptional;
        }
        std::string toString() const {
                std::stringstream s;
                s << _name << " = " << value();
                if (not _description.empty()) {
                        s << " (" << _description << ")";
                }
                return s.str();
        }
protected:
        SegmentationParameter(const std::string& nam, const std::string& desc, UnitType unitTyp = NoUnit,
                        bool isOpt = false) :
                        _name(nam), _description(desc), _unitType(unitTyp), _isOptional(isOpt) {
        }
        std::string _name;
        std::string _description;
        UnitType _unitType;
        bool _isOptional;
};

template<typename TYPE> class TypedSegmentationParameter: public SegmentationParameter {
public:
        TypedSegmentationParameter(const std::string& nam, const std::string& desc, TYPE& val,
                        const TYPE& default_Value, SegmentationParameter::UnitType unitTyp = SegmentationParameter::NoUnit,
                        bool isOpt = false) :
                        SegmentationParameter(nam, desc, unitTyp, isOpt), _value(val), _defaultValue(default_Value) {
                _value = default_Value;
        }

        const TYPE& typedValue() const {
                return _value;
        }

        void setTypedValue(const TYPE& val) {
                _value = val;
        }

        const TYPE& typedDefaultValue() const {
                return _defaultValue;
        }

        std::string type() const {
                return TypeName<TYPE>::name();
        }

        std::string value() const {
                std::stringstream s;
                s << _value;
                return s.str();
        }

        void setValue(const std::string& val) {
                std::stringstream s;
                s << val;
                s >> _value;
        }

        std::string defaultValue() const {
                std::stringstream s;
                s << _defaultValue;
                return s.str();
        }

protected:
        TYPE& _value;
        TYPE _defaultValue;
};

template<typename TYPE> class TypedSegmentationParameter<std::vector<TYPE> > : public SegmentationParameter {
public:
        TypedSegmentationParameter(const std::string& nam, const std::string& desc, std::vector<TYPE>& val,
                        const std::vector<TYPE>& defaultVal, SegmentationParameter::UnitType unitTyp =
                                        SegmentationParameter::NoUnit, bool isOpt = false) :
                        SegmentationParameter(nam, desc, unitTyp, isOpt), _value(val), _defaultValue(defaultVal) {
                _value = defaultVal;
        }

        const std::vector<TYPE>& typedValue() const {
                return _value;
        }

        void setTypedValue(const std::vector<TYPE>& val) {
                _value = val;
        }

        const std::vector<TYPE>& typedDefaultValue() const {
                return _defaultValue;
        }

        std::string type() const {
                std::stringstream s;
                s << TypeName<TYPE>::name() << "vec";
                return s.str() ;
        }

        std::string value() const {
                std::stringstream s;
                typename std::vector<TYPE>::const_iterator it = _value.begin();
                for (; it != _value.end(); ++it) {
                        s << *it;
                        s << " ";
                }
                return s.str();
        }

        void setValue(const std::string& val) {
                std::vector<std::string> elements = splitString(val);
                _value.clear();
                for (std::vector<std::string>::const_iterator it = elements.begin(); it != elements.end(); ++it) {
                        if (not it->empty()) {
                                TYPE entry;
                                std::stringstream s;
                                s << *it;
                                s >> entry;
                                _value.push_back(entry);
                        }
                }
        }

        std::string defaultValue() const {
                std::stringstream s;
                typename std::vector<TYPE>::const_iterator it = _defaultValue.begin();
                for (; it != _defaultValue.end(); ++it) {
                        s << *it;
                        s << " ";
                }
                return s.str();
        }

protected:
        std::vector<TYPE>& _value;
        std::vector<TYPE> _defaultValue;

};

} /* namespace DDSegmentation */
} /* namespace DD4hep */
#endif /* DDSegmentation_SEGMENTATIONPARAMETER_H_ */