AbstractDataProviderType.qc.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
namespace DataProvider {
const TypeCodeMap = {
    NT_INT: "int",
    NT_STRING: "string",
    NT_BOOLEAN: "bool",
    NT_FLOAT: "float",
    NT_NUMBER: "number",
    NT_BINARY: "binary",
    NT_LIST: "list",
    NT_HASH: "hash",
    NT_OBJECT: "object",
    NT_ALL: "any",
    NT_DATE: "date",
    NT_NULL: "null",
    NT_NOTHING: "nothing",
};
 
 
const OptimalQoreDataTypeMap = {
    "int": "int",
    Type::Int: "int",
    Type::String: "string",
    "boolean": "bool",
    Type::Boolean: "bool",
    "double": "float",
    Type::Float: "float",
    Type::Number: "number",
    Type::Binary: "binary",
    Type::List: "list<auto>",
    Type::Hash: "hash<auto>",
    Type::Object: "object",
    Type::Date: "date",
    Type::NullType: "null",
    Type::NothingType: "nothing",
    "all": "any",
};
 
 
const OptimalQoreSoftDataTypeMap = OptimalQoreDataTypeMap + {
    "int": "softint",
    Type::Int: "softint",
    Type::String: "softstring",
    "boolean": "softbool",
    Type::Boolean: "softbool",
    "double": "softfloat",
    Type::Float: "softfloat",
    Type::Number: "softnumber",
    Type::List: "softlist<auto>",
    Type::Date: "softdate",
};
 
const DataTypeMap = {
    "int": IntType,
    Type::Int: IntType,
    Type::String: StringType,
    "boolean": BoolType,
    Type::Boolean: BoolType,
    "double": FloatType,
    Type::Float: FloatType,
    Type::Number: NumberType,
    Type::Binary: BinaryType,
    Type::List: AutoListType,
    Type::Hash: AutoHashType,
    Type::Object: ObjectType,
    Type::Date: DateType,
    Type::NullType: Reflection::NullType,
    Type::NothingType: AbstractDataProviderType::nothingType,
    "base64binary": Base64BinaryType,
    "hexbinary": HexBinaryType,
    "data": DataType,
 
    "softint": SoftIntType,
    "softstring": SoftStringType,
    "softbool": SoftBoolType,
    "softfloat": SoftFloatType,
    "softnumber": SoftNumberType,
    "softdate": SoftDateType,
 
    "*softint": SoftIntOrNothingType,
    "*softstring": SoftStringOrNothingType,
    "*softbool": SoftBoolOrNothingType,
    "*softfloat": SoftFloatOrNothingType,
    "*softnumber": SoftNumberOrNothingType,
    "*softdate": SoftDateOrNothingType,
 
    "all": AbstractDataProviderType::anyType,
    "any": AbstractDataProviderType::anyType,
    "auto": AbstractDataProviderType::anyType,
 
    "*int": IntOrNothingType,
    "*integer": IntOrNothingType,
    "*string": StringOrNothingType,
    "*boolean": BoolOrNothingType,
    "*bool": BoolOrNothingType,
    "*double": FloatOrNothingType,
    "*float": FloatOrNothingType,
    "*number": NumberOrNothingType,
    "*binary": BinaryOrNothingType,
    "*list": AutoListOrNothingType,
    "*hash": AutoHashOrNothingType,
    "*object": ObjectOrNothingType,
    "*date": DateOrNothingType,
    "*data": DataOrNothingType,
    "*hexbinary": HexBinaryOrNothingType,
};
 
const AbstractDataProviderTypeMap = ...;
 
 
public hashdecl DataProviderTypeOptionInfo {
    string type;
 
    string desc;
};
 
public hashdecl DataTypeInfo {
    string name;
 
    string desc;
 
    *hash<string, hash<DataProviderTypeOptionInfo>> supported_options;
 
    *hash<auto> options;
 
    string base_type;
 
    bool mandatory;
 
    list<string> types_accepted;
 
    list<string> types_returned;
 
    hash<string, hash<DataFieldInfo>> fields;
 
    bool can_manage_fields = False;
 
    *hash<DataTypeInfo> default_field_type_info;
 
    *hash<auto> tags;
};
 
const DTT_FromFile = "from_file";
 
const DTT_FromLocation = "from_location";
 
const DTT_ClientOnly = "client_only";
 
class AbstractDataProviderType : public Qore::Serializable {
 
public:
        static Type nothingType = Reflection::NothingType;
        static Type anyType = Reflection::AutoType;
        // not initialized here to workaround issue #4048 (circular initializtion error)
        static AbstractDataProviderType anyDataType;
 
        const DefaultDesc = "no description available";
 
protected:
        hash<auto> options;
 
        *hash<auto> tags;
 
public:
 
    constructor();
 
 
 
    constructor(hash<auto> options, *hash<auto> tags);
 
 
    string getDesc();
 
 
    *hash<string, hash<DataProviderTypeOptionInfo>> getSupportedOptions();
 
 
 
    hash<DataTypeInfo> getInputInfo();
 
 
    hash<DataTypeInfo> getInfo();
 
 
    *hash<string, hash<DataFieldInfo>> getFieldInfo();
 
 
    bool isAssignableFrom(AbstractDataProviderType t);
 
 
    bool isAssignableFrom(Type t);
 
 
    bool isList();
 
 
    bool isMandatory();
 
 
    *AbstractDataField getField(string field_name);
 
 
    bool hasType();
 
 
    string getBaseTypeName();
 
 
    int getBaseTypeCode();
 
 
    *hash<string, bool> getDirectTypeHash();
 
 
    bool isOrNothingType();
 
 
    *AbstractDataProviderType getFieldType(string field_name);
 
 
    auto getOptionValue(string opt);
 
 
    *hash<auto> getOptions();
 
 
 
    setOption(string opt, auto value);
 
 
 
    setOptions(hash<auto> options);
 
 
    auto getTag(string tag);
 
 
    *hash<auto> getTags();
 
 
 
    AbstractDataProviderType getSoftType();
 
 
 
    AbstractDataProviderType getOrNothingType();
 
 
    abstract string getName();
 
    abstract *Type getValueType();
 
    abstract *AbstractDataProviderType getElementType();
 
    abstract *hash<string, AbstractDataField> getFields();
 
    abstract hash<string, bool> getAcceptTypeHash();
 
    abstract hash<string, bool> getReturnTypeHash();
 
 
    abstract auto acceptsValue(auto value);
 
      static AbstractDataProviderType get(Type type, *hash<auto> options, *hash<auto> tags);
 
 
      static AbstractDataProviderType get(string typename, *hash<auto> options);
 
protected:
     setOptionIntern(string opt, auto value);
public:
 
};
};