AbstractDataProviderType.qc.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
// assume local scope for variables, do not use "$" signs
// require type definitions everywhere
// enable all warnings
 
 
namespace DataProvider {
const TypeCodeMap = ...;
 
 
 
const OptimalQoreDataTypeMap = ...;
 
 
 
const OptimalQoreSoftDataTypeMap = ...;
 
 
const DataTypeMap = ...;
 
 
public struct DataProviderTypeOptionInfo {
    string type;
 
    string desc;
};
 
public struct DataTypeInfo {
    string name;
 
    *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;
};
 
class AbstractDataProviderType : public Serializable {
 
public:
        static Type nothingType("nothing");
        static Type anyType("auto");
 
protected:
        hash<auto> options;
 
public:
 
    constructor();
 
 
 
    constructor(hash<auto> options);
 
 
    *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);
 
 
 
    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);
 
 
      static AbstractDataProviderType get(string typename, *hash<auto> options);
 
protected:
     setOptionIntern(string opt, auto value);
public:
 
};
};