GoogleDataProviderBase.qc.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
namespace GoogleDataProvider {
class GoogleDataProviderBase : public DataProvider::AbstractDataProvider {
 
public:
        const DiscoveryUrlBase = "https://discovery.googleapis.com/discovery/v1/apis";
 
        const InitTimeout = 10s;
 
protected:
        *RestClient::RestClient rest;
 
        static hash<string, string> api_map;
 
        static hash<string, hash<auto>> info_map;
 
        static hash<string, hash<string, AbstractDataProviderType>> input_schema_map;
 
        static hash<string, hash<string, AbstractDataProviderType>> output_schema_map;
 
        //   {request_type -> type, response_type -> type, http_method -> string, path -> string}
        static hash<string, hash<auto>> request_map;
 
        static Mutex m();
 
public:
 
    constructor();
 
 
    constructor(RestClient::RestClient rest);
 
 
    setLogger(*LoggerInterface logger);
 
 
 
    *hash<auto> prepareRequest(auto req, *hash<string, softstring> implicit_path_args, *bool backfill_request_body);
 
 
 
    updateConnectionObjects(object conn, object connobj);
 
 
    setRestClient(RestClient rest);
 
 
    RestClient getRestClient();
 
 
protected:
     bool needsBackfillRequestBody();
public:
 
 
 
    *hash<auto> prepareRequestIntern(AbstractDataProviderType request_type, auto req0, *hash<string, softstring> implicit_path_args, *bool backfill_request_body);
 
 
    string getQueryValue(string key, AbstractDataProviderType type, auto val);
 
 
      static string cap(string word);
 
protected:
     hash<auto> backfillRequestBody(auto req);
public:
 
 
      static RestClient::RestClient getRestConnection(*hash<auto> options);
 
      static hash<auto> getRequestInfoForResource(string api, string resource);
 
      static string getPathForSchema(string api, string resource);
 
      static string getMethodForSchema(string api, string path);
 
      static DataProvider::AbstractDataProviderType getResponseTypeForSchema(string api, string resource);
 
      static DataProvider::AbstractDataProviderType getRequestTypeForSchema(string api, string resource, ...);
 
      static checkResource(string api, list<string> resource_path);
 
      static *hash<string, bool> getMethodsForResource(string api, list<string> resource_path, *hash<auto> path_args);
 
      static DataProvider::AbstractDataProviderType getRequestTypeForSchemaArgs(string api, string path, *list<auto> args);
 
      static DataProvider::AbstractDataProviderType getTypeForSchema(string api, string schema);
 
      static DataProvider::AbstractDataProviderType getInputTypeForSchema(string api, string schema);
 
      static hash<auto> getRequestInfo(string api);
 
protected:
      static hash<auto> processRequests(string api, hash<auto> h, TypeResolverHelper unresolved);
public:
 
 
      static hash<auto> processRequest(string key, hash<auto> info, TypeResolverHelper unresolved);
 
      static hash<string, AbstractDataProviderType> getApi(string api);
 
      static hash<string, AbstractDataProviderType> getInputSchemasForApi(string api);
 
      static hash<string, AbstractDataProviderType> getInputSchemaMap(string api, hash<auto> api_info);
 
      static hash<string, AbstractDataProviderType> getOutputSchemaMap(string api, hash<auto> api_info);
 
      static hash<auto> getSchemaInfo(string api);
 
protected:
      static AbstractDataProviderType makeTypeFromSchemaInfo(HashDataType type, hash<auto> info, TypeResolverHelper unresolved, *bool for_input);
public:
 
 
protected:
      static AbstractDataProviderType makeTypeFromSchemaInfo(ListDataType type, string key, hash<auto> info, TypeResolverHelper unresolved, *bool for_input);
public:
 
 
protected:
      static AbstractDataProviderType makeTypeFromSchemaInfo(QoreDataField field, hash<auto> info, TypeResolverHelper unresolved, *bool for_input);
public:
 
 
protected:
      static AbstractDataProviderType makeTypeFromSchemaInfo(string key, hash<auto> info, TypeResolverHelper unresolved, *bool for_input);
public:
 
 
      static ListDataType makeListFromSchemaInfo(string key, hash<auto> info, TypeResolverHelper unresolved, *bool for_input);
 
      static HashDataType makeHashFromSchemaInfo(string key, hash<auto> info, TypeResolverHelper unresolved, *bool for_input);
 
      static QoreDataField makeFieldFromProperty(HashDataType h, string key, hash<auto> info, TypeResolverHelper unresolved, *bool for_input);
 
      static string getUrlForApi(string api, RestClient::RestClient rest);
};
};
 
namespace Priv {
class TypeResolverHelper {
 
public:
    
 
protected:
        list<hash<auto>> lists;
 
        list<hash<auto>> hashes;
 
        list<hash<auto>> fields;
 
        list<hash<auto>> requests;
 
        list<hash<auto>> responses;
 
public:
 
    addRequestTypeReference(string key, string ref, *bool required);
 
 
    addResponseTypeReference(string key, string ref, *bool required);
 
 
    AbstractDataProviderType addReference(HashDataType type, string ref, *bool required);
 
 
    AbstractDataProviderType addReference(ListDataType type, string ref);
 
 
    AbstractDataProviderType addReference(QoreDataField field, string ref);
 
 
    resolve(hash<string, AbstractDataProviderType> schemas);
 
 
    hash<auto> resolveRequests(string api, hash<auto> req, hash<string, hash<string, AbstractDataProviderType>> input_schema_map, hash<string, hash<string, AbstractDataProviderType>> output_schema_map);
 
 
      static AbstractDataProviderType getType(string ref, hash<string, AbstractDataProviderType> schemas, *bool required);
};
};