DataType.hpp

// Copyright (c) 2004-2023 TIBCO Software Inc.  All rights reserved.
 
#ifndef STREAMBASE_DATA_TYPE_H
#define STREAMBASE_DATA_TYPE_H
 
#include "StreamBase.hpp"
#include <string>
 
#include "Exceptions.hpp"
 
SB_NAMESPACE_BEGIN;
 
/// A type of data in a tuple.  Valid values are
///
/// - DataType::NONE (sentinel "null" value)
/// - DataType::INT
/// - DataType::DOUBLE
/// - DataType::STRING
/// - DataType::TIMESTAMP
/// - DataType::BOOL
/// - DataType::LONG
/// - DataType::BLOB
/// - DataType::TUPLE
/// - DataType::LIST
/// - DataType::CAPTURE
/// - DataType::FUNCTION
///
 
class DataType {
  public:
#ifndef DOXYGEN_INTERNAL_ONLY
    enum Rep {
        NONE = 0,
        INT = 7,
        DOUBLE = 8,
        STRING = 10,
        TIMESTAMP = 11,
        BOOL = 12,
        LONG = 13,
        BLOB = 14,
        TUPLE = 15,
        LIST = 16,
        CAPTURE = 17,
        FUNCTION = 18
        // No, we don't know why 1-6 and 9 are skipped.  These are all left over
        // from Aurora, so we assume historical reasons.  Just keep incrementing.
    };
#endif
 
    /// Construct a DataType equal to DataType::NONE.
    DataType() : _type(NONE) {}
 
#ifndef DOXYGEN_SKIP
    /// Implicit constructor
    DataType(Rep type) : _type(type) {}
 
    operator int() const { return _type; }
#endif
 
    /// Return a string representation of the data type.
    std::string as_string() const {
        char buf[24];
 
        sprintf(buf, "unknown[%d]", _type);
        switch(_type) {
            case NONE:      return "none";
            case INT:       return "int";
            case DOUBLE:    return "double";
            case STRING:    return "string";
            case TIMESTAMP: return "timestamp";
            case LONG:      return "long";
            case BOOL:      return "bool";
            case BLOB:      return "blob";
            case TUPLE:     return "tuple";
            case LIST:      return "list";
            case CAPTURE:   return "capture";
            case FUNCTION:  return "function";
            default:        return buf;
            // can't use to_string, since this header is used by external clients also
        }
    }
 
    size_t getSize() const {
        switch(_type) {
            case LONG:
            case TIMESTAMP:
            case DOUBLE:
                return 8;
            case INT:
            case BOOL:
                return 4;
            case BLOB:
            case STRING:
            case TUPLE:
            case LIST:
            case CAPTURE:
            case FUNCTION:
                return (size_t)-1;
            case NONE:
            default:
                SB_Throw(IllegalArgumentException(SB_NEW_MESSAGE_CODE,
                                                  "Unrecognized or invalid data type: " + as_string()));
        }
        return 0;   // To silence compiler warnings
    }
 
    /// Return false if the type is variable-length (e.g., STRING or BLOB)
    static bool isFixedSize(DataType type) { return type.getSize() != (size_t)-1; }
 
  private:
    Rep _type;
};
 
inline bool operator == (const DataType& a, DataType::Rep b) { return a == DataType(b); }
inline bool operator == (DataType::Rep b, const DataType& a) { return a == DataType(b); }
 
 
SB_NAMESPACE_END;
#endif