WSBasicTypes.h

/*
╔══════════════════════════════════════════════════════════════════════════════╗
║                       SIMPLY POWERFUL TOOLKIT (SPTK)                         ║
╟──────────────────────────────────────────────────────────────────────────────╢
║  copyright            © 1999-2022 Alexey Parshin. All rights reserved.       ║
║  email                alexeyp@gmail.com                                      ║
╚══════════════════════════════════════════════════════════════════════════════╝
┌──────────────────────────────────────────────────────────────────────────────┐
│   This library is free software; you can redistribute it and/or modify it    │
│   under the terms of the GNU Library General Public License as published by  │
│   the Free Software Foundation; either version 2 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 Library   │
│   General Public License for more details.                                   │
│                                                                              │
│   You should have received a copy of the GNU Library General Public License  │
│   along with this library; if not, write to the Free Software Foundation,    │
│   Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.               │
│                                                                              │
│   Please report all bugs and problems to alexeyp@gmail.com.                  │
└──────────────────────────────────────────────────────────────────────────────┘
*/
 
#pragma once
 
#include <sptk5/Field.h>
#include <sptk5/wsdl/WSFieldIndex.h>
#include <sptk5/wsdl/WSType.h>
#include <sptk5/xdoc/Node.h>
 
namespace sptk {
 
class SP_EXPORT WSBasicType
    : public WSType
{
public:
    WSBasicType() = default;
 
    WSBasicType(const char* name, bool optional)
        : WSType(name)
        , m_optional(optional)
    {
    }
 
    WSBasicType(const WSBasicType& other) = default;
 
    WSBasicType(WSBasicType&& other) noexcept = default;
 
    ~WSBasicType() override = default;
 
    WSBasicType& operator=(const WSBasicType& other)
    {
        m_value = other.m_value;
        m_optional = other.m_optional;
        return *this;
    }
 
    WSBasicType& operator=(WSBasicType&& other) noexcept
    {
        m_value = std::move(other.m_value);
        m_optional = other.m_optional;
        return *this;
    }
 
    bool optional() const
    {
        return m_optional;
    }
 
    void optional(bool opt)
    {
        m_optional = opt;
    }
 
    void clear() override
    {
        m_value.setNull(defaultDataType());
    }
 
    void load(const xdoc::SNode& attr, bool nullLargeData) override
    {
        if (nullLargeData && attr->getString().length() > 256)
        {
            m_value.setNull(VariantDataType::VAR_STRING);
        }
        else
        {
            m_value.load(attr);
        }
    }
 
    virtual void load(const String& attr)
    {
        m_value.setString(attr);
    }
 
    virtual void load(const Field& field)
    {
        m_value = *static_cast<const Variant*>(&field);
    }
 
    virtual operator String() const
    {
        return m_value.asString();
    }
 
    String asString() const override
    {
        return m_value.asString();
    }
 
    auto asInteger() const
    {
        return value().asInteger();
    }
 
    auto asInt64() const
    {
        return value().asInt64();
    }
 
    auto asFloat() const
    {
        return value().asFloat();
    }
 
    auto asBool() const
    {
        return m_value.asBool();
    }
 
    void setInteger(int32_t _value)
    {
        m_value.setInteger(_value);
    }
 
    void setInt64(int64_t _value)
    {
        m_value.setInt64(_value);
    }
 
    void setFloat(bool _value)
    {
        m_value.setFloat(_value);
    }
 
    void setBool(bool _value)
    {
        m_value.setBool(_value);
    }
 
    void setBuffer(const char* buffer, size_t size)
    {
        m_value.setBuffer((const uint8_t*) buffer, size);
    }
 
    bool isNull() const override
    {
        return m_value.isNull();
    }
 
    void throwIfNull(const String& parentTypeName) const;
 
    size_t dataSize() const
    {
        return m_value.dataSize();
    }
 
    VariantDataType dataType() const
    {
        return m_value.dataType();
    }
 
    void setNull()
    {
        m_value.setNull(defaultDataType());
    }
 
    Variant& value()
    {
        return m_value;
    }
 
    const Variant& value() const
    {
        return m_value;
    }
 
    void exportTo(const xdoc::SNode& parent, const char* name = nullptr) const override;
 
protected:
    void setNull(VariantDataType dataType)
    {
        m_value.setNull(dataType);
    }
 
    virtual VariantDataType defaultDataType() const
    {
        return VariantDataType::VAR_NONE;
    }
 
private:
    Variant m_value;
    bool m_optional {false}; 
};
 
class SP_EXPORT WSString
    : public WSBasicType
{
public:
    WSString()
    {
        setNull(VariantDataType::VAR_STRING);
    }
 
    WSString(const String& name, bool optional)
        : WSBasicType(name.c_str(), optional)
    {
        setNull(VariantDataType::VAR_STRING);
    }
 
    explicit WSString(const String& _value)
    {
        value().setString(_value);
    }
 
    String className() const override
    {
        return "WSString";
    }
 
    VariantDataType defaultDataType() const override
    {
        return VariantDataType::VAR_STRING;
    };
 
    void load(const xdoc::SNode& attr, bool nullLargeData) override;
 
    void load(const String& attr) override;
 
    void load(const Field& field) override;
 
    WSString& operator=(const char* _value)
    {
        value().setString(_value);
        return *this;
    }
 
    WSString& operator=(const String& _value)
    {
        value().setBuffer((const uint8_t*) _value.c_str(), _value.length(), VariantDataType::VAR_STRING);
        return *this;
    }
 
    WSString& operator=(const Buffer& _value)
    {
        value().setBuffer(_value.data(), _value.bytes(), VariantDataType::VAR_BUFFER);
        return *this;
    }
 
    WSString& operator=(int32_t _value)
    {
        value().setInteger(_value);
        return *this;
    }
 
    WSString& operator=(int64_t _value)
    {
        value().setInt64(_value);
        return *this;
    }
 
    operator String() const override
    {
        return value().asString();
    }
 
    const char* getString() const
    {
        return value().getString();
    }
};
 
class SP_EXPORT WSBool
    : public WSBasicType
{
public:
    WSBool()
    {
        setNull(VariantDataType::VAR_BOOL);
    }
 
    WSBool(const String& name, bool optional)
        : WSBasicType(name.c_str(), optional)
    {
        setNull(VariantDataType::VAR_BOOL);
    }
 
    explicit WSBool(bool _value)
    {
        value().setBool(_value);
    }
 
    String className() const override
    {
        return "WSBool";
    }
 
    VariantDataType defaultDataType() const override
    {
        return VariantDataType::VAR_BOOL;
    };
 
    void load(const xdoc::SNode& attr, bool nullLargeData) override;
 
    void load(const String& attr) override;
 
    void load(const Field& field) override;
 
    virtual WSBool& operator=(bool _value)
    {
        value().setBool(_value);
        return *this;
    }
 
    operator bool() const
    {
        return value().asBool();
    }
};
 
class SP_EXPORT WSDate
    : public WSBasicType
{
public:
    WSDate()
    {
        setNull(VariantDataType::VAR_DATE);
    }
 
    WSDate(const String& name, bool optional)
        : WSBasicType(name.c_str(), optional)
    {
        setNull(VariantDataType::VAR_DATE);
    }
 
    explicit WSDate(const DateTime& _value)
    {
        value().setDateTime(_value, true);
    }
 
    String className() const override
    {
        return "WSDate";
    }
 
    VariantDataType defaultDataType() const override
    {
        return VariantDataType::VAR_DATE;
    };
 
    void load(const xdoc::SNode& attr, bool nullLargeData) override;
 
    void load(const String& attr) override;
 
    void load(const Field& field) override;
 
    WSDate& operator=(DateTime _value)
    {
        value().setDateTime(_value, true);
        return *this;
    }
 
    auto asDate() const
    {
        return value().asDate();
    }
 
    auto asDateTime() const
    {
        return value().asDateTime();
    }
 
    operator DateTime() const
    {
        return value().asDate();
    }
};
 
class SP_EXPORT WSDateTime
    : public WSBasicType
{
public:
    WSDateTime()
    {
        setNull(VariantDataType::VAR_DATE_TIME);
    }
 
    WSDateTime(const String& name, bool optional)
        : WSBasicType(name.c_str(), optional)
    {
        setNull(VariantDataType::VAR_DATE_TIME);
    }
 
    explicit WSDateTime(const DateTime& _value)
    {
        value().setDateTime(_value);
    }
 
    String className() const override
    {
        return "WSDateTime";
    }
 
    VariantDataType defaultDataType() const override
    {
        return VariantDataType::VAR_DATE_TIME;
    };
 
    void load(const xdoc::SNode& attr, bool nullLargeData) override;
 
    void load(const String& attr) override;
 
    void load(const Field& field) override;
 
    String asString() const override;
 
    auto asDate() const
    {
        return value().asDate();
    }
 
    auto asDateTime() const
    {
        return value().asDateTime();
    }
 
    WSDateTime& operator=(DateTime _value)
    {
        value().setDateTime(_value);
        return *this;
    }
 
    operator DateTime() const
    {
        return value().asDateTime();
    }
};
 
class SP_EXPORT WSDouble
    : public WSBasicType
{
public:
    WSDouble()
    {
        setNull(VariantDataType::VAR_FLOAT);
    }
 
    WSDouble(const String& name, bool optional)
        : WSBasicType(name.c_str(), optional)
    {
        setNull(VariantDataType::VAR_FLOAT);
    }
 
    WSDouble(double _value)
    {
        value().setFloat(_value);
    }
 
    String className() const override
    {
        return "WSDouble";
    }
 
    VariantDataType defaultDataType() const override
    {
        return VariantDataType::VAR_FLOAT;
    };
 
    void load(const xdoc::SNode& attr, bool nullLargeData) override;
 
    void load(const String& attr) override;
 
    void load(const Field& field) override;
 
    WSDouble& operator=(double _value)
    {
        value().setFloat(_value);
        return *this;
    }
 
    operator double() const
    {
        return value().asFloat();
    }
};
 
class SP_EXPORT WSInteger
    : public WSBasicType
{
public:
    WSInteger()
    {
        setNull(VariantDataType::VAR_INT);
    }
 
    WSInteger(const String& name, bool optional)
        : WSBasicType(name.c_str(), optional)
    {
        setNull(VariantDataType::VAR_INT);
    }
 
    WSInteger(int _value)
    {
        value().setInteger(_value);
    }
 
    String className() const override
    {
        return "WSInteger";
    }
 
    VariantDataType defaultDataType() const override
    {
        return VariantDataType::VAR_INT;
    };
 
    void load(const xdoc::SNode& attr, bool nullLargeData) override;
 
    void load(const String& attr) override;
 
    void load(const Field& field) override;
 
    WSInteger& operator=(int64_t _value)
    {
        value().setInt64(_value);
        return *this;
    }
 
    WSInteger& operator=(int _value)
    {
        value().setInteger(_value);
        return *this;
    }
 
    operator int32_t() const
    {
        return value().asInteger();
    }
 
    operator int64_t() const
    {
        return value().asInt64();
    }
 
    operator uint64_t() const
    {
        return (uint64_t) value().asInt64();
    }
};
 
String SP_EXPORT wsTypeIdToName(const String& typeIdName);
 
} // namespace sptk