config.h

Go to the documentation of this file.

#ifndef CONFIG_H
#define CONFIG_H

#include <map>
#include <string>
#include <tr1/cstdint>

#include "base_exception.h"
#include "conversions.h"

class Config {
        public:
                class InvalidValueError: public BaseException {
                        public:
                                explicit InvalidValueError(const std::string &errorMessage):
                                        BaseException(errorMessage) {}
                };

                typedef std::map<std::string, std::string> RawConfigValues;

                typedef size_t BufferSize;

                typedef unsigned LengthField;

                typedef std::tr1::uint32_t LengthFieldMessageLength;

        public:
                static Config fromRawConfigValues(RawConfigValues rawConfigValues);

                ~Config();

                Config(const Config &other);

                Config & operator=(const Config &other);

                bool operator==(const Config &other) const;

                bool operator!=(const Config &other) const;

                void swap(Config &other);

                size_t getBufferSize() const { return _bufferSize; }

                LengthField getLengthField() const { return _lengthField; }

                static LengthFieldMessageLength binaryFieldLengthToNumber(const std::string &binaryNumber);

                static LengthFieldMessageLength computeMaximalMessageLength(unsigned lengthField);

                static std::string messageLengthToBinaryLengthField(LengthFieldMessageLength messageLength,
                        unsigned lengthField);

        protected:
                Config();

                Config(RawConfigValues rawConfigValues);

        protected:

                template <typename T>
                static T parseNumber(const std::string &optionName,
                                const std::string &rawValue, T minValue, T maxValue) {
                        T value = 0;

                        // Check whether the rawValue is a valid unsigned value
                        // (I can use the trick toString(value) != rawValues because of
                        // the precondition of the fromRawConfigValues() function)
                        if (!strToNum(rawValue, value) || toString(value) != rawValue) {
                                throw InvalidValueError(std::string("TCP/IP configuration parsing error: invalid ") +
                                        optionName + " (" + rawValue + ")");
                        }

                        // Check bounds
                        if (value < minValue || value > maxValue) {
                                throw InvalidValueError(std::string("TCP/IP configuration parsing error: invalid ") +
                                        optionName + " (" + rawValue + ") - " + optionName + " must be between " +
                                        toString(minValue) + " and " + toString(maxValue));
                        }

                        return value;
                }

        private:
                // All parsig functions have the same behaviour - they parses the
                // selected value and returns it. They throw InvalidValueError if the
                // value is invalid.
                static BufferSize parseBufferSize(const std::string &rawBufferSize);
                static LengthField parseLengthField(const std::string &rawLengthField);

        private:
                BufferSize _bufferSize;
                LengthField _lengthField;

                static const BufferSize DEFAULT_BUFFER_SIZE;
                static const LengthField DEFAULT_LENGTH_FIELD;
};

#endif // #ifndef CONFIG_H

// End of file config.h