CompleteDataType.hpp

//
// Copyright (c) 2004-2023 TIBCO Software Inc. All rights reserved.
//
 
#ifndef STREAMBASE_COMPLETEDATATYPE_HPP_
#define STREAMBASE_COMPLETEDATATYPE_HPP_
 
#include "StreamBase.hpp"
 
#include "DataType.hpp"
#include "Schema.hpp"
 
SB_NAMESPACE_BEGIN;
 
class Schema;
 
/** An object containing all the information about a data type -- the primitive DataType;
 * for DataType::TUPLEs, the Tuple's Schema; and for DataType::LISTs, the List elements'
 * own CompleteDataType.
 * 
 * To get a CompleteDataType object, call the type-appropriate static method, eg. for a 
 * Boolean CompleteDatatType object, call CompleteDataType::forBool(); for a Tuple CompleteDataType,
 * call CompleteDataType::forTuple(s) with some Schema s; for a List CompleteDataType, call
 * CompleteDataType::forList(cdt) with some CompleteDataType cdt; and so on.
 * 
 * CompleteDataTypes are immutable; once created they may not be changed.
 */
class CompleteDataType
{
private:
    /**
     * Create a complete data type from a DataType::foo enum value
     */
    CompleteDataType(DataType type) : _type(type), _schema(0), _name(""), _cdt(0) { }
        
    
    /**
     * Create a complete data type of DataType::TUPLE with the specified Schema
     */
    CompleteDataType(const Schema &schema) : _type(DataType::TUPLE), _schema(new Schema(schema)), _name(""), _cdt(0), _argumentSchema(0), _returnType(0) { }
    
    /**
     * Creates a complete data type of the given type.  Errors if given a schema for a non-DataType::TUPLE type.
     */
    CompleteDataType(DataType type, const Schema &schema) : _type(type), _schema(new Schema(schema)), _name(""), _cdt(0), _argumentSchema(0), _returnType(0) {
        assert(!schema || type == DataType::TUPLE);
    }
    
    /**
     * Create a complete data type of type1 with sub-type type2,
     * eg CompleteDataType(DataType::LIST, DataType::INT)
     */
    CompleteDataType(DataType type, DataType elementType) : 
        _type(type), _schema(0), _name(""), _cdt(new CompleteDataType(elementType)), _argumentSchema(0), _returnType(0) {
        assert(type == DataType::LIST);
    }
    
    /**
     * Create a complete data type of type1 with sub-complete data type type2,
     * eg CompleteDataType(DataType::LIST, CompleteDataType(DataType::LIST, DataType::INT))
     */
    CompleteDataType(DataType type, const CompleteDataType& elementCDT) : 
        _type(type), _schema(0), _name(""), _cdt(new CompleteDataType(elementCDT)), _argumentSchema(0), _returnType(0) {  
        assert(type == DataType::LIST);
    }
 
    /**
     * Create a complete data type for a capture field with the given name. type must be DataType::CAPTURE
     */
    CompleteDataType(DataType type, const std::string name) :
        _type(type), _schema(0), _name(name), _cdt(0), _argumentSchema(0), _returnType(0) {
        assert(type == DataType::CAPTURE);
    }
 
    /**
     * Create a complete data type for a function with the given argument schema and return type
     */
    CompleteDataType(DataType type, const Schema& argumentSchema, const CompleteDataType& returnType) :
        _type(type), _schema(0), _name(""), _cdt(0), _argumentSchema(new Schema(argumentSchema)), _returnType(new CompleteDataType(returnType)) {
        assert(type == DataType::FUNCTION);
    }
 
    
public:
#ifndef DOXYGEN_INTERNAL_ONLY 
    /// Null constructor
    CompleteDataType() : _type(DataType::NONE), _schema(0), _cdt(0), _argumentSchema(0), _returnType(0) {}
#endif
    
    /// Copy constructor
    CompleteDataType(const CompleteDataType& cdt) : _type(cdt._type), 
                                                    _schema(cdt._schema ? new Schema(*(cdt._schema)) : 0), 
                                                    _name(cdt._name),
                                                    _cdt(cdt._cdt ? new CompleteDataType(*(cdt._cdt)) : 0),
                                                    _argumentSchema(cdt._argumentSchema ? new Schema(*(cdt._argumentSchema)) : 0),
                                                    _returnType(cdt._returnType ? new CompleteDataType(*(cdt._returnType)) : 0){
    }
    
    /// Assignment operator
    CompleteDataType& operator=(const CompleteDataType& cdt);
    
    /// Destructor
    ~CompleteDataType() {
        delete _schema;
        delete _cdt;
    }
    
    // Comparison operators
    bool operator==(const CompleteDataType& t) const { return compare(t) == 0; }
    bool operator!=(const CompleteDataType& t) const { return compare(t) != 0; }
    bool operator<(const CompleteDataType& t) const { return compare(t) < 0; }
    bool operator>(const CompleteDataType& t) const { return compare(t) > 0; }
    bool operator<=(const CompleteDataType& t) const { return compare(t) <= 0; }
    bool operator>=(const CompleteDataType& t) const { return compare(t) >= 0; }
 
    // void * operator
    operator const void *() const { return this; }
    
    /**
     * Compare the current CompleteDataType against the provided CompleteDataType by
     * base type (eg DataType::BOOL, ::INT, ::TUPLE, etc).  Therefore,
     * for example a LIST of type INT and a LIST of type TUPLE are equal.
     * 
     * @return -1 if the current CompleteDataType is less than the provided CompleteDataType,
     *   0 if the current is equal to the provided CompleteDataType,
     *   and 1 if the current is greater than the provided CompleteDataType.
     */
    int compare(const CompleteDataType& fv) const;
    
    /// Return a CompleteDataType of type DataType::BOOL
    static const CompleteDataType &forBool() { return BOOL; }
    /// Return a CompleteDataType of type DataType::INT
    static const CompleteDataType &forInt() { return INT; }
    /// Return a CompleteDataType of type DataType::LONG
    static const CompleteDataType &forLong() { return LONG; }
    /// Return a CompleteDataType of type DataType::DOUBLE
    static const CompleteDataType &forDouble() { return DOUBLE; }
    /// Return a CompleteDataType of type DataType::TIMESTAMP
    static const CompleteDataType &forTimestamp() { return TIMESTAMP; }
    /// Return a CompleteDataType of type DataType::STRING
    static const CompleteDataType &forString() { return STRING; }
    /// Return a CompleteDataType of type DataType::BLOB
    static const CompleteDataType &forBlob() { return BLOB; }
    /// Return a CompleteDataType of type DataType::TUPLE with the given Schema
    static const CompleteDataType forTuple(const Schema& s) { return CompleteDataType(DataType::TUPLE, s); }
    /// Return a CompleteDataType of type DataType::LIST with the given CompleteDataType as the type of its elements
    static const CompleteDataType forList(const CompleteDataType& elemType) { return CompleteDataType(DataType::LIST, elemType); }
    /// Return a CompleteDataType of type DataType::CAPTURE with the given capture type name
    static const CompleteDataType forCapture(const std::string  &captureName) { return CompleteDataType(DataType::CAPTURE, captureName); }
    /// Return a CompleteDataType of type DataType::FUNCTION with the given argument schema  and return type
    static const CompleteDataType forFunction(const Schema& argumentSchema, const CompleteDataType& returnType) { 
        return CompleteDataType(DataType::FUNCTION, argumentSchema, returnType); 
    }
 
    /// Convenience method.  Return the CompleteDataType appropriate to the given DataType.  Invalid on DataType::TUPLE 
    /// and DataType::LIST, since they require extra information to fully specify their CompleteDataType.
    static const CompleteDataType forSimpleType(const DataType& type);
 
    /**
     * Return the primitive DataType of the CompleteDataType.
     */
    const DataType &getType() const {
        return _type;
    }
    
    /**
     * Returns true if this CompleteDataType contains a Schema (eg it is a DataType::TUPLE).
     */
    bool hasSchema() {
        return _type == DataType::TUPLE;
    }
    
    /**
     * If this CompleteDataType has a nested tuple, return its Schema.  For all other types, return a null Schema.
     */
    const Schema getSchema() const {
        return _schema ? *_schema : Schema::EMPTY_SCHEMA;
    }
 
    /**
     * Returns true if this CompleteDataType has an element CompleteDataType (eg it is a DataType::LIST of DataType::INTs, the latter being its element type).
     */
    bool hasElementType() const {
        return _cdt ? _cdt->getType() != DataType::NONE : false;
    }
    
    /**
     * If this CompleteDataType has an element type, returns the element CompleteDataType.  For all other types, returns a null CompleteDataType.
     */
    const CompleteDataType& getElementCompleteType() const {
        return _cdt ? *_cdt : EMPTY_DATATYPE;
    }
 
    /**
     * If this CompleteDataType is a function, return its return type
     */ 
    const CompleteDataType& getReturnType() const {
        return _returnType ? *_returnType : EMPTY_DATATYPE;
    }
 
 
    /**
     * If this CompleteDataType is a function, return its argument schema
     */ 
    const Schema& getArgumentSchema() const {
        return _argumentSchema ? *_argumentSchema : Schema::EMPTY_SCHEMA;
    }
 
    std::string getCaptureTypeName() const {
        return _name;
    }
    
    /**
     * Returns a string representation of this CompleteDataType.
     */
    std::string as_string() const { 
        switch(_type) {
        case DataType::NONE:
        case DataType::BOOL:
        case DataType::INT:
        case DataType::LONG:
        case DataType::DOUBLE:
        case DataType::TIMESTAMP:
        case DataType::STRING:
        case DataType::BLOB:
            return NMSTL::to_string(_type); 
        case DataType::TUPLE:
            return NMSTL::to_string(_type) + " (" + NMSTL::to_string(getSchema()) + ")";
        case DataType::LIST:
            return NMSTL::to_string(_type) + " (" + NMSTL::to_string(getElementCompleteType()) + ")";
        case DataType::CAPTURE:
            return "@" + _name;
        case DataType::FUNCTION:
            assert (_argumentSchema && _returnType);
            return _argumentSchema->as_string() + " -> " + _returnType->as_string();
        }
 
        NMSTL_ASSERT_UNREACHABLE();
    }
    
private:
    static const CompleteDataType EMPTY_DATATYPE;
    static const CompleteDataType BOOL;
    static const CompleteDataType INT;
    static const CompleteDataType LONG;
    static const CompleteDataType DOUBLE;
    static const CompleteDataType TIMESTAMP;
    static const CompleteDataType STRING;
    static const CompleteDataType BLOB;
    DataType _type;
    Schema *_schema;  // schema for tuples
    std::string _name; // name for capture types
    CompleteDataType *_cdt; // CDT for list elements
    Schema *_argumentSchema;
    CompleteDataType *_returnType;
};
 
SB_NAMESPACE_END;
 
#endif /*STREAMBASE_COMPLETEDATATYPE_HPP_*/