rdb/include/value_object.h

/*
 * Copyright (c) 2021 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef NATIVE_RDB_VALUE_OBJECT_H
#define NATIVE_RDB_VALUE_OBJECT_H

#include <string>
#include <variant>
#include <vector>

#include "asset_value.h"
#include "rdb_visibility.h"
namespace OHOS {
namespace NativeRdb {
/**
 * The ValueObject class of RDB.
 */
class API_EXPORT ValueObject {
public:
    /**
     * @brief Use Type replace std::variant.
     */
    using Nil = std::monostate;
    using Blob = std::vector<uint8_t>;
    using Asset = AssetValue;
    using Assets = std::vector<Asset>;
    using Type = std::variant<Nil, int64_t, double, std::string, bool, Blob, Asset, Assets>;
    template<typename Tp, typename... Types>
    struct index_of : std::integral_constant<size_t, 0> {};

    template<typename Tp, typename... Types>
    inline static constexpr size_t index_of_v = index_of<Tp, Types...>::value;

    template<typename Tp, typename First, typename... Rest>
    struct index_of<Tp, First, Rest...>
        : std::integral_constant<size_t, std::is_same_v<Tp, First> ? 0 : index_of_v<Tp, Rest...> + 1> {};

    template<typename... Types>
    struct variant_size_of {
        static constexpr size_t value = sizeof...(Types);
    };

    template<typename T, typename... Types>
    struct variant_index_of {
        static constexpr size_t value = index_of_v<T, Types...>;
    };

    template<typename... Types>
    static variant_size_of<Types...> variant_size_test(const std::variant<Types...> &);

    template<typename T, typename... Types>
    static variant_index_of<T, Types...> variant_index_test(const T &, const std::variant<Types...> &);

    template<typename T>
    inline constexpr static int32_t TYPE_INDEX =
        decltype(variant_index_test(std::declval<T>(), std::declval<Type>()))::value;

    inline constexpr static int32_t TYPE_MAX = decltype(variant_size_test(std::declval<Type>()))::value;

    /**
     * @brief Indicates the ValueObject {@link ValueObject} type.
     * */
    enum TypeId : int32_t {
        /** Indicates the ValueObject type is NULL.*/
        TYPE_NULL = TYPE_INDEX<Nil>,
        /** Indicates the ValueObject type is int.*/
        TYPE_INT = TYPE_INDEX<int64_t>,
        /** Indicates the ValueObject type is double.*/
        TYPE_DOUBLE = TYPE_INDEX<double>,
        /** Indicates the ValueObject type is string.*/
        TYPE_STRING = TYPE_INDEX<std::string>,
        /** Indicates the ValueObject type is bool.*/
        TYPE_BOOL = TYPE_INDEX<bool>,
        /** Indicates the ValueObject type is blob.*/
        TYPE_BLOB = TYPE_INDEX<Blob>,
        /** Indicates the ValueObject type is asset.*/
        TYPE_ASSET = TYPE_INDEX<Asset>,
        /** Indicates the ValueObject type is assets.*/
        TYPE_ASSETS = TYPE_INDEX<Assets>,
        /** the BUTT.*/
        TYPE_BUTT = TYPE_MAX
    };
    Type value;

    /**
     * @brief convert a std::variant input to another std::variant output with different (..._Types)
     */
    template<typename T>
    static inline std::enable_if_t<(TYPE_INDEX<T>) < TYPE_MAX, const char *> DeclType()
    {
        return DECLARE_TYPES[TYPE_INDEX<T>];
    }
    /**
     * @brief Constructor.
     */
    API_EXPORT ValueObject();

    /**
     * @brief Destructor.
     */
    API_EXPORT ~ValueObject();

    /**
     * @brief Constructor.
     *
     * A parameterized constructor used to create a ValueObject instance.
     */
    API_EXPORT ValueObject(Type val) noexcept;

    /**
     * @brief Move constructor.
     */
    API_EXPORT ValueObject(ValueObject &&val) noexcept;

    /**
     * @brief Copy constructor.
     */
    API_EXPORT ValueObject(const ValueObject &val);

    /**
     * @brief Constructor.
     *
     * This constructor is used to convert the int input parameter to a value of type ValueObject.
     *
     * @param val Indicates an int input parameter.
     */
    API_EXPORT ValueObject(int32_t val);

    /**
     * @brief Constructor.
     *
     * This constructor is used to convert the int64_t input parameter to a value of type ValueObject.
     *
     * @param val Indicates an int64_t input parameter.
     */
    API_EXPORT ValueObject(int64_t val);

    /**
     * @brief Constructor.
     *
     * This constructor is used to convert the double input parameter to a value of type ValueObject.
     *
     * @param val Indicates an double input parameter.
     */
    API_EXPORT ValueObject(double val);

    /**
     * @brief Constructor.
     *
     * This constructor is used to convert the bool input parameter to a value of type ValueObject.
     *
     * @param val Indicates an bool input parameter.
     */
    API_EXPORT ValueObject(bool val);

    /**
     * @brief Constructor.
     *
     * This constructor is used to convert the string input parameter to a value of type ValueObject.
     *
     * @param val Indicates an string input parameter.
     */
    API_EXPORT ValueObject(std::string val);

    /**
     * @brief Constructor.
     *
     * This constructor is used to convert the const char * input parameter to a value of type ValueObject.
     *
     * @param val Indicates an const char * input parameter.
     */
    API_EXPORT ValueObject(const char *val);

    /**
     * @brief Constructor.
     *
     * This constructor is used to convert the vector<uint8_t> input parameter to a value of type ValueObject.
     *
     * @param val Indicates an vector<uint8_t> input parameter.
     */
    API_EXPORT ValueObject(const std::vector<uint8_t> &blob);

    /**
     * @brief Constructor.
     *
     * This constructor is used to convert the Asset input parameter to a value of type ValueObject.
     *
     * @param val Indicates an Asset input parameter.
     */
    API_EXPORT ValueObject(Asset val);

    /**
     * @brief Constructor.
     *
     * This constructor is used to convert the Assets input parameter to a value of type ValueObject.
     *
     * @param val Indicates an Assets input parameter.
     */
    API_EXPORT ValueObject(Assets val);

    /**
     * @brief Move assignment operator overloaded function.
     */
    API_EXPORT ValueObject &operator=(ValueObject &&valueObject) noexcept;

    /**
     * @brief Copy assignment operator overloaded function.
     */
    API_EXPORT ValueObject &operator=(const ValueObject &valueObject);

    /**
     * @brief Obtains the type in this {@code ValueObject} object.
     */
    API_EXPORT TypeId GetType() const;

    /**
     * @brief Obtains the int value in this {@code ValueObject} object.
     */
    API_EXPORT int GetInt(int &val) const;

    /**
     * @brief Obtains the long value in this {@code ValueObject} object.
     */
    API_EXPORT int GetLong(int64_t &val) const;

    /**
     * @brief Obtains the double value in this {@code ValueObject} object.
     */
    API_EXPORT int GetDouble(double &val) const;

    /**
     * @brief Obtains the bool value in this {@code ValueObject} object.
     */
    API_EXPORT int GetBool(bool &val) const;

    /**
     * @brief Obtains the string value in this {@code ValueObject} object.
     */
    API_EXPORT int GetString(std::string &val) const;

    /**
     * @brief Obtains the vector<uint8_t> value in this {@code ValueObject} object.
     */
    API_EXPORT int GetBlob(std::vector<uint8_t> &val) const;

    /**
     * @brief Obtains the vector<uint8_t> value in this {@code ValueObject} object.
     */
    API_EXPORT int GetAsset(Asset &val) const;

    /**
     * @brief Obtains the vector<uint8_t> value in this {@code ValueObject} object.
     */
    API_EXPORT int GetAssets(Assets &val) const;

    /**
     * @brief Type conversion function.
     *
     * @return Returns the int type ValueObject.
     */
    operator int() const
    {
        return static_cast<int>(std::get<int64_t>(value));
    }

    /**
     * @brief Type conversion function.
     *
     * @return Returns the int64_t type ValueObject.
     */
    operator int64_t() const
    {
        return std::get<int64_t>(value);
    }

    /**
     * @brief Type conversion function.
     *
     * @return Returns the double type ValueObject.
     */
    operator double() const
    {
        return std::get<double>(value);
    }

    /**
     * @brief Type conversion function.
     *
     * @return Returns the bool type ValueObject.
     */
    operator bool() const
    {
        return std::get<bool>(value);
    }

    /**
     * @brief Type conversion function.
     *
     * @return Returns the string type ValueObject.
     */
    operator std::string() const
    {
        return std::get<std::string>(value);
    }

    /**
     * @brief Type conversion function.
     *
     * @return Returns the vector<uint8_t> type ValueObject.
     */
    operator Blob() const
    {
        return std::get<Blob>(value);
    }

    /**
     * @brief Type conversion function.
     *
     * @return Returns the vector<uint8_t> type ValueObject.
     */
    operator Asset() const
    {
        return std::get<Asset>(value);
    }

    /**
    * @brief Type conversion function.
    *
    * @return Returns the vector<uint8_t> type ValueObject.
    */
    operator Assets() const
    {
        return std::get<Assets>(value);
    }

    /**
     * @brief Type conversion function.
     *
     * @return Returns the Type type ValueObject.
     */
    operator Type() const
    {
        return value;
    }

private:
    template<class T>
    int Get(T &output) const;
    static constexpr const char *DECLARE_TYPES[TypeId::TYPE_BUTT] = {
        /** Indicates the ValueObject type is NULL.*/
        "",
        /** Indicates the ValueObject type is int.*/
        "INT",
        /** Indicates the ValueObject type is double.*/
        "REAL",
        /** Indicates the ValueObject type is string.*/
        "TEXT",
        /** Indicates the ValueObject type is bool.*/
        "INT",
        /** Indicates the ValueObject type is blob.*/
        "BLOB",
        /** Indicates the ValueObject type is asset.*/
        "ASSET",
        /** Indicates the ValueObject type is assets.*/
        "ASSETS"
    };
};
using ValueObjectType = ValueObject::TypeId;
} // namespace NativeRdb
} // namespace OHOS
#endif