DataProvider.qc.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
namespace DataProvider {
 
const DPO_EnableServers                  = (1 << 0);
 
 
const DPO_DisableOnDemandInitialization  = (1 << 1);
 
const DPO_AllOptions = ...;
 
 
class DataProvider {
 
public:
        const FactoryMap = ...;
 
 
        const TypeMap = ...;
 
 
        const FactoryModuleList = keys (map {$1: True}, FactoryMap.iterator());
        // "map" is used above to ensure that the values only appear once in the final list
 
        const NoApp = "$NO_APP";
 
protected:
        static hash<string, AbstractDataProviderFactory> factory_cache;
 
        static hash<string, string> factory_module_map;
 
        static Gate 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;
 
        static list<code> ilist;
 
        static list<*list<code>> ilist_save;
 
        static hash<string, code> smap;
 
        static int options = 0;
 
        static *LoggerInterface logger;
 
public:
 
 
      static setGlobalLogger(*LoggerInterface logger);
 
 
      static *LoggerInterface getGlobalLogger();
 
 
      static addOptions(int options);
 
 
      static removeOptions(int options);
 
 
      static int getOptions();
 
 
      static setOptions(int options);
 
 
      static checkOptions(int options);
 
 
      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);
 
 
      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(*LoggerInterface logger);
 
      static *AbstractDataProvider tryLoadProviderForConnectionFromEnv(string name, *string subtype, *LoggerInterface logger);
 
      static registerKnownTypes();
 
      static loadTypesFromEnvironment(*LoggerInterface logger);
 
 
      static hash<auto> getInfoAsData(hash<auto> info0, *bool with_type_info);
 
 
      static setAutoConfig();
 
      static bool getAutoConfig();
 
      static list<string> getPathList(string path);
 
      static list<string> getPathList(reference<string> path);
 
 
      static registerStaticInitializer(code init);
 
 
      static checkStaticInit();
 
 
      static deferStaticInitialization();
 
 
      static restoreStaticInitialization();
 
protected:
      synchronized static checkStaticInitIntern();
public:
 
 
 
      static shutdown();
 
 
      static registerShutdownHandler(string key, code handler);
 
 
      static bool deregisterShutdownHandler(string key);
 
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 init);
public:
 
 
protected:
      static *object loadFromEnvironment(string func, string type, *hash<SymbolInfo> info, *LoggerInterface logger);
public:
 
 
protected:
      static *object checkSymbol(hash<SymbolInfo> info, *LoggerInterface logger);
public:
 
 
protected:
      static bool checkInjection(object obj, hash<string, string> module_map);
public:
 
 
protected:
      static deregisterFactory(string name);
public:
 
};
 
// private hashdecls
hashdecl SymbolInfo {
    // symbol type
    string type;
    // symbol name
    string name;
    // subtype, if any
    *string subtype;
}
hashdecl FactoryInfo {
    // factory name
    string name;
    // path to final data provider in factory
    list<string> path_list;
    // factory options
    auto options;
}
}