anonymous_namespace{Field.cpp} Namespace Reference

Functions
template<typename T >
constexpr T	GetDefaultValue ()
template<typename T >
bool	IsCorrectFieldType (DatabaseFieldTypes type)
Optional< std::string_view >	GetCleanAliasName (std::string_view alias)
template<typename T >
bool	IsCorrectAlias (DatabaseFieldTypes type, std::string_view alias)

Function Documentation

GetCleanAliasName()

Optional< std::string_view > anonymous_namespace{Field.cpp}::GetCleanAliasName ( std::string_view  alias )

inline

    {
        if (alias.empty())
            return {};
 
        auto pos = alias.find_first_of('(');
        if (pos == std::string_view::npos)
            return {};
 
        alias.remove_suffix(alias.length() - pos);
 
        return { alias };
    }

GetDefaultValue()

template<typename T >

constexpr T anonymous_namespace{Field.cpp}::GetDefaultValue ( )

constexpr

    {
        if constexpr (std::is_same_v<T, bool>)
            return false;
        else if constexpr (std::is_integral_v<T>)
            return 0;
        else if constexpr (std::is_floating_point_v<T>)
            return 1.0f;
        else if constexpr (std::is_same_v<T, std::vector<uint8>> || std::is_same_v<std::string_view, T>)
            return {};
        else
            return "";
    }

IsCorrectAlias()

template<typename T >

bool anonymous_namespace{Field.cpp}::IsCorrectAlias ( DatabaseFieldTypes  type, std::string_view  alias  )

inline

    {
        if constexpr (std::is_same_v<T, double>)
        {
            if ((StringEqualI(alias, "sum") || StringEqualI(alias, "avg")) && type == DatabaseFieldTypes::Decimal)
                return true;
 
            return false;
        }
 
        if constexpr (std::is_same_v<T, uint64>)
        {
            if (StringEqualI(alias, "count") && type == DatabaseFieldTypes::Int64)
                return true;
 
            return false;
        }
 
        if ((StringEqualI(alias, "min") || StringEqualI(alias, "max")) && IsCorrectFieldType<T>(type))
        {
            return true;
        }
 
        return false;
    }

References Decimal, Int64, and StringEqualI().

IsCorrectFieldType()

template<typename T >

bool anonymous_namespace{Field.cpp}::IsCorrectFieldType ( DatabaseFieldTypes  type )

inline

    {
        // Int8
        if constexpr (std::is_same_v<T, bool> || std::is_same_v<T, int8> || std::is_same_v<T, uint8>)
        {
            if (type == DatabaseFieldTypes::Int8)
                return true;
        }
 
        // In16
        if constexpr (std::is_same_v<T, uint16> || std::is_same_v<T, int16>)
        {
            if (type == DatabaseFieldTypes::Int16)
                return true;
        }
 
        // Int32
        if constexpr (std::is_same_v<T, uint32> || std::is_same_v<T, int32>)
        {
            if (type == DatabaseFieldTypes::Int32)
                return true;
        }
 
        // Int64
        if constexpr (std::is_same_v<T, uint64> || std::is_same_v<T, int64>)
        {
            if (type == DatabaseFieldTypes::Int64)
                return true;
        }
 
        // float
        if constexpr (std::is_same_v<T, float>)
        {
            if (type == DatabaseFieldTypes::Float)
                return true;
        }
 
        // dobule
        if constexpr (std::is_same_v<T, double>)
        {
            if (type == DatabaseFieldTypes::Double || type == DatabaseFieldTypes::Decimal)
                return true;
        }
 
        // Binary
        if constexpr (std::is_same_v<T, Binary>)
        {
            if (type == DatabaseFieldTypes::Binary)
                return true;
        }
 
        return false;
    }

References Binary, Decimal, Double, Float, Int16, Int32, Int64, and Int8.