type.h

Go to the documentation of this file.

 
#ifndef _EXPORT_TYPE_H_
#define _EXPORT_TYPE_H_
 
#include <string>
#include <tuple>
 
class Type {
    enum class Data {
        COMPLEX,  
        FLOAT,    
        INTEGER,  
        UNSIGNED, 
        BOOL,     
        STRING,   
        CHAR,     
        OTHER,    
        UNKNOWN   
    };
 
    enum class Suffix {
        NONE,       
        CONST_,     
        REFERENCE_, 
        VOLATILE_,  
        UNKNOWN,    
    };
 
    using Dim = int8_t;
 
  public:
    Type() = default;
 
    Type(const std::string& str);
 
    Data data() const noexcept;
 
    Dim dim() const noexcept;
 
    std::string string() const noexcept;
 
    bool isUnknown() const noexcept;
 
    bool isConst() const noexcept;
 
    bool isReference() const noexcept;
 
    static std::string string(const std::string&) noexcept;
 
  private:
    std::tuple<Data, Dim> _getData(char c) const noexcept;
 
    Suffix _getSuffix(char c) const noexcept;
 
    std::string _getString(const std::string& elem_type) const noexcept;
 
  private:
    Data _data     = Data::UNKNOWN;
    Dim _dim       = -1;
    Suffix _suffix = Suffix::NONE;
};
 
inline Type::Data Type::data() const noexcept { return _data; }
 
inline Type::Dim Type::dim() const noexcept { return _dim; }
 
inline bool Type::isUnknown() const noexcept {
    return (_data == Data::UNKNOWN || _dim == -1 || _suffix == Suffix::UNKNOWN);
}
 
inline bool Type::isConst() const noexcept { return _suffix == Suffix::CONST_; }
 
inline bool Type::isReference() const noexcept { return _suffix == Suffix::REFERENCE_; }
 
inline std::string Type::string(const std::string& str) noexcept {
    Type t(str);
    return t.string();
}
 
#endif