Interval.h

#ifndef OpenTestSystem_Otx_Runtime_Api_DataTypes_Interval_H
#define OpenTestSystem_Otx_Runtime_Api_DataTypes_Interval_H
 
#include "Object.h"
 
#include <memory>
 
namespace OpenTestSystem { namespace Otx { namespace Runtime { namespace Api { namespace DataTypes {
    class Quantity;
}}}}}
 
namespace OpenTestSystem { namespace  Otx { namespace Runtime { namespace Api {
    namespace DataTypes {
        enum class IntervalSemantics
        {
            None,
 
            Success,
 
            Info,
 
            Warning,
 
            Error
        };
 
        class API_EXPORTS Interval : public Object
        {
        public:
            IntervalSemantics GetSemantic() const;
 
            std::string GetLabel() const;
 
            std::string GetSemanticAsString() const;
        protected:
            IntervalSemantics _semantic;
            std::string _label;
        };
 
        class API_EXPORTS NumericInterval : public Interval
        {
        };
 
        class API_EXPORTS FloatInterval : public NumericInterval
        {
        public:
            FloatInterval();
 
            FloatInterval(
                double lowerLimit);
 
            FloatInterval(
                double lowerLimit,
                double upperLimit,
                IntervalSemantics semantic = IntervalSemantics::None,
                const std::string& label = "");
 
            virtual ~FloatInterval();
 
            double GetLowerLimit() const;
 
            double GetUpperLimit() const;
 
            std::string ToLiteralString() const override;
 
            bool IsInsideInterval(double value);
        private:
            double _lowerLimit;
            double _upperLimit;
        };
 
        class API_EXPORTS IntegerInterval : public NumericInterval
        {
        public:
            IntegerInterval();
 
            IntegerInterval(
                long long lowerLimit);
 
            IntegerInterval(
                long long lowerLimit,
                long long upperLimit,
                IntervalSemantics semantic = IntervalSemantics::None,
                const std::string& label = "");
 
            virtual ~IntegerInterval();
 
            long long GetLowerLimit() const;
 
            long long GetUpperLimit() const;
 
            std::string ToLiteralString() const override;
 
            bool IsInsideInterval(long long value);
        private:
            long long _lowerLimit;
            long long _upperLimit;
        };
 
        class API_EXPORTS QuantityInterval : public NumericInterval
        {
        public:
            QuantityInterval();
 
            QuantityInterval(
                std::shared_ptr<Quantity> lowerLimit);
 
            QuantityInterval(
                std::shared_ptr<Quantity> lowerLimit,
                std::shared_ptr<Quantity> upperLimit,
                IntervalSemantics semantic = IntervalSemantics::None,
                const std::string& label = "");
 
            virtual ~QuantityInterval();
 
            std::shared_ptr<Quantity> GetLowerLimit() const;
 
            std::shared_ptr<Quantity> GetUpperLimit() const;
 
            std::string ToLiteralString() const override;
 
            bool IsInsideInterval(std::shared_ptr<Quantity> value);
        private:
            std::shared_ptr<Quantity> _lowerLimit;
            std::shared_ptr<Quantity> _upperLimit;
        };
 
        class API_EXPORTS StringInterval : public Interval
        {
        public:
            StringInterval();
 
            StringInterval(
                const std::string& regExp,
                IntervalSemantics semantic = IntervalSemantics::None,
                const std::string& label = "");
 
            virtual ~StringInterval();
 
            std::string GetRegExp() const;
 
            std::string ToLiteralString() const override;
 
            bool IsInsideInterval(const std::string& value);
        private:
            std::string _regExp;
        };
    }
}}}}
 
#endif//OpenTestSystem_Otx_Runtime_Api_DataTypes_Interval_H