Type.hpp

Go to the documentation of this file.

#pragma once
 
#include <exception>
#include <functional>
#include <mutable/util/fn.hpp>
#include <mutable/util/macro.hpp>
#include <mutable/util/Pool.hpp>
#include <mutable/util/Visitor.hpp>
#include <vector>
 
 
namespace m {
 
struct Type;
struct ErrorType;
struct NoneType;
struct PrimitiveType;
struct Boolean;
struct Bitmap;
struct CharacterSequence;
struct Date;
struct DateTime;
struct Numeric;
struct FnType;
 
// forward declare the Type visitor
struct TypeVisitor;
struct ConstTypeVisitor;
 
}
 
namespace std {
 
template<>
struct hash<m::Type>
{
    uint64_t operator()(const m::Type &type) const;
};
 
}
 
namespace m {
 
struct M_EXPORT Type
{
#define category_t(X) X(TY_Scalar) X(TY_Vector)
    M_DECLARE_ENUM(category_t); 
    protected:
    static constexpr const char *CATEGORY_TO_STR_[] = { M_ENUM_TO_STR(category_t) };
#undef category_t
 
    protected:
    static Pool<Type> types_; 
 
    public:
    template<typename T>
    using Pooled = m::Pooled<T, Pool<Type>>;
 
    Type() = default;
    Type(const Type&) = delete;
    Type(Type&&) = default;
    virtual ~Type() { }
 
    virtual void accept(TypeVisitor &v) = 0;
    virtual void accept(ConstTypeVisitor &v) const = 0;
 
    virtual bool operator==(const Type &other) const = 0;
    bool operator!=(const Type &other) const { return not operator==(other); }
 
    bool is_error() const { return Get_Error() == this; }
    bool is_none() const { return Get_None() == this; }
    bool is_primitive() const { return is<const PrimitiveType>(this); }
    bool is_boolean() const { return is<const Boolean>(this); }
    bool is_bitmap() const { return is<const Bitmap>(this); }
    bool is_character_sequence() const { return is<const CharacterSequence>(this); }
    bool is_date() const { return is<const Date>(this); }
    bool is_date_time() const { return is<const DateTime>(this); }
    bool is_numeric() const { return is<const Numeric>(this); }
    bool is_integral() const;
    bool is_decimal() const;
    bool is_floating_point() const;
    bool is_float() const;
    bool is_double() const;
 
    virtual uint64_t size() const { throw std::logic_error("the size of this type is not defined"); }
 
    virtual uint64_t alignment() const { throw std::logic_error("the size of this type is not defined"); }
 
    virtual uint64_t hash() const = 0;
 
    virtual void print(std::ostream &out) const = 0;
 
    virtual void dump(std::ostream &out) const = 0;
    void dump() const;
 
M_LCOV_EXCL_START
    friend std::ostream & operator<<(std::ostream &out, const Type &t) {
        t.print(out);
        return out;
    }
M_LCOV_EXCL_STOP
 
    /*----- Type factory methods -------------------------------------------------------------------------------------*/
    static Pooled<ErrorType> Get_Error();
    static Pooled<NoneType> Get_None();
    static Pooled<Boolean> Get_Boolean(category_t category);
    static Pooled<Bitmap> Get_Bitmap(category_t category, std::size_t length);
    static Pooled<CharacterSequence> Get_Char(category_t category, std::size_t length);
    static Pooled<CharacterSequence> Get_Varchar(category_t category, std::size_t length);
    static Pooled<Date> Get_Date(category_t category);
    static Pooled<DateTime> Get_Datetime(category_t category);
    static Pooled<Numeric> Get_Decimal(category_t category, unsigned digits, unsigned scale);
    static Pooled<Numeric> Get_Integer(category_t category, unsigned num_bytes);
    static Pooled<Numeric> Get_Float(category_t category);
    static Pooled<Numeric> Get_Double(category_t category);
    static Pooled<FnType> Get_Function(const Type *return_type, std::vector<const Type*> parameter_types);
};
 
template<typename T>
bool M_EXPORT is_convertible(const Type *attr);
 
bool M_EXPORT is_comparable(const Type *first, const Type *second);
 
template<typename T>
const PrimitiveType * M_EXPORT get_runtime_type();
 
}
 
namespace m {
 
struct M_EXPORT PrimitiveType : Type
{
    category_t category; 
 
    PrimitiveType(category_t category) : category(category) { }
    PrimitiveType(const PrimitiveType&) = delete;
    PrimitiveType(PrimitiveType&&) = default;
    virtual ~PrimitiveType() { }
 
    bool is_scalar() const { return category == TY_Scalar; }
    bool is_vectorial() const { return category == TY_Vector; }
 
    virtual const PrimitiveType * as_scalar() const = 0;
 
    virtual const PrimitiveType * as_vectorial() const = 0;
};
 
struct M_EXPORT ErrorType: Type
{
    friend struct Type;
 
    private:
    ErrorType() { }
 
    public:
    ErrorType(ErrorType&&) = default;
 
    void accept(TypeVisitor &v) override;
    void accept(ConstTypeVisitor &v) const override;
 
    bool operator==(const Type &other) const override;
 
    uint64_t hash() const override;
 
    void print(std::ostream &out) const override;
    using Type::dump;
    void dump(std::ostream &out) const override;
};
 
struct M_EXPORT NoneType: Type
{
    friend struct Type;
 
    private:
    NoneType() { }
 
    public:
    NoneType(NoneType&&) = default;
 
    void accept(TypeVisitor &v) override;
    void accept(ConstTypeVisitor &v) const override;
 
    bool operator==(const Type &other) const override;
 
    uint64_t size() const override { return 0; }
    uint64_t alignment() const override { return 1; }
 
    uint64_t hash() const override;
 
    void print(std::ostream &out) const override;
    using Type::dump;
    void dump(std::ostream &out) const override;
};
 
struct M_EXPORT Boolean : PrimitiveType
{
    friend struct Type;
 
    private:
    Boolean(category_t category) : PrimitiveType(category) { }
 
    public:
    Boolean(Boolean&&) = default;
 
    void accept(TypeVisitor &v) override;
    void accept(ConstTypeVisitor &v) const override;
 
    bool operator==(const Type &other) const override;
 
    uint64_t size() const override { return 1; }
    uint64_t alignment() const override { return 1; }
 
    uint64_t hash() const override;
 
    void print(std::ostream &out) const override;
    using Type::dump;
    void dump(std::ostream &out) const override;
 
    virtual const PrimitiveType *as_scalar() const override;
    virtual const PrimitiveType *as_vectorial() const override;
};
 
struct M_EXPORT Bitmap : PrimitiveType
{
    friend struct Type;
 
    uint64_t length; 
 
    private:
    Bitmap(category_t category, uint64_t length) : PrimitiveType(category), length(length) { }
 
    public:
    Bitmap(Bitmap&&) = default;
 
    void accept(TypeVisitor &v) override;
    void accept(ConstTypeVisitor &v) const override;
 
    bool operator==(const Type &other) const override;
 
    uint64_t size() const override { return length; }
    uint64_t alignment() const override { return 1; }
 
    uint64_t hash() const override;
 
    void print(std::ostream &out) const override;
    using Type::dump;
    void dump(std::ostream &out) const override;
 
    virtual const PrimitiveType *as_scalar() const override;
    virtual const PrimitiveType *as_vectorial() const override;
};
 
struct M_EXPORT CharacterSequence : PrimitiveType
{
    friend struct Type;
 
    std::size_t length; 
    bool is_varying; 
 
    private:
    CharacterSequence(category_t category, std::size_t length, bool is_varying)
            : PrimitiveType(category)
            , length(length)
            , is_varying(is_varying)
    { }
 
    public:
    CharacterSequence(CharacterSequence&&) = default;
 
    void accept(TypeVisitor &v) override;
    void accept(ConstTypeVisitor &v) const override;
 
    bool operator==(const Type &other) const override;
 
    uint64_t size() const override {
        if (is_varying)
            return 8 * (length + 1);
        else
            return 8 * length;
    }
 
    uint64_t alignment() const override { return 8; }
 
    uint64_t hash() const override;
 
    void print(std::ostream &out) const override;
    using Type::dump;
    void dump(std::ostream &out) const override;
 
    virtual const PrimitiveType *as_scalar() const override;
    virtual const PrimitiveType *as_vectorial() const override;
};
 
struct M_EXPORT Date : PrimitiveType
{
    friend struct Type;
 
    private:
    Date(category_t category) : PrimitiveType(category) { }
 
    public:
    Date(Date&&) = default;
 
    void accept(TypeVisitor &v) override;
    void accept(ConstTypeVisitor &v) const override;
 
    bool operator==(const Type &other) const override;
 
    uint64_t size() const override { return 32; }
    uint64_t alignment() const override { return 32; }
 
    uint64_t hash() const override;
 
    void print(std::ostream &out) const override;
    using Type::dump;
    void dump(std::ostream &out) const override;
 
    virtual const PrimitiveType *as_scalar() const override;
    virtual const PrimitiveType *as_vectorial() const override;
};
 
struct M_EXPORT DateTime : PrimitiveType
{
    friend struct Type;
 
    private:
    DateTime(category_t category) : PrimitiveType(category) { }
 
    public:
    DateTime(DateTime&&) = default;
 
    void accept(TypeVisitor &v) override;
    void accept(ConstTypeVisitor &v) const override;
 
    bool operator==(const Type &other) const override;
 
    uint64_t size() const override { return 64; }
    uint64_t alignment() const override { return 64; }
 
    uint64_t hash() const override;
 
    void print(std::ostream &out) const override;
    using Type::dump;
    void dump(std::ostream &out) const override;
 
    virtual const PrimitiveType *as_scalar() const override;
    virtual const PrimitiveType *as_vectorial() const override;
};
 
struct M_EXPORT Numeric : PrimitiveType
{
    friend struct Type;
 
    static constexpr std::size_t MAX_DECIMAL_PRECISION = 19;
 
    static constexpr float DECIMAL_TO_BINARY_DIGITS = 3.32192f;
 
#define kind_t(X) X(N_Int) X(N_Float) X(N_Decimal)
    M_DECLARE_ENUM(kind_t) kind; 
private:
    static constexpr const char *KIND_TO_STR_[] = { M_ENUM_TO_STR(kind_t) };
#undef kind_t
    public:
    unsigned precision; 
    unsigned scale; 
 
    private:
    Numeric(category_t category, kind_t kind, unsigned precision, unsigned scale)
            : PrimitiveType(category)
            , kind(kind)
            , precision(precision)
            , scale(scale)
    { }
 
    public:
    Numeric(Numeric&&) = default;
 
    void accept(TypeVisitor &v) override;
    void accept(ConstTypeVisitor &v) const override;
 
    bool operator==(const Type &other) const override;
 
    uint64_t size() const override {
        switch (kind) {
            case N_Int: return 8 * precision;
            case N_Float: return precision;
            case N_Decimal: return ceil_to_pow_2(uint32_t(std::ceil(DECIMAL_TO_BINARY_DIGITS * precision)));
        }
        M_unreachable("illegal kind");
    }
 
    uint64_t alignment() const override { return size(); }
 
    uint64_t hash() const override;
 
    void print(std::ostream &out) const override;
    using Type::dump;
    void dump(std::ostream &out) const override;
 
    virtual const PrimitiveType *as_scalar() const override;
    virtual const PrimitiveType *as_vectorial() const override;
};
 
struct M_EXPORT FnType : Type
{
    friend struct Type;
 
    const Type *return_type; 
    std::vector<const Type *> parameter_types; 
 
    private:
    FnType(const Type *return_type, std::vector<const Type*> parameter_types)
            : return_type(M_notnull(return_type))
            , parameter_types(parameter_types)
    { }
 
    public:
    FnType(FnType&&) = default;
 
    void accept(TypeVisitor &v) override;
    void accept(ConstTypeVisitor &v) const override;
 
    bool operator==(const Type &other) const override;
 
    uint64_t hash() const override;
 
    void print(std::ostream &out) const override;
    using Type::dump;
    void dump(std::ostream &out) const override;
};
 
/* Given two `Numeric` types, compute the `Numeric` type that is at least as precise as either of them. */
const Numeric * arithmetic_join(const Numeric *lhs, const Numeric *rhs);
 
#define M_TYPE_LIST(X) \
    X(ErrorType) \
    X(NoneType) \
    X(Boolean) \
    X(Bitmap) \
    X(CharacterSequence) \
    X(Date) \
    X(DateTime) \
    X(Numeric) \
    X(FnType)
 
M_DECLARE_VISITOR(TypeVisitor, Type, M_TYPE_LIST)
M_DECLARE_VISITOR(ConstTypeVisitor, const Type, M_TYPE_LIST)
 
inline bool Type::is_integral() const {
    if (auto n = cast<const Numeric>(this))
        return n->kind == Numeric::N_Int;
    return false;
}
 
inline bool Type::is_decimal() const {
    if (auto n = cast<const Numeric>(this))
        return n->kind == Numeric::N_Decimal;
    return false;
}
 
inline bool Type::is_floating_point() const {
    if (auto n = cast<const Numeric>(this))
        return n->kind == Numeric::N_Float;
    return false;
}
 
inline bool Type::is_float() const {
    if (auto n = cast<const Numeric>(this))
        return n->kind == Numeric::N_Float and n->precision == 32;
    return false;
}
 
inline bool Type::is_double() const {
    if (auto n = cast<const Numeric>(this))
        return n->kind == Numeric::N_Float and n->precision == 64;
    return false;
}
 
template<typename T>
bool is_convertible(const Type *ty) {
    /* Boolean */
    if constexpr (std::is_same_v<T, bool>)
        return is<const Boolean>(ty);
 
    /* CharacterSequence */
    if constexpr (std::is_same_v<T, std::string>)
        return is<const CharacterSequence>(ty);
 
    /* Numeric */
    if constexpr (std::is_arithmetic_v<T>)
        return is<const Numeric>(ty);
 
    return false;
}
 
inline bool is_comparable(const Type *first, const Type *second) {
    if (first->is_boolean() and second->is_boolean()) return true;
    if (first->is_character_sequence() and second->is_character_sequence()) return true;
    if (first->is_date() and second->is_date()) return true;
    if (first->is_date_time() and second->is_date_time()) return true;
    if (first->is_numeric() and second->is_numeric()) return true;
    return false;
}
 
 
template<typename T>
const PrimitiveType * get_runtime_type()
{
    if constexpr (std::is_integral_v<T>)
        return Type::Get_Integer(Type::TY_Vector, sizeof(T));
    else if constexpr (std::is_same_v<T, float>)
        return Type::Get_Float(Type::TY_Vector);
    else if constexpr (std::is_same_v<T, double>)
        return Type::Get_Double(Type::TY_Vector);
    else
        static_assert(not std::is_same_v<T, T>, "unsupported compile-time type T");
}
 
}