Variant.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/Buffer.h>
#include <sptk5/DateTime.h>
#include <sptk5/Exception.h>
#include <sptk5/VariantData.h>
#include <sptk5/sptk.h>
 
#include <utility>
 
namespace sptk {
 
namespace xdoc {
class Node;
}
 
class Field;
 
class SP_EXPORT BaseVariant
{
    friend class VariantAdaptors;
 
public:
    BaseVariant() = default;
 
    BaseVariant(const BaseVariant& other) = default;
 
    BaseVariant(BaseVariant&& other) noexcept = default;
 
    virtual ~BaseVariant() = default;
 
    [[nodiscard]] VariantDataType dataType() const;
 
    [[nodiscard]] size_t dataSize() const;
 
    void dataSize(size_t newDataSize);
 
    [[nodiscard]] size_t bufferSize() const;
 
    [[nodiscard]] bool isNull() const;
 
    [[nodiscard]] static String typeName(VariantDataType type);
 
    [[nodiscard]] static VariantDataType nameType(const char* name);
 
    template<typename T>
    const T& get() const
    {
        return m_data.get<T>();
    }
 
    template<typename T>
    T& get()
    {
        return m_data.get<T>();
    }
 
    [[nodiscard]] virtual const MoneyData& getMoney() const;
 
    [[nodiscard]] virtual const char* getString() const;
 
    [[nodiscard]] virtual const uint8_t* getExternalBuffer() const;
 
    [[nodiscard]] virtual const char* getText() const;
 
    [[nodiscard]] virtual const uint8_t* getImagePtr() const;
 
    [[nodiscard]] virtual uint32_t getImageNdx() const;
 
protected:
    void dataType(VariantType newDataType);
 
    void dataType(VariantDataType newDataType);
 
    [[nodiscard]] bool isExternalBuffer() const
    {
        return m_data.type().isExternalBuffer;
    }
 
    [[nodiscard]] virtual String moneyDataToString() const;
 
    VariantData m_data; 
};
 
class SP_EXPORT VariantAdaptors
    : public BaseVariant
{
public:
    VariantAdaptors() = default;
 
    VariantAdaptors(const VariantAdaptors& other) = default;
 
    VariantAdaptors(VariantAdaptors&& other) noexcept = default;
 
    ~VariantAdaptors() override = default;
 
    virtual void setBool(bool value);
 
    virtual void setInteger(int32_t value);
 
    virtual void setInt64(int64_t value);
 
    virtual void setFloat(double value);
 
    virtual void setMoney(int64_t value, unsigned scale);
 
    virtual void setString(const String& value);
 
    virtual void setBuffer(const uint8_t* value, size_t valueSize, VariantDataType type = VariantDataType::VAR_BUFFER);
 
    virtual void setExternalBuffer(uint8_t* value, size_t valueSize, VariantDataType type = VariantDataType::VAR_BUFFER);
 
    virtual void setDateTime(DateTime value, bool dateOnly = false);
 
    virtual void setImagePtr(const uint8_t* value);
 
    virtual void setImageNdx(uint32_t value);
 
    virtual void setMoney(const MoneyData& value);
 
    virtual void setNull(VariantDataType vtype = VariantDataType::VAR_NONE);
 
    [[nodiscard]] int asInteger() const;
 
    [[nodiscard]] int64_t asInt64() const;
 
    [[nodiscard]] bool asBool() const;
 
    [[nodiscard]] double asFloat() const;
 
    [[nodiscard]] virtual String asString() const;
 
    [[nodiscard]] DateTime asDate() const;
 
    [[nodiscard]] DateTime asDateTime() const;
 
    const uint8_t* asImagePtr() const;
 
protected:
    void setData(const BaseVariant& other);
    [[nodiscard]] const char* getBufferPtr() const;
};
 
class SP_EXPORT Variant
    : public VariantAdaptors
{
public:
    Variant();
 
    Variant(bool value);
 
    Variant(int32_t value);
 
    Variant(int64_t value, unsigned scale = 1);
 
    Variant(double value);
 
    Variant(const char* value);
 
    Variant(const String& v);
 
    Variant(const DateTime& v);
 
    Variant(const uint8_t* value, size_t sz);
 
    Variant(const Buffer& value);
 
    explicit Variant(const Variant& other) = default;
 
    Variant(Variant&& other) noexcept = default;
 
    ~Variant() override;
 
    Variant& operator=(const Variant& other);
 
    Variant& operator=(Variant&& other) noexcept;
 
    virtual Variant& operator=(bool value);
 
    virtual Variant& operator=(int32_t value);
 
    virtual Variant& operator=(int64_t value);
 
    virtual Variant& operator=(double value);
 
    virtual Variant& operator=(const MoneyData& value);
 
    virtual Variant& operator=(const char* value);
 
    virtual Variant& operator=(const String& value);
 
    virtual Variant& operator=(DateTime value);
 
    virtual Variant& operator=(const uint8_t* value);
 
    virtual Variant& operator=(const Buffer& value);
 
    virtual explicit operator bool() const;
 
    virtual explicit operator int() const;
 
    virtual explicit operator int64_t() const;
 
    virtual explicit operator uint64_t() const;
 
    virtual explicit operator double() const;
 
    virtual explicit operator String() const;
 
    virtual explicit operator DateTime() const;
 
    virtual void load(const std::shared_ptr<xdoc::Node>& element);
 
    void save(const std::shared_ptr<xdoc::Node>& node) const;
};
 
using VariantVector = std::vector<Variant>;
 
} // namespace sptk