Numeric.h

Go to the documentation of this file.

/*
 * This file is part of KnowRob, please consult
 * https://github.com/knowrob/knowrob for license details.
 */
 
#ifndef KNOWROB_NUMERIC_TERM_H
#define KNOWROB_NUMERIC_TERM_H
 
#include "XSDAtomic.h"
#include "sstream"
#include "optional"
#include "string"
 
namespace knowrob {
    class Numeric : public XSDAtomic {
    public:
        explicit Numeric(XSDType xsdType) : XSDAtomic(xsdType) {}
 
        ~Numeric() override = default;
 
        virtual bool isSameNumeric(const Numeric &other) const = 0;
 
        virtual double asDouble() const = 0;
 
        virtual float asFloat() const = 0;
 
        virtual int asInteger() const = 0;
 
        virtual long asLong() const = 0;
 
        virtual short asShort() const = 0;
 
        virtual unsigned int asUnsignedInteger() const = 0;
 
        virtual unsigned long asUnsignedLong() const = 0;
 
        virtual unsigned short asUnsignedShort() const = 0;
 
        virtual bool asBoolean() const = 0;
 
        static std::shared_ptr<Numeric> trueAtom();
 
        static std::shared_ptr<Numeric> falseAtom();
 
        bool isFloatingNumber() const;
    };
 
    template<typename T1, XSDType T2>
    class NumericTemplate : public Numeric {
    public:
        explicit NumericTemplate(T1 numericForm) : Numeric(T2), numericForm_(numericForm) {}
 
        explicit NumericTemplate(std::string_view stringForm) : Numeric(T2), stringForm_(stringForm) {}
 
        ~NumericTemplate() override = default;
 
        T1 operator()() const { return numericForm(); }
 
        T1 numericForm() const {
            if (!numericForm_) {
                std::istringstream iss(*stringForm_);
                auto &value = numericForm_.emplace();
                iss >> std::fixed >> value;
                return value;
            } else {
                return numericForm_.value();
            }
        }
 
        // override Numeric
        double asDouble() const override { return static_cast<double>(numericForm()); }
 
        // override Numeric
        float asFloat() const override { return static_cast<float>(numericForm()); }
 
        // override Numeric
        int asInteger() const override { return static_cast<int>(numericForm()); }
 
        // override Numeric
        long asLong() const override { return static_cast<long>(numericForm()); }
 
        // override Numeric
        short asShort() const override { return static_cast<short>(numericForm()); }
 
        // override Numeric
        unsigned int asUnsignedInteger() const override { return static_cast<unsigned int>(numericForm()); }
 
        // override Numeric
        unsigned long asUnsignedLong() const override { return static_cast<unsigned long>(numericForm()); }
 
        // override Numeric
        unsigned short asUnsignedShort() const override { return static_cast<unsigned short>(numericForm()); }
 
        // override Numeric
        bool asBoolean() const override { return static_cast<bool>(numericForm()); }
 
        // override Atomic
        std::string_view stringForm() const override {
            if (!stringForm_) {
                std::ostringstream oss;
                oss << std::fixed << std::boolalpha << *numericForm_;
                stringForm_ = oss.str();
            }
            return *stringForm_;
        }
 
        // override Numeric
        bool isSameNumeric(const Numeric &other) const override {
            if (xsdType() != other.xsdType()) {
                return false;
            }
            const auto otherNumeric = static_cast<const NumericTemplate<T1, T2> *>(&other);
            return numericForm() == otherNumeric->numericForm();
        }
 
        // override Printable
        void write(std::ostream &os) const override { os << std::defaultfloat << std::boolalpha << numericForm(); }
 
    private:
        // Note: both are mutable because they are initialized in a lazy fashion
        mutable std::optional<std::string> stringForm_;
        mutable std::optional<T1> numericForm_;
    };
 
    using Integer = NumericTemplate<int, XSDType::INTEGER>;
 
    using Long = NumericTemplate<long, XSDType::LONG>;
 
    using Short = NumericTemplate<short, XSDType::SHORT>;
 
    using UnsignedLong = NumericTemplate<unsigned long, XSDType::UNSIGNED_LONG>;
 
    using UnsignedInt = NumericTemplate<unsigned int, XSDType::UNSIGNED_INT>;
 
    using UnsignedShort = NumericTemplate<unsigned short, XSDType::UNSIGNED_SHORT>;
 
    using Float = NumericTemplate<float, XSDType::FLOAT>;
 
    using Double = NumericTemplate<double, XSDType::DOUBLE>;
 
    using Boolean = NumericTemplate<bool, XSDType::BOOLEAN>;
 
} // knowrob
 
#endif //KNOWROB_NUMERIC_TERM_H