DataProvider.qc.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
namespace DataProvider {
class DataProvider {
 
public:
        const FactoryMap = {
            "cdsrest": "CdsRestDataProvider",
            "csvread": "CsvUtil",
            "csvwrite": "CsvUtil",
            "db": "DbDataProvider",
            "elasticsearch": "ElasticSearchDataProvider",
            "empathicbuilding": "EmpathicBuildingDataProvider",
            "file": "FileDataProvider",
            "filepoller": "FilePoller",
            "fixedlengthread": "FixedLengthUtil",
            "fixedlengthwrite": "FixedLengthUtil",
            "ftpclient": "FtpClientDataProvider",
            "ftppoller": "FtpPoller",
            "httpclient": "HttpClientDataProvider",
            "restclient": "RestClientDataProvider",
            "salesforcerest": "SalesforceRestDataProvider",
            "sax": "SaxDataProvider",
            "servicenowrest": "ServiceNowRestDataProvider",
            "smtpclient": "SmtpClient",
 
            // provided by the xml module
            "soap": "SoapDataProvider",
 
            "swagger": "SwaggerDataProvider",
            "wsclient": "WebSocketClient",
        };
 
        const TypeMap = {
            "qore/ftp": "FtpPollerUtil",
            "qore/sftp": "SftpPollerUtil",
            "qore/fsevents": "FsEventPollerUtil",
        };
 
        const FactoryModuleList = keys (map {$1: True}, FactoryMap.iterator());
        // "map" is used above to ensure that the values only appear once in the final list
 
protected:
        static hash<string, AbstractDataProviderFactory> factory_cache;
 
        static hash<string, string> factory_module_map;
 
        static Mutex factory_cache_lock();
 
        static DataProviderTypeCache type_cache();
 
        static hash<string, string> type_module_map;
 
 
        static bool allow_env_config = False;
 
        static bool env_config_locked = False;
 
        static hash<string, bool> mod_map;
 
public:
 
 
      static registerFactory(AbstractDataProviderFactory factory);
 
      static *AbstractDataProviderFactory getFactory(string name);
 
 
      static AbstractDataProviderFactory getFactoryEx(string name);
 
 
    static AbstractDataProvider getFactoryObjectWithTemplate(string path, *hash<auto> template_options,
            *hash<auto> options) {
        AbstractDataProvider provider;
        {
            list<string> path_list = path.split("/");
            provider = DataProvider::getFactoryEx(shift path_list).createWithTemplate(template_options, options);
            map provider = provider.getChildProviderEx($1), path_list;
        }
        return provider;
    }
 
 
      static AbstractDataProvider getFactoryObjectFromExample(string path, data example, *hash<auto> options);
 
 
      static AbstractDataProvider getFactoryObjectFromExample(string path, InputStream example, *hash<auto> options);
 
 
      static AbstractDataProvider getFactoryObject(string path, *hash<auto> options);
 
 
      static AbstractDataProvider getFactoryObjectFromString(string name);
 
 
      static AbstractDataProvider getFactoryObjectFromStringUseEnv(string name);
 
protected:
      static hash<FactoryInfo> getFactoryInfoFromString(string name);
public:
 
 
      static *list<string> listFactories();
 
      static DataProviderTypeCache getTypeCache();
 
 
      static registerType(string path, AbstractDataProviderType type);
 
 
      static *AbstractDataProviderType getType(string path);
 
 
      static AbstractDataProviderType getTypeEx(string path);
 
      static DataProviderTypeEntry getTypeRoot();
 
      static lockAllTypes();
 
 
      static *list<string> listTypes();
 
      static registerKnownFactories();
 
      static loadProvidersFromEnvironment();
 
      static *AbstractDataProvider tryLoadProviderForConnectionFromEnv(string name);
 
      static registerKnownTypes();
 
      static loadTypesFromEnvironment();
 
 
      static hash<auto> getInfoAsData(hash<auto> info0, *bool with_type_info);
 
 
      static setAutoConfig();
 
      static bool getAutoConfig();
 
      static list<string> getPathList(string path);
 
protected:
      static checkRequest();
public:
 
 
protected:
      static *string tryGetFactoryModuleName(string name);
public:
 
 
protected:
      static *string tryGetTypeModuleName(string name);
public:
 
 
protected:
      static *string tryGetModuleName(string name, string func, string type);
public:
 
 
protected:
      static *DataProviderTypeEntry tryLoadTypeFromPath(list<string> type_path);
public:
 
 
protected:
      static bool tryLoad(string module_str, *bool verbose);
public:
 
 
protected:
      static *object loadFromEnvironment(string func, string type, *hash<SymbolInfo> info);
public:
 
 
protected:
      static *object checkSymbol(hash<SymbolInfo> info);
public:
 
 
protected:
      static bool checkInjection(object obj, hash<string, string> module_map);
public:
 
};
 
// private hashdecls
hashdecl SymbolInfo {
    // symbol type
    string type;
    # symbol name
    string name;
}
hashdecl FactoryInfo {
    // factory name
    string name;
    # path to final data provider in factory
    list<string> path_list;
    # factory options
    auto options;
}
};