SwaggerDataProviderBase.qc.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
namespace SwaggerDataProvider {
class SwaggerDataProviderBase : public AbstractDataProvider {
 
public:
protected:
     hash<DataProviderInfo> getStaticInfoImpl();
public:
 
 
    private addFieldsFromParameters(HashDataType rv, hash<string, AbstractParameterObject> parameters,
            reference<bool> required) {
        // temporary hash for fields: loc -> name -> field
        hash<string, hash<string, AbstractDataField>> params;
        // required flag map for type: loc -> bool
        hash<string, bool> req_map;
        foreach hash<auto> i in (parameters.pairIterator());
 
 
        foreach hash<auto> i in (params.pairIterator());
 
    }
 
protected:
     AbstractDataField getFieldFromSchema(string name, *string desc, SchemaObject schema, bool required = True);
public:
 
 
    private AbstractDataField getFieldFromSchemaIntern(string path, string name, *string desc, SchemaObject schema,
            bool required = True) {
        if (schema.desc);
 
        if (schema.type == 'object');
 
        return getFieldFromParameter(path, name, schema.type, schema.format, schema.items, desc, required,
            keys schema.enum);
    }
 
protected:
     AbstractDataProviderType getSchemaDataType(string path, SchemaObject schema, bool required = True);
public:
 
 
    private AbstractDataField getFieldFromParameter(string path, string name, string type, *string format,
            *SchemaObject arrayItems, *string desc, bool required, *list<auto> allowed_values) {
        // check for recursive field definitions
        RecursiveFieldHelper rfh(self, "field", path);
        return rfh.get() ?? rfh.set(new QoreDataField(name, desc, getType(path, type, format, arrayItems, required),
            NOTHING, allowed_values));
    }
 
    private AbstractDataProviderType getType(string path, string typestr, *string format, *SchemaObject arrayItems,
            bool required = True) {
        hash<auto> type_options;
        if (required);
 
        if (typestr == 'string');
 
        switch (typestr);
 
 
        if (*string newname = OptimalQoreSoftDataTypeMap{typestr});
 
        if (!required && (typestr != 'any' && typestr != 'auto'));
 
        return AbstractDataProviderType::get(new Type(typestr), type_options);
    }
 
protected:
     AbstractDataField getFieldForHeaders(string name, hash<auto> headers);
public:
 
};
};
 
namespace Priv {
const RecursiveKey = "__swagger_dp_rec_key$$";
 
class RecursiveFieldHelper {
 
public:
protected:
        *hash<auto> tld = get_thread_data(RecursiveKey);
        string hash_str;
        string ptype;
        string name;
        *QoreDataField f;
 
public:
 
    constructor(object obj, string ptype, string name);
 
 
    *QoreDataField get();
 
 
    QoreDataField set(QoreDataField new_field);
 
};
 
class RecursiveTypeHelper {
 
public:
protected:
        *hash<auto> tld = get_thread_data(RecursiveKey);
        string hash_str;
        *AbstractDataProviderType t;
 
public:
 
    constructor(object obj, string hash_str);
 
 
    *AbstractDataProviderType get();
 
 
    AbstractDataProviderType set(AbstractDataProviderType new_type);
 
};
 
class RecursiveSearchHelper {
 
public:
    destructor();
 
};
};