metaLoader.h

Go to the documentation of this file.

 
// Copyright (c) 2013-2015 OpenM++
// This code is licensed under the MIT license (see LICENSE.txt for details)
 
#ifndef META_LOADER_H
#define META_LOADER_H
 
#include <algorithm>
using namespace std;
 
#include "libopenm/common/argReader.h"
#include "msg.h"
 
namespace openm
{
    struct RunOptionsKey
    {
        static constexpr const char * subValueCount = "OpenM.SubValues";
 
        static constexpr const char * runName = "OpenM.RunName";
 
        static constexpr const char * runId = "OpenM.RunId";
 
        static constexpr const char * runCreated = "OpenM.RunCreated";
 
        static constexpr const char * restartRunId = "OpenM.RestartRunId";
 
        static constexpr const char * setId = "OpenM.SetId";
 
        static constexpr const char * setName = "OpenM.SetName";
 
        static constexpr const char * baseRunName = "OpenM.BaseRunName";
 
        static constexpr const char * baseRunId = "OpenM.BaseRunId";
 
        static constexpr const char * baseRunDigest = "OpenM.BaseRunDigest";
 
        static constexpr const char * taskId = "OpenM.TaskId";
 
        static constexpr const char * taskName = "OpenM.TaskName";
 
        static constexpr const char * taskRunName = "OpenM.TaskRunName";
 
        static constexpr const char * taskRunId = "OpenM.TaskRunId";
 
        static constexpr const char * taskWait = "OpenM.TaskWait";
 
        static constexpr const char * profile = "OpenM.Profile";
 
        static constexpr const char * threadCount = "OpenM.Threads";
 
        static constexpr const char * notOnRoot = "OpenM.NotOnRoot";
 
        static constexpr const char * dbConnStr = "OpenM.Database";
 
        static constexpr const char * useSparse = "OpenM.SparseOutput";
 
        static constexpr const char * sparseNull = "OpenM.SparseNullValue";
 
        static constexpr const char * doubleFormat = "OpenM.DoubleFormat";
 
        static constexpr const char * paramDir = "OpenM.ParamDir";
 
        static constexpr const char * useIdCsv = "OpenM.IdCsv";
 
        static constexpr const char * useIdParamValue = "OpenM.IdParameterValue";
 
        static constexpr const char * progressPercent = "OpenM.ProgressPercent";
 
        static constexpr const char * progressStep = "OpenM.ProgressStep";
 
        static constexpr const char * parameterPrefix = "Parameter";
 
        static constexpr const char * subFromPrefix = "SubFrom";
 
        static constexpr const char * subValuesPrefix = "SubValues";
 
        static constexpr const char * tableSuppress = "Tables.Suppress";
 
        static constexpr const char * tableRetain = "Tables.Retain";
 
        static constexpr const char * microdataToDb = "Microdata.ToDb";
 
        static constexpr const char * microdataToCsv = "Microdata.ToCsv";
 
        static constexpr const char * microdataToTrace = "Microdata.ToTrace";
 
        static constexpr const char * microdataCsvDir = "Microdata.CsvDir";
 
        static constexpr const char* microdataAll = "Microdata.All";
 
        static constexpr const char * microdataInternal = "Microdata.UseInternal";
 
        static constexpr const char * microdataEvents = "Microdata.Events";
 
        static constexpr const char * microdataEventColumn = "Microdata.CsvEventColumn";
 
        static constexpr const char* microdataPrefix = "Microdata";
 
        // static constexpr const char* microdataFilterPrefix = "MicrodataFilter";
 
        static constexpr const char * importAll = "Import.All";
 
        static constexpr const char * importPrefix = "Import";
 
        static constexpr const char * importRunDigestPrefix = "ImportRunDigest";
 
        static constexpr const char * importRunIdPrefix = "ImportRunId";
 
        static constexpr const char * importRunNamePrefix = "ImportRunName";
 
        static constexpr const char * importModelDigestPrefix = "ImportModelDigest";
 
        static constexpr const char * importModelIdPrefix = "ImportModelId";
 
        static constexpr const char * importExprPrefix = "ImportExpr";
 
        static constexpr const char * importDbPrefix = "ImportDb";
 
        static constexpr const char * runDescrSuffix = "RunDescription";
 
        static constexpr const char * runNotePathSuffix = "RunNotesPath";
 
        static constexpr const char * traceToConsole = "OpenM.TraceToConsole";
 
        static constexpr const char * traceToFile = "OpenM.TraceToFile";
 
        static constexpr const char * traceFilePath = "OpenM.TraceFilePath";
 
        static constexpr const char * traceToStamped = "OpenM.TraceToStampedFile";
 
        static constexpr const char * traceUseTs = "OpenM.TraceUseTimeStamp";
 
        static constexpr const char * traceUsePid = "OpenM.TraceUsePidStamp";
 
        static constexpr const char * traceNoMsgTime = "OpenM.TraceNoMsgTime";
                                       
        static constexpr const char * traceRank = "OpenM.TraceRank";
 
        static constexpr const char * logRank = "OpenM.LogRank";
 
        static constexpr const char * messageLang = "OpenM.MessageLanguage";
        
        static constexpr const char * dbSubValue = "db";
 
        static constexpr const char * iotaSubValue = "iota";
 
        static constexpr const char * csvSubValue = "csv";
 
        static constexpr const char * defaultValue = "default";
 
        static constexpr const char * allValue = "All";
    };
 
    struct RunShortKey
    {
        static constexpr const char * iniFile = "ini";
 
        static constexpr const char * setName = "s";
 
        static constexpr const char * paramDir = "p";
    };
 
    class MetaLoader
    {
    public:
        virtual ~MetaLoader(void) noexcept = 0;
 
        int subValueCount;
 
        int threadCount;
 
        const ArgReader & argOpts(void) const { return argStore; }
 
        const MetaHolder * meta(void) const { return metaStore.get(); }
 
        const RunOptions modelRunOptions(int i_subCount, int i_subId) const;
 
        static const ArgReader getRunOptions(int argc, char ** argv);
 
        int parameterSubCount(int i_paramId) const
        {
            return binary_search(paramIdSubArr.cbegin(), paramIdSubArr.cend(), i_paramId) ? subValueCount : 1;
        }
 
        int parameterIdByName(const char * i_name) const;
 
        int tableIdByName(const char * i_name) const;
 
        bool isSuppressed(const char * i_name) const { return isSuppressed(tableIdByName(i_name)); }
 
        bool isSuppressed(int i_tableId) const
        {
            return binary_search(tableIdSuppressArr.cbegin(), tableIdSuppressArr.cend(), i_tableId);
        }
 
    protected:
        int modelId;                        // model id in database
        unique_ptr<MetaHolder> metaStore;   // metadata tables
        vector<int> paramIdSubArr;          // ids of parameters where sub-values count same as model run sub-values count
        vector<int> tableIdSuppressArr;     // id's of tables to suppress from calculation and output
        vector<int> entityIdxArr;           // microdata attributes indices in EntityNameSizeArr
        bool isCsvEventColumn;              // if true then write even names into entity microdata CSV
        vector<bool> entityUseEvents;       // microdata event filter: if this array[event id] is true then use this event
 
        MetaLoader(const ArgReader & i_argStore) :
            subValueCount(0),
            threadCount(1),
            modelId(0),
            isCsvEventColumn(false),
            argStore(i_argStore)
        { }
 
        const RunOptions & modelRunOptions(void) const { return baseRunOpts; }
 
        void setRunOptions(const RunOptions & i_opts) { baseRunOpts = i_opts; }
 
        // read metadata tables from db, except of run_option table
        static int readMetaTables(IDbExec * i_dbExec, MetaHolder * io_metaStore, const char * i_name, const char * i_digest);
 
        void loadMessages(IDbExec * i_dbExec);
 
        void mergeOptions(IDbExec * i_dbExec);
 
        // enum to indicate what kind of sub id's selected: single, default, range or list
        enum class KindSubIds : int
        {
            none = 0,       // SubValues option not defined
            single = 1,     // single sub id
            defaultId = 2,  // "default" single sub id
            range =3,       // range of sub id's [first id, last id]
            list = 4        // list of sub id's
        };
 
        // enum to indicate where to get sub-values of input parameter: database input workset, csv file or generate iota
        enum class FromSub : int
        {
            defaultValue = 0,   // SubFrom option not defined
            db = 1,             // sub values from database input workset
            csv = 2,            // sub values from csv file
            iota = 3            // generate iota sub values
        };
 
        // parameter sub-values options:
        // SubFrom:   get sub-values from "db", "iota" or "csv"
        // SubValues: can be list of id's: 1,2,3,4 or range: [1,4] or mask: x0F or single id: 7 or default id: "default"
        struct ParamSubOpts
        {
            int subCount = 1;                       // number of sub-values
            KindSubIds kind = KindSubIds::none;     // is it a single sub id, range or list of id's
            vector<int> subIds;                     // list of sub id's to use, if not default id
            FromSub from = FromSub::defaultValue;   // get sub-values from: "db", "iota" or "csv"
        };
 
        map<int, ParamSubOpts> subOptsMap;  // map parameter id to sub-values options
 
        // enum to indicate how to find source model run for import
        enum class ImportKind : int
        {
            none = 0,           // no import
            modelName = 1,      // use model name: last run id of model with that name
            modelId = 2,        // use model id: last run id of that model id
            modelDigest = 3,    // use model digest: last run id of that model digest
            runName = 4,        // use run name: last run id with that name
            runId = 5,          // use run id
            runDigest = 6       // use run digest
        };
 
        // import options for each model run
        struct ImportOpts {
            ImportKind kind = ImportKind::none;
            int modelId = 0;        // source model id
            string modelDigest;     // source model digest
            int runId = 0;          // source run id
            string runName;         // source run name
            string runDigest;       // source run digest
            string connectionStr;   // if not empty then db connection string
        };
        map<string, ImportOpts> importOptsMap;  // import options for each model name
 
        // import source for each model run: run id and digest, model id and digest
        struct RunImportOpts {
            int runId = 0;                  // source run id
            string runDigest;               // source run digest
            int modelId = 0;                // source model id
            string modelDigest;             // source model digest
            unique_ptr<MetaHolder> meta;    // metadata rows: source model, parameters and output tables to import from
            unique_ptr<IDbExec> dbExec;     // database connection, if null then use "main" database connection
        };
 
        // import options for parameter
        struct ParamImportOpts {
            string expr;    // output table expression name to import as parameter value
        };
        map<int, ParamImportOpts> paramImportOptsMap;   // parameter id mapped to import options
 
        // model run language-specific options: map language id to run description and notes
        map<int, pair<string, string> > langOptsMap;
 
    private:
        RunOptions baseRunOpts;     // basic model run options
        ArgReader argStore;         // arguments as key-value string pairs with case-neutral search
 
        // merge parameter name arguments with profile_option table, ie "Parameter.Age" or "SubValues.Age" argument
        void mergeParameterProfile(
            const string & i_profileName, const char * i_prefix, const IProfileOptionTable * i_profileOpt, const vector<ParamDicRow> & i_paramRs
        );
 
        void parseParamSubOpts(void);
 
        void parseImportOptions(void);
 
        void parseSuppressOptions(void);
 
        void parseLangOptions(void);
 
        void parseEntityOptions(void);
 
        tuple<bool, string, const EntityDicRow *> parseEntityNameOption(const string & i_key, const string & i_metadataPrefix) const;
 
    private:
        MetaLoader(const MetaLoader & i_metaLoader) = delete;
        MetaLoader & operator=(const MetaLoader & i_metaLoader) = delete;
    };
}
 
#endif  // META_LOADER_H