BasicVariable.h

Go to the documentation of this file.

/*
 * clockUtils
 * Copyright (2015) Michael Baer, Daniel Bonrath, All rights reserved.
 *
 * This file is part of clockUtils; clockUtils is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef __CLOCKUTILS_ARGPARSER_BASICVARIABLE_H__
#define __CLOCKUTILS_ARGPARSER_BASICVARIABLE_H__

#include "clockUtils/argParser/argParserParameters.h"

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

namespace clockUtils {
namespace argParser {

        class Parser;

        class CLOCK_ARGPARSER_API BasicVariable {
                friend class Parser;

        public:
                BasicVariable(const std::string & longname, const std::string & shortname, const std::string & description, bool required, bool multiple);

                virtual ~BasicVariable();

                inline std::string getLongname() const {
                        return _longname;
                }

                inline std::string getShortname() const {
                        return _shortname;
                }

                virtual bool isBool() const = 0;

                virtual bool setValue(const std::string & value) = 0;

                bool isSet() const {
                        return _set;
                }

                bool isRequired() const {
                        return _required;
                }

                bool canHaveMultiple() const {
                        return _multiple;
                }

                virtual void resetToDefault() = 0;

        protected:
                bool _set;

        private:
                std::string _longname;

                std::string _shortname;

                std::string _description;
                
                bool _required;
                
                bool _multiple;
        };

        template<typename T>
        class Variable : public BasicVariable {
        public:
                Variable(const std::string & longname, const std::string & shortname, const std::string & description, T value, bool required, bool multiple) : BasicVariable(longname, shortname, description, required, multiple), _value(value), _values(), _defaultValue(value) {
                }

                bool isBool() const override {
                        return std::is_same<T, bool>::value;
                }

                bool setValue(const std::string & value) override {
                        std::stringstream ss(value);
                        T val;
                        bool ret = !(ss >> (val)).fail() && ss.eof();
                        if (!_set) {
                                _value = val;
                        } else {
                                _values.push_back(val);
                        }
                        return ret;
                }

                friend bool operator==(const T & first, const Variable<T> & second) {
                        return first == second._value;
                }

                friend bool operator==(const Variable<T> & first, const T & second) {
                        return first._value == second;
                }

                friend bool operator!=(const T & first, const Variable<T> & second) {
                        return first != second._value;
                }

                friend bool operator!=(const Variable<T> & first, const T & second) {
                        return first._value != second;
                }

                T & operator=(const T & val) {
                        _value = val;
                        return _value;
                }

                operator T() const {
                        return _value;
                }

                friend std::ostream & operator<<(std::ostream & out, Variable & v) {
                        out << v._value;
                        return out;
                }

                size_t count() const {
                        return 1 + _values.size();
                }

                T at(size_t idx) const {
                        return (idx == 0) ? _value : _values[idx - 1];
                }

        private:
                T _value;

                std::vector<T> _values;

                T _defaultValue;

                void resetToDefault() override {
                        _value = _defaultValue;
                        _values.clear();
                        _set = false;
                }
        };

        template<>
        bool CLOCK_ARGPARSER_API Variable<std::string>::setValue(const std::string & value);

        template<>
        bool CLOCK_ARGPARSER_API Variable<char>::setValue(const std::string & value);

        template<>
        bool CLOCK_ARGPARSER_API Variable<bool>::setValue(const std::string & value);

} /* namespace argParser */
} /* namespace clockUtils */

#endif /* __CLOCKUTILS_ARGPARSER_BASICVARIABLE_H__ */