ConfigurationManager.cc

#include "otsdaq/ConfigurationInterface/ConfigurationManager.h"
#include "artdaq/Application/LoadParameterSet.hh"
#include "otsdaq/ConfigurationInterface/ConfigurationInterface.h"  //All configurable objects are included here
#include "otsdaq/ProgressBar/ProgressBar.h"
#include "otsdaq/TablePlugins/XDAQContextTable/XDAQContextTable.h"
 
#include <dirent.h>  // DIR and dirent
#include <fstream>   // std::ofstream
#include <sstream>   // std::istringstream
 
#include "otsdaq/TableCore/TableGroupKey.h"
#include "otsdaq/TablePlugins/DesktopIconTable.h"  //for dynamic desktop icon change
 
using namespace ots;
 
#undef __MF_SUBJECT__
#define __MF_SUBJECT__ "ConfigurationManager"
 
// clang-format off
 
const unsigned int      ConfigurationManager::PROCESSOR_COUNT                       = std::thread::hardware_concurrency();
 
const std::string       ConfigurationManager::LAST_TABLE_GROUP_SAVE_PATH            = ((getenv("SERVICE_DATA_PATH") == NULL)
                                                                                        ? (std::string(__ENV__("USER_DATA")) + "/ServiceData")
                                                                                        : (std::string(__ENV__("SERVICE_DATA_PATH")))) +
                                                                                        "/RunControlData/";
 
const std::string       ConfigurationManager::LAST_ACTIVATED_CONFIG_GROUP_FILE      = "CFGLastActivatedConfigGroup.hist";
const std::string       ConfigurationManager::LAST_ACTIVATED_CONTEXT_GROUP_FILE     = "CFGLastActivatedContextGroup.hist";
const std::string       ConfigurationManager::LAST_ACTIVATED_BACKBONE_GROUP_FILE    = "CFGLastActivatedBackboneGroup.hist";
const std::string       ConfigurationManager::LAST_ACTIVATED_ITERATE_GROUP_FILE     = "CFGLastActivatedIterateGroup.hist";
 
const std::string       ConfigurationManager::ACTIVATED_CONFIGS_FILE                = "CFGActivatedConfigGroups.hist";
const std::string       ConfigurationManager::ACTIVATED_CONTEXTS_FILE               = "CFGActivatedContextGroups.hist";
const std::string       ConfigurationManager::ACTIVATED_BACKBONES_FILE              = "CFGActivatedBackboneGroups.hist";
const std::string       ConfigurationManager::ACTIVATED_ITERATES_FILE               = "CFGActivatedIterateGroups.hist";
 
const std::string       ConfigurationManager::LAST_ATTEMPTED_CONFIGURE_CONFIG_ALIAS_FILE    = "CFGAttemptedConfigureConfigAlias.hist";
const std::string       ConfigurationManager::LAST_ATTEMPTED_CONFIGURE_CONFIG_GROUP_FILE    = "CFGAttemptedConfigureConfigGroup.hist";
 
const std::string       ConfigurationManager::ATTEMPTED_CONFIGURE_CONFIG_ALIASES_FILE       = "CFGAttemptedConfigureConfigAliases.hist";
const std::string       ConfigurationManager::ATTEMPTED_CONFIGURE_CONFIGS_FILE              = "CFGAttemptedConfigureConfigGroups.hist";
 
const std::string       ConfigurationManager::LAST_CONFIGURED_CONFIG_ALIAS_FILE     = "CFGLastConfiguredConfigAlias.hist";
const std::string       ConfigurationManager::LAST_CONFIGURED_CONFIG_GROUP_FILE     = "CFGLastConfiguredConfigGroup.hist";
const std::string       ConfigurationManager::LAST_CONFIGURED_CONTEXT_GROUP_FILE    = "CFGLastConfiguredContextGroup.hist";
const std::string       ConfigurationManager::LAST_CONFIGURED_BACKBONE_GROUP_FILE   = "CFGLastConfiguredBackboneGroup.hist";
const std::string       ConfigurationManager::LAST_CONFIGURED_ITERATE_GROUP_FILE    = "CFGLastConfiguredIterateGroup.hist";
 
const std::string       ConfigurationManager::CONFIGURED_CONFIG_ALIASES_FILE        = "CFGConfiguredConfigAliases.hist";
const std::string       ConfigurationManager::CONFIGURED_CONFIGS_FILE               = "CFGConfiguredConfigGroups.hist";
const std::string       ConfigurationManager::CONFIGURED_CONTEXTS_FILE              = "CFGConfiguredContextGroups.hist";
const std::string       ConfigurationManager::CONFIGURED_BACKBONES_FILE             = "CFGConfiguredBackboneGroups.hist";
const std::string       ConfigurationManager::CONFIGURED_ITERATES_FILE              = "CFGConfiguredIterateGroups.hist";
 
const std::string       ConfigurationManager::LAST_STARTED_CONFIG_ALIAS_FILE        = "CFGLastStartedConfigAlias.hist";
const std::string       ConfigurationManager::LAST_STARTED_CONFIG_GROUP_FILE        = "CFGLastStartedConfigGroup.hist";
const std::string       ConfigurationManager::LAST_STARTED_CONTEXT_GROUP_FILE       = "CFGLastStartedContextGroup.hist";
const std::string       ConfigurationManager::LAST_STARTED_BACKBONE_GROUP_FILE      = "CFGLastStartedBackboneGroup.hist";
const std::string       ConfigurationManager::LAST_STARTED_ITERATE_GROUP_FILE       = "CFGLastStartedIterateGroup.hist";
 
const std::string       ConfigurationManager::STARTED_CONFIG_ALIASES_FILE           = "CFGStartedConfigAliases.hist";
const std::string       ConfigurationManager::STARTED_CONFIGS_FILE                  = "CFGStartedConfigGroups.hist";
const std::string       ConfigurationManager::STARTED_CONTEXTS_FILE                 = "CFGStartedContextGroups.hist";
const std::string       ConfigurationManager::STARTED_BACKBONES_FILE                = "CFGStartedBackboneGroups.hist";
const std::string       ConfigurationManager::STARTED_ITERATES_FILE                 = "CFGStartedIterateGroups.hist";
 
const std::string       ConfigurationManager::CONFIGURED_OR_STARTED_CONFIG_ALIASES_FILE     = "CFGConfiguredOrStartedConfigAliases.hist";
const std::string       ConfigurationManager::CONFIGURED_OR_STARTED_CONFIGS_FILE            = "CFGConfiguredOrStartedConfigGroups.hist";
const std::string       ConfigurationManager::CONFIGURED_OR_STARTED_CONTEXTS_FILE           = "CFGConfiguredOrStartedContextGroups.hist";
const std::string       ConfigurationManager::CONFIGURED_OR_STARTED_BACKBONES_FILE          = "CFGConfiguredOrStartedBackboneGroups.hist";
const std::string       ConfigurationManager::CONFIGURED_OR_STARTED_ITERATES_FILE           = "CFGConfiguredOrStartedIterateGroups.hist";
 
 
const std::string       ConfigurationManager::READONLY_USER                         = "READONLY_USER";
 
const std::string       ConfigurationManager::XDAQ_CONTEXT_TABLE_NAME               = "XDAQContextTable";
const std::string       ConfigurationManager::XDAQ_APPLICATION_TABLE_NAME           = "XDAQApplicationTable";
const std::string       ConfigurationManager::XDAQ_APP_PROPERTY_TABLE_NAME          = "XDAQApplicationPropertyTable";
const std::string       ConfigurationManager::GROUP_ALIASES_TABLE_NAME              = "GroupAliasesTable";
const std::string       ConfigurationManager::VERSION_ALIASES_TABLE_NAME            = "VersionAliasesTable";
const std::string       ConfigurationManager::ARTDAQ_TOP_TABLE_NAME                 = "ARTDAQSupervisorTable";
const std::string       ConfigurationManager::DESKTOP_ICON_TABLE_NAME               = "DesktopIconTable";
 
const std::string       ConfigurationManager::ACTIVE_GROUPS_FILENAME                = ((getenv("SERVICE_DATA_PATH") == NULL)
                                                                                        ? (std::string(__ENV__("USER_DATA")) + "/ServiceData")
                                                                                        : (std::string(__ENV__("SERVICE_DATA_PATH")))) +
                                                                                        "/ActiveTableGroups.cfg";
 
const std::string       ConfigurationManager::ALIAS_VERSION_PREAMBLE                    = "ALIAS:";
const std::string       ConfigurationManager::SCRATCH_VERSION_ALIAS                     = "Scratch";
const std::string       ConfigurationManager::SUBSYSTEM_COMMON_VERSION_ALIAS            = "SubsystemCommon";
const std::string       ConfigurationManager::SUBSYSTEM_COMMON_OVERRIDE_VERSION_ALIAS   = "SubsystemCommonOverride";
 
 
const std::string       ConfigurationManager::GROUP_TYPE_NAME_CONTEXT               = "Context";
const std::string       ConfigurationManager::GROUP_TYPE_NAME_BACKBONE              = "Backbone";
const std::string       ConfigurationManager::GROUP_TYPE_NAME_ITERATE               = "Iterate";
const std::string       ConfigurationManager::GROUP_TYPE_NAME_CONFIGURATION         = "Configuration";
const std::string       ConfigurationManager::GROUP_TYPE_NAME_UNKNOWN               = "UNKNOWN";
 
const std::string       ConfigurationManager::UNKNOWN_INFO                          = "UNKNOWN";
const std::string       ConfigurationManager::UNKNOWN_TIME                          = "0";
 
const uint8_t           ConfigurationManager::METADATA_COL_ALIASES                  = 1;
const uint8_t           ConfigurationManager::METADATA_COL_COMMENT                  = 2;
const uint8_t           ConfigurationManager::METADATA_COL_AUTHOR                   = 3;
const uint8_t           ConfigurationManager::METADATA_COL_TIMESTAMP                = 4;
 
const std::string       ConfigurationManager::CONTEXT_SUBSYSTEM_OPTIONAL_TABLE      = "SubsystemUserDataPathsTable";
 
 
const std::set<std::string> ConfigurationManager::fixedContextMemberNames_          = {
                                                                                        ConfigurationManager::XDAQ_CONTEXT_TABLE_NAME,
                                                                                        ConfigurationManager::XDAQ_APPLICATION_TABLE_NAME,
                                                                                        "XDAQApplicationPropertyTable",
                                                                                        ConfigurationManager::DESKTOP_ICON_TABLE_NAME,
                                                                                        "MessageFacilityTable",
                                                                                        "GatewaySupervisorTable",
                                                                                        "StateMachineTable",
                                                                                        "DesktopWindowParameterTable",
                                                                                        "SlowControlsDashboardSupervisorTable"
                                                                                    };
const std::set<std::string> ConfigurationManager::backboneMemberNames_              = {
                                                                                        ConfigurationManager::GROUP_ALIASES_TABLE_NAME,
                                                                                        ConfigurationManager::VERSION_ALIASES_TABLE_NAME
                                                                                    };
const std::set<std::string> ConfigurationManager::iterateMemberNames_               = {
                                                                                        "IterateTable",
                                                                                        "IterationPlanTable",
                                                                                        "IterationTargetTable",
                                                                                        /*command specific tables*/ "IterationCommandBeginLabelTable",
                                                                                        "IterationCommandChooseFSMTable",
                                                                                        "IterationCommandConfigureAliasTable",
                                                                                        "IterationCommandConfigureGroupTable",
                                                                                        "IterationCommandExecuteFEMacroTable",
                                                                                        "IterationCommandExecuteMacroTable",
                                                                                        "IterationCommandMacroDimensionalLoopTable",
                                                                                        "IterationCommandMacroDimensionalLoopParameterTable",
                                                                                        "IterationCommandModifyGroupTable",
                                                                                        "IterationCommandRepeatLabelTable",
                                                                                        "IterationCommandRunTable"
                                                                                    };
 
// clang-format on
 
//==============================================================================
ConfigurationManager::ConfigurationManager(bool initForWriteAccess /*=false*/,
                                           bool doInitializeFromFhicl /*=false*/,
                                           bool forceNotFirstInContext /*=false*/)
    : startClockTime_(std::chrono::steady_clock::now())
    , deltaClockTime_(std::chrono::steady_clock::now())
    , forceNotFirstInContext_(forceNotFirstInContext)
    , mfSubject_(ConfigurationManager::READONLY_USER)
    , username_(ConfigurationManager::READONLY_USER)
    , theInterface_(0)
    , theConfigurationTableGroupKey_(0)
    , theContextTableGroupKey_(0)
    , theBackboneTableGroupKey_(0)
    , theConfigurationTableGroup_("")
    , theContextTableGroup_("")
    , theBackboneTableGroup_("")
    , groupMetadataTable_(true /*special table*/, TableBase::GROUP_METADATA_TABLE_NAME)
{
    __GEN_COUTTV__(runTimeSeconds());
    theInterface_ = ConfigurationInterface::getInstance(
        ConfigurationInterface::CONFIGURATION_MODE::
            ARTDAQ_DATABASE);  // false to use artdaq DB
 
    __GEN_COUTTV__(runTimeSeconds());
 
    // // initialize special group metadata table
    // {
    //  // Note: "TableGroupMetadata" should never be in conflict
    //  //  because all other tables end in "...Table"
 
    //  // This is a table called TableGroupMetadata
    //  //  with 4 fields:
    //  //      - GroupAliases
    //  //      - GroupAuthor
    //  //      - GroupCreationTime
    //  //      - CommentDescription
 
    //  groupMetadataTable_.setTableName(
    //      TableBase::GROUP_METADATA_TABLE_NAME);
    //  std::vector<TableViewColumnInfo>* colInfo =
    //      groupMetadataTable_.getMockupViewP()->getColumnsInfoP();
    //  colInfo->push_back(TableViewColumnInfo(
    //      TableViewColumnInfo::TYPE_UID,  // just to make init() happy
    //      "UnusedUID",
    //      "UNUSED_UID",
    //      TableViewColumnInfo::DATATYPE_NUMBER,
    //      0 /*Default*/,
    //      "",
    //      0 /*Min*/,
    //      0 /*Max*/,
    //      0));
    //  colInfo->push_back(TableViewColumnInfo(TableViewColumnInfo::TYPE_DATA,
    //                                         "GroupAliases",
    //                                         "GROUP_ALIASES",
    //                                         TableViewColumnInfo::DATATYPE_STRING,
    //                                         0 /*Default*/,
    //                                         "",
    //                                         0 /*Min*/,
    //                                         0 /*Max*/,
    //                                         0));
    //  colInfo->push_back(TableViewColumnInfo(
    //      TableViewColumnInfo::TYPE_COMMENT,  // just to make init() happy
    //      TableViewColumnInfo::COL_NAME_COMMENT,
    //      "COMMENT_DESCRIPTION",
    //      TableViewColumnInfo::DATATYPE_STRING,
    //      0 /*Default*/,
    //      "",
    //      0 /*Min*/,
    //      0 /*Max*/,
    //      0));
    //  colInfo->push_back(TableViewColumnInfo(
    //      TableViewColumnInfo::TYPE_AUTHOR,  // just to make init() happy
    //      "GroupAuthor",
    //      "AUTHOR",
    //      TableViewColumnInfo::DATATYPE_STRING,
    //      0 /*Default*/,
    //      "",
    //      0 /*Min*/,
    //      0 /*Max*/,
    //      0));
    //  colInfo->push_back(TableViewColumnInfo(TableViewColumnInfo::TYPE_TIMESTAMP,
    //                                         "GroupCreationTime",
    //                                         "GROUP_CREATION_TIME",
    //                                         TableViewColumnInfo::DATATYPE_TIME,
    //                                         0 /*Default*/,
    //                                         "",
    //                                         0 /*Min*/,
    //                                         0 /*Max*/,
    //                                         0));
    //  auto tmpVersion = groupMetadataTable_.createTemporaryView();
    //  groupMetadataTable_.setActiveView(tmpVersion);
    //  // only need this one and only row for all time
    //  groupMetadataTable_.getViewP()->addRow();
    // }
 
    if(doInitializeFromFhicl)
    {
        // create tables and fill based on fhicl
        initializeFromFhicl(__ENV__("CONFIGURATION_INIT_FCL"));
        return;
    }
    // else do normal init
 
    __GEN_COUTTV__(runTimeSeconds());
    if(!initForWriteAccess)  //ConfigurationManagerRW can do manual init later when it calls getAllTableInfo(true)
        init(0 /*accumulatedErrors*/, initForWriteAccess);
    __GEN_COUTTV__(runTimeSeconds());
 
}  // end constructor()
 
//==============================================================================
ConfigurationManager::ConfigurationManager(const std::string& username)
    : ConfigurationManager(true /*initForWriteAccess*/)
{
    __GEN_COUT__ << "Private constructor for write access called." << __E__;
    // overwrite read-only username initialization with write-access username:
    mfSubject_ = username;
    username_  = username;
}  // end constructor(username)
 
//==============================================================================
ConfigurationManager::~ConfigurationManager() { destroy(); }
 
//==============================================================================
void ConfigurationManager::init(std::string* accumulatedErrors /*=0*/,
                                bool         initForWriteAccess /*= false*/,
                                std::string* accumulatedWarnings /*=0*/)
{
    // if(accumulatedErrors)
    //  *accumulatedErrors = "";
 
    // destroy();
 
    // once Interface is false (using artdaq db) ..
    //  then can test (configurationInterface_->getMode() == false)
    {
        try
        {
            __GEN_COUTTV__(username_);
 
            // if write access, then load all specified table groups (including configuration group),
            //  otherwise skip configuration group. Important to consider initForWriteAccess
            //  because this may be called before username_ is properly initialized
            ConfigurationManager::LoadGroupType onlyLoadIfBackboneOrContext =
                ConfigurationManager::LoadGroupType::ALL_TYPES;
            if(username_ == ConfigurationManager::READONLY_USER && !initForWriteAccess)
                onlyLoadIfBackboneOrContext =
                    ConfigurationManager::LoadGroupType::ONLY_BACKBONE_OR_CONTEXT_TYPES;
 
            // clang-format off
            restoreActiveTableGroups(accumulatedErrors ? true : false /*throwErrors*/,
                                     "" /*pathToActiveGroupsFile*/,
                                     onlyLoadIfBackboneOrContext,
                                     accumulatedWarnings);
            // clang-format on
        }
        catch(std::runtime_error& e)
        {
            __GEN_COUT_ERR__ << "Error caught in init(): " << e.what();
            if(accumulatedErrors)
                *accumulatedErrors += e.what();
            else
            {
                __SS__ << e.what();  // add line number of rethrow
                __SS_ONLY_THROW__;
            }
        }
    }
}  // end init()
 
//==============================================================================
void ConfigurationManager::restoreActiveTableGroups(
    bool               throwErrors /*=false*/,
    const std::string& pathToActiveGroupsFile /*=""*/,
    ConfigurationManager::LoadGroupType
        onlyLoadIfBackboneOrContext /*= ConfigurationManager::LoadGroupType::ALL_TYPES */,
    std::string* accumulatedWarnings /*=0*/)
{
    destroyTableGroup("", true);  // deactivate all
 
    std::string fn =
        pathToActiveGroupsFile == "" ? ACTIVE_GROUPS_FILENAME : pathToActiveGroupsFile;
    FILE* fp = fopen(fn.c_str(), "r");
 
    __GEN_COUTT__ << "ACTIVE_GROUPS_FILENAME = " << fn << __E__;
    __GEN_COUTS__(10) << "ARTDAQ_DATABASE_URI = "
                      << std::string(__ENV__("ARTDAQ_DATABASE_URI")) << __E__;
 
    if(!fp)
    {
        __GEN_COUT_WARN__ << "No active groups file found at " << fn << __E__;
        return;
    }
 
    __GEN_COUTVS__(10, throwErrors);
 
    char tmp[500];
    char strVal[500];
 
    std::string groupName;
    std::string errorStr = "";
    bool        skip;
 
    __SS__;
 
    while(fgets(tmp, 500, fp))
    {
        // do check for out of sync.. i.e. name is a number
        {
            int numberCheck = 0;
            sscanf(tmp, "%d", &numberCheck);
            if(numberCheck)
            {
                __GEN_COUT__
                    << "Out of sync with active groups file lines, attempting to resync."
                    << __E__;
                continue;
            }
        }
 
        skip = false;
        sscanf(tmp, "%s", strVal);  // sscanf to remove '\n'
        for(unsigned int j = 0; j < strlen(strVal); ++j)
            if(!((strVal[j] >= 'a' && strVal[j] <= 'z') ||
                 (strVal[j] >= 'A' && strVal[j] <= 'Z') ||
                 (strVal[j] >= '0' && strVal[j] <= '9')))
            {
                strVal[j] = '\0';
                if(strlen(strVal) == 0)
                    __GEN_COUT__ << "Empty group name found, so skipping! Check active "
                                    "groups file: "
                                 << fn << __E__;
                else
                    __GEN_COUT_WARN__
                        << "Illegal character found in group name '" << strVal
                        << "', so skipping! Check active groups file: " << fn << __E__;
 
                skip = true;
                break;
            }
 
        if(skip)
            continue;
 
        groupName = strVal;
        fgets(tmp, 500, fp);
        sscanf(tmp, "%s", strVal);  // sscanf to remove '\n'
 
        for(unsigned int j = 0; j < strlen(strVal); ++j)
            if(!((strVal[j] >= '0' && strVal[j] <= '9')))
            {
                strVal[j] = '\0';
 
                if(groupName.size() > 3)  // notify if seems like a real group name
                    __GEN_COUT_WARN__
                        << "Skipping active group with illegal character in group key '"
                        << strVal << ".' Check active groups file: " << fn << __E__;
 
                skip = true;
                break;
            }
 
        if(groupName.size() <= 3)
            continue;  //skip illegal group names
 
        if(skip)
            continue;
 
        try
        {
            TableGroupKey::getFullGroupString(groupName, TableGroupKey(strVal));
        }
        catch(...)
        {
            __GEN_COUT__
                << "illegal group according to TableGroupKey::getFullGroupString... "
                   "Check active groups file: "
                << fn << __E__;
            skip = true;
        }
 
        if(skip)
            continue;
 
        try
        {
            // load and doActivate
            std::string groupAccumulatedErrors = "";
 
            if(accumulatedWarnings)
                __GEN_COUT__ << "Ignoring warnings while loading and activating group '"
                             << groupName << "(" << strVal << ")'" << __E__;
 
            loadTableGroup(
                groupName,
                TableGroupKey(strVal),
                true /*doActivate*/,
                0 /*groupMembers*/,
                0 /*progressBar*/,
                (accumulatedWarnings ? &groupAccumulatedErrors
                                     : 0) /*accumulateWarnings = 0*/,
                0 /*groupComment       = 0*/,
                0 /*groupAuthor        = 0*/,
                0 /*groupCreateTime    = 0*/,
                0 /*doNotLoadMembers   = false*/,
                0 /*groupTypeString    = 0*/,
                0 /*groupAliases       = 0*/,
                onlyLoadIfBackboneOrContext /*onlyLoadIfBackboneOrContext = false*/
            );
 
            if(accumulatedWarnings)
                *accumulatedWarnings += groupAccumulatedErrors;
        }
        catch(std::runtime_error& e)
        {
            ss << "Failed to load group in ConfigurationManager::init() with name '"
               << groupName << "(" << strVal
               << ")' specified active by active groups file: " << fn << __E__;
            ss << e.what() << __E__;
 
            errorStr += ss.str();
        }
        catch(...)
        {
            ss << "Failed to load group in ConfigurationManager::init() with name '"
               << groupName << "(" << strVal
               << ")' specified active by active groups file: " << fn << __E__;
            try
            {
                throw;
            }  //one more try to printout extra info
            catch(const std::exception& e)
            {
                ss << "Exception message: " << e.what();
            }
            catch(...)
            {
            }
            errorStr += ss.str();
        }
    }
 
    fclose(fp);
 
    if(throwErrors && errorStr != "")
    {
        __SS__ << "\n" << errorStr;
        __SS_ONLY_THROW__;
    }
    else if(errorStr != "")
        __GEN_COUT_WARN__ << "\n" << errorStr;
 
}  // end restoreActiveTableGroups()
 
//==============================================================================
void ConfigurationManager::destroyTableGroup(const std::string& theGroup,
                                             bool               onlyDeactivate)
{
    // delete
    bool isContext       = theGroup == "" || theGroup == theContextTableGroup_;
    bool isBackbone      = theGroup == "" || theGroup == theBackboneTableGroup_;
    bool isIterate       = theGroup == "" || theGroup == theIterateTableGroup_;
    bool isConfiguration = theGroup == "" || theGroup == theConfigurationTableGroup_;
 
    if(!isContext && !isBackbone && !isIterate && !isConfiguration)
    {
        __SS__ << "Invalid configuration group to destroy: " << theGroup << __E__;
        __GEN_COUT_ERR__ << ss.str();
        __SS_THROW__;
    }
 
    std::string dbgHeader = onlyDeactivate ? "Deactivating" : "Destroying";
    if(theGroup != "")
    {
        if(isContext)
            __GEN_COUT__ << dbgHeader << " Context group: " << theGroup << __E__;
        if(isBackbone)
            __GEN_COUT__ << dbgHeader << " Backbone group: " << theGroup << __E__;
        if(isIterate)
            __GEN_COUT__ << dbgHeader << " Iterate group: " << theGroup << __E__;
        if(isConfiguration)
            __GEN_COUT__ << dbgHeader << " Configuration group: " << theGroup << __E__;
    }
 
    getActiveContextMemberNames();  // make sure active contextMemberNames_ are up to date
 
    std::set<std::string>::const_iterator contextFindIt, backboneFindIt, iterateFindIt;
    for(auto it = nameToTableMap_.begin(); it != nameToTableMap_.end();
        /*no increment*/)
    {
        contextFindIt  = contextMemberNames_.find(it->first);
        backboneFindIt = backboneMemberNames_.find(it->first);
        iterateFindIt  = iterateMemberNames_.find(it->first);
 
        __GEN_COUTT__ << "Considering table: " << it->first << " contextFindIt:"
                      << (contextFindIt != contextMemberNames_.end() ? "Y" : "N")
                      << " backboneFindIt:"
                      << (backboneFindIt != backboneMemberNames_.end() ? "Y" : "N")
                      << " iterateFindIt:"
                      << (iterateFindIt != iterateMemberNames_.end() ? "Y" : "N")
                      << __E__;
        if(theGroup == "" ||
           ((isContext &&
             contextFindIt !=
                 contextMemberNames_
                     .end()) ||  //for context group, deactivate context members AND optional member
            (isContext &&
             it->first ==
                 ConfigurationManager::
                     CONTEXT_SUBSYSTEM_OPTIONAL_TABLE) ||  //optional context member
            (isBackbone && backboneFindIt != backboneMemberNames_.end()) ||
            (isIterate && iterateFindIt != iterateMemberNames_.end()) ||
            (isConfiguration &&  //for configuration group, deactivate all tables not specified in other group types
             contextFindIt == contextMemberNames_.end() &&
             it->first != ConfigurationManager::CONTEXT_SUBSYSTEM_OPTIONAL_TABLE &&
             backboneFindIt == backboneMemberNames_.end() &&
             iterateFindIt == iterateMemberNames_.end())))
        {
            __GEN_COUTT__ << "\t" << dbgHeader << ".. " << it->first
                          << (it->second->isActive()
                                  ? "_v" + it->second->getViewVersion().str()
                                  : "")
                          << __E__;
 
            if(onlyDeactivate)  // only deactivate
            {
                it->second->deactivate();
                ++it;
            }
            else  // else, delete/erase
            {
                delete it->second;
                nameToTableMap_.erase(it++);
            }
        }
        else
            ++it;
    }
 
    if(isConfiguration)
    {
        theConfigurationTableGroup_ = "";
        if(theConfigurationTableGroupKey_ != 0)
        {
            __GEN_COUTT__ << "Destroying Configuration Key: "
                          << *theConfigurationTableGroupKey_ << __E__;
            theConfigurationTableGroupKey_.reset();
        }
    }
    if(isBackbone)
    {
        theBackboneTableGroup_ = "";
        if(theBackboneTableGroupKey_ != 0)
        {
            __GEN_COUTT__ << "Destroying Backbone Key: " << *theBackboneTableGroupKey_
                          << __E__;
            theBackboneTableGroupKey_.reset();
        }
    }
    if(isIterate)
    {
        theIterateTableGroup_ = "";
        if(theIterateTableGroupKey_ != 0)
        {
            __GEN_COUTT__ << "Destroying Iterate Key: " << *theIterateTableGroupKey_
                          << __E__;
            theIterateTableGroupKey_.reset();
        }
    }
    if(isContext)
    {
        theContextTableGroup_ = "";
        if(theContextTableGroupKey_ != 0)
        {
            __GEN_COUTT__ << "Destroying Context Key: " << *theContextTableGroupKey_
                          << __E__;
            theContextTableGroupKey_.reset();
        }
    }
}  //end destroyTableGroup()
 
//==============================================================================
void ConfigurationManager::destroy(void) { destroyTableGroup(); }  //end destroy()
 
//==============================================================================
const std::string& ConfigurationManager::convertGroupTypeToName(
    const ConfigurationManager::GroupType& groupTypeId)
{
    return groupTypeId == ConfigurationManager::GroupType::CONTEXT_TYPE
               ? ConfigurationManager::GROUP_TYPE_NAME_CONTEXT
               : (groupTypeId == ConfigurationManager::GroupType::BACKBONE_TYPE
                      ? ConfigurationManager::GROUP_TYPE_NAME_BACKBONE
                      : (groupTypeId == ConfigurationManager::GroupType::ITERATE_TYPE
                             ? ConfigurationManager::GROUP_TYPE_NAME_ITERATE
                             : (groupTypeId == ConfigurationManager::GroupType::
                                                   CONFIGURATION_TYPE
                                    ? ConfigurationManager::GROUP_TYPE_NAME_CONFIGURATION
                                    : ConfigurationManager::GROUP_TYPE_NAME_UNKNOWN)));
}  // end convertGroupTypeToName()
 
//==============================================================================
ConfigurationManager::GroupType ConfigurationManager::getTypeOfGroup(
    const std::map<std::string /*name*/, TableVersion /*version*/>& memberMap)
{
    bool         isContext  = true;
    bool         isBackbone = true;
    bool         isIterate  = true;
    bool         inGroup;
    bool         inContext  = false;
    bool         inBackbone = false;
    bool         inIterate  = false;
    unsigned int matchCount = 0;
 
    for(auto& memberPair : memberMap)
    {
        //__COUT__ << "Member name: = "<< memberPair.first << __E__;
        inGroup = false;  // check context
        if(memberPair.first == CONTEXT_SUBSYSTEM_OPTIONAL_TABLE)
        {
            inGroup   = true;
            inContext = true;
        }
        else
            for(auto& contextMemberString : fixedContextMemberNames_)
                if(memberPair.first == contextMemberString)
                {
                    inGroup   = true;
                    inContext = true;
                    ++matchCount;
                    break;
                }
        if(!inGroup)
        {
            isContext = false;
            if(inContext)  // there was a member in context!
            {
                __SS__ << "This group is an incomplete match to a Context group.\n";
                ss << "\nTo be a Context group, the members must exactly match "
                   << "the following members (w/ or wo/ the optional table "
                   << CONTEXT_SUBSYSTEM_OPTIONAL_TABLE << "):\n";
                int i = 0;
                for(const auto& memberName : fixedContextMemberNames_)
                    ss << ++i << ". " << memberName << "\n";
                ss << "\nThe members are as follows::\n";
                i = 0;
                for(const auto& memberPairTmp : memberMap)
                    ss << ++i << ". " << memberPairTmp.first << "\n";
                __SS_ONLY_THROW__;
            }
        }
 
        inGroup = false;  // check backbone
        for(auto& backboneMemberString : backboneMemberNames_)
            if(memberPair.first == backboneMemberString)
            {
                inGroup    = true;
                inBackbone = true;
                ++matchCount;
                break;
            }
        if(!inGroup)
        {
            isBackbone = false;
            if(inBackbone)  // there was a member in backbone!
            {
                __SS__ << "This group is an incomplete match to a Backbone group.\n";
                ss << "\nTo be a Backbone group, the members must exactly match "
                   << "the following members:\n";
                int i = 0;
                for(auto& memberName : backboneMemberNames_)
                    ss << ++i << ". " << memberName << "\n";
                ss << "\nThe members are as follows::\n";
                i = 0;
                for(const auto& memberPairTmp : memberMap)
                    ss << ++i << ". " << memberPairTmp.first << "\n";
                //__COUT_ERR__ << "\n" << ss.str();
                __SS_ONLY_THROW__;
            }
        }
 
        inGroup = false;  // check iterate
        for(auto& iterateMemberString : iterateMemberNames_)
            if(memberPair.first == iterateMemberString)
            {
                inGroup   = true;
                inIterate = true;
                ++matchCount;
                break;
            }
        if(!inGroup)
        {
            isIterate = false;
            if(inIterate)  // there was a member in iterate!
            {
                __SS__ << "This group is an incomplete match to a Iterate group.\n";
                ss << "\nTo be a Iterate group, the members must exactly match "
                   << "the following members:\n";
                int i = 0;
                for(auto& memberName : iterateMemberNames_)
                    ss << ++i << ". " << memberName << "\n";
                ss << "\nThe members are as follows::\n";
                i = 0;
                for(const auto& memberPairTmp : memberMap)
                    ss << ++i << ". " << memberPairTmp.first << "\n";
                //__COUT_ERR__ << "\n" << ss.str();
                __SS_ONLY_THROW__;
            }
        }
    }
 
    if((isContext || inContext) && matchCount != fixedContextMemberNames_.size())
    {
        __SS__ << "This group is an incomplete match to a Context group: "
               << " Size=" << matchCount << " but should be "
               << fixedContextMemberNames_.size() << __E__;
        ss << "\nThe members currently are...\n";
        int i = 0;
        for(auto& memberPair : memberMap)
            ss << ++i << ". " << memberPair.first << "\n";
        ss << "\nThe expected Context members are...\n";
        i = 0;
        for(auto& memberName : fixedContextMemberNames_)
            ss << ++i << ". " << memberName << "\n";
        ss << "optional. (" << CONTEXT_SUBSYSTEM_OPTIONAL_TABLE << ")\n";
        //__COUT_ERR__ << "\n" << ss.str();
        __SS_ONLY_THROW__;
    }
 
    if((isBackbone || inBackbone) && matchCount != backboneMemberNames_.size())
    {
        __SS__ << "This group is an incomplete match to a Backbone group: "
               << " Size=" << matchCount << " but should be "
               << backboneMemberNames_.size() << __E__;
        ss << "\nThe members currently are...\n";
        int i = 0;
        for(auto& memberPair : memberMap)
            ss << ++i << ". " << memberPair.first << "\n";
        ss << "\nThe expected Backbone members are...\n";
        i = 0;
        for(auto& memberName : backboneMemberNames_)
            ss << ++i << ". " << memberName << "\n";
        //__COUT_ERR__ << "\n" << ss.str();
        __SS_ONLY_THROW__;
    }
 
    if((isIterate || inIterate) && matchCount != iterateMemberNames_.size())
    {
        __SS__ << "This group is an incomplete match to a Iterate group: "
               << " Size=" << matchCount << " but should be "
               << iterateMemberNames_.size() << __E__;
        ss << "\nThe members currently are...\n";
        int i = 0;
        for(auto& memberPair : memberMap)
            ss << ++i << ". " << memberPair.first << "\n";
        ss << "\nThe expected Iterate members are...\n";
        i = 0;
        for(auto& memberName : iterateMemberNames_)
            ss << ++i << ". " << memberName << "\n";
        //__COUT_ERR__ << "\n" << ss.str();
        __SS_ONLY_THROW__;
    }
 
    return isContext
               ? ConfigurationManager::GroupType::CONTEXT_TYPE
               : (isBackbone
                      ? ConfigurationManager::GroupType::BACKBONE_TYPE
                      : (isIterate
                             ? ConfigurationManager::GroupType::ITERATE_TYPE
                             : ConfigurationManager::GroupType::CONFIGURATION_TYPE));
}  // end getTypeOfGroup()
 
//==============================================================================
const std::string& ConfigurationManager::getTypeNameOfGroup(
    const std::map<std::string /*name*/, TableVersion /*version*/>& memberMap)
{
    return convertGroupTypeToName(getTypeOfGroup(memberMap));
}  // end getTypeNameOfGroup()
 
//==============================================================================
#define OUT out << tabStr << commentStr
#define PUSHTAB tabStr += "\t"
#define POPTAB tabStr.resize(tabStr.size() - 1)
#define PUSHCOMMENT commentStr += "# "
#define POPCOMMENT commentStr.resize(commentStr.size() - 2)
 
void ConfigurationManager::dumpMacroMakerModeFhicl()
{
    if(nameToTableMap_.find("FEInterfaceTable") == nameToTableMap_.end())
    {
        __COUT__ << "Skipping dumpMacroMakerModeFhicl() since FEInterface table is not "
                    "activated."
                 << __E__;
        return;
    }
 
    std::string filepath =
        __ENV__("USER_DATA") + std::string("/") + "MacroMakerModeConfigurations";
    mkdir(filepath.c_str(), 0755);
    filepath += "/MacroMakerModeFhiclDump.fcl";
    __GEN_COUT__ << "dumpMacroMakerModeFhicl: " << filepath << __E__;
 
    // generate MacroMaker mode fhicl file
    std::fstream out;
 
    std::string tabStr     = "";
    std::string commentStr = "";
 
    out.open(filepath, std::fstream::out | std::fstream::trunc);
    if(out.fail())
    {
        __SS__ << "Failed to open MacroMaker mode fcl file for configuration dump: "
               << filepath << __E__;
        __SS_THROW__;
    }
 
    try
    {
        std::vector<std::pair<std::string, ConfigurationTree>> fes =
            getNode("FEInterfaceTable").getChildren();
 
        for(auto& fe : fes)
        {
            // skip status false
            if(!fe.second.status())
                continue;
 
            //__GEN_COUTV__(fe.first);
 
            OUT << fe.first << ": {" << __E__;
            PUSHTAB;
 
            // only do FEInterfacePluginName and LinkToFETypeTable at top level
 
            OUT << "FEInterfacePluginName"
                << ": \t"
                << "\"" << fe.second.getNode("FEInterfacePluginName").getValueAsString()
                << "\"" << __E__;
 
            recursiveTreeToFhicl(
                fe.second.getNode("LinkToFETypeTable"), out, tabStr, commentStr);
 
            POPTAB;
            OUT << "} //end " << fe.first << __E__ << __E__;
 
        }  // end fe handling
    }
    catch(...)
    {
        __SS__ << "Failed to complete MacroMaker mode fcl "
                  "file configuration dump due to error."
               << __E__;
        try
        {
            throw;
        }  //one more try to printout extra info
        catch(const std::runtime_error& e)
        {
            ss << "Exception message: " << e.what();
        }
        catch(const std::exception& e)
        {
            ss << "Exception message: " << e.what();
        }
        __GEN_COUT_ERR__ << ss.str();
    }
 
    out.close();
    // end fhicl output
}  // end dumpMacroMakerModeFhicl()
 
//==============================================================================
void ConfigurationManager::recursiveTreeToFhicl(ConfigurationTree node,
                                                std::ostream&     out /* = std::cout */,
                                                std::string&      tabStr /* = "" */,
                                                std::string&      commentStr /* = "" */,
                                                unsigned int      depth /* = -1 */)
{
    if(depth == 0)
    {
        __COUT__ << __COUT_HDR_P__ << "Depth limit reached. Ending recursion." << __E__;
        return;
    }
 
    //__COUT__ << __COUT_HDR_P__ << "Adding tree record '" << node.getValueAsString() << "' fields..." << __E__;
 
    if(depth == (unsigned int)-1)
        depth = 10;
 
    // decorate link node with link_table {} wrapper
    if(node.isLinkNode())
    {
        if(node.isDisconnected())
        {
            //__COUT__ << node.getFieldName() << " field is a disconnected link." << __E__;
            return;
        }
 
        OUT << node.getFieldName() << "_"
            << node.getValueAsString(true /* returnLinkTableValue */) << ": \t{" << __E__;
        PUSHTAB;
    }  // end link preamble decoration
 
    if(node.isGroupLinkNode())
    {
        // for group link, handle each as a UID record
        std::vector<std::pair<std::string, ConfigurationTree>> children =
            node.getChildren();
        for(auto& child : children)
            recursiveTreeToFhicl(child.second, out, tabStr, commentStr, depth - 1);
 
        POPTAB;
        OUT << "} //end " << node.getValueAsString(true /* returnLinkTableValue */)
            << " group link record" << __E__;
        return;
    }  // end group link handling
 
    // treat as UID record now
    //  give UID decoration, then contents
 
    // open UID decoration
    OUT << node.getValueAsString() << ": \t{" << __E__;
    PUSHTAB;
    {  // open UID content
 
        std::vector<std::pair<std::string, ConfigurationTree>> fields =
            node.getChildren();
 
        // skip last 3 fields that are always common
        for(unsigned int i = 0; i < fields.size() - 3; ++i)
        {
            //__COUT__ << fields[i].first << __E__;
 
            if(fields[i].second.isLinkNode())
            {
                recursiveTreeToFhicl(
                    fields[i].second, out, tabStr, commentStr, depth - 1);
                continue;
            }
            // else a normal field
 
            OUT << fields[i].second.getFieldName() << ": \t";
            if(fields[i].second.isValueNumberDataType())
                OUT << fields[i].second.getValueAsString() << __E__;
            else
                OUT << "\"" << fields[i].second.getValueAsString() << "\"" << __E__;
 
        }  // end fe fields
 
    }        // close UID content
    POPTAB;  // close UID decoration
    OUT << "} //end " << node.getValueAsString() << " record" << __E__;
 
    // handle link closing decoration
    if(node.isLinkNode())
    {
        POPTAB;
        OUT << "} //end " << node.getValueAsString(true /* returnLinkTableValue */)
            << " link record" << __E__;
    }  // end link closing decoration
 
}  // end recursiveTreeToFhicl
 
//==============================================================================
void ConfigurationManager::dumpActiveConfiguration(
    const std::string& filePath,
    const std::string& dumpType,
    const std::string& configurationAlias,
    const std::string& subsystemCommonList,
    const std::string& subsystemCommonOverrideList,
    const std::string& logEntry,
    const std::string& activeUsers,
    const std::string& activeStateMachine,
    std::ostream&      altOut /* = std::cout */)
{
    time_t rawtime = time(0);
    __GEN_COUT__ << "filePath = " << filePath << __E__;
    __GEN_COUT__ << "dumpType = " << dumpType << __E__;
 
    std::ofstream fs;
    if(filePath != "")
        fs.open(filePath, std::fstream::out | std::fstream::trunc);
 
    std::ostream* out;
 
    // if file was valid use it, else default to cout
    if(fs.is_open())
        out = &fs;
    else
    {
        if(filePath != "")
        {
            __SS__ << "Invalid file path to dump active configuration. File " << filePath
                   << " could not be opened!" << __E__;
            __GEN_COUT_ERR__ << ss.str();
            __SS_THROW__;
        }
        out = &(altOut);
    }
 
    if(dumpType == "JSON All")
    {
        (*out) << "{\n";
        (*out) << "\t\"ARTDAQ_DATABASE_URI\": \"" << __ENV__("ARTDAQ_DATABASE_URI")
               << "\"," << __E__;
        if(fs.is_open())
        {
            (*out) << "\t\"HOSTNAME\": \"" << __ENV__("HOSTNAME") << "\"," << __E__;
            (*out) << "\t\"HOSTNAME filepath\": \"" << filePath << "\"," << __E__;
            (*out) << "\t\"Active State Machine\": \"" << activeStateMachine << "\","
                   << __E__;
        }
        (*out) << "\t\"active_users\": \t[";
        if(activeUsers.size())
        {
            std::istringstream iss(activeUsers);
            std::string        user;
            bool               first = true;
            while(std::getline(iss, user, ','))
            {
                if(!first)
                    (*out) << ",";
                (*out) << "\n\t\t\"" << user << "\"";
                first = false;
            }
        }
        (*out) << "\n\t]," << __E__;
        (*out) << "\t\"dump_type\": \t\t\"" << dumpType << "\"," << __E__;
        (*out) << "\t\"dump_time\": \t\t\"" << rawtime << "\"," << __E__;
        (*out) << "\t\"dump_time_formatted\": \t\t\""
               << StringMacros::getTimestampString(rawtime) << "\"," << __E__;
    }
    else
    {
        (*out) << "#################################" << __E__;
        (*out) << "This is an ots system configuration dump.\n" << __E__;
        (*out) << "Source database is $ARTDAQ_DATABASE_URI: "
               << __ENV__("ARTDAQ_DATABASE_URI") << __E__;
        if(fs.is_open())
            (*out) << "Original location of dump:               " << __ENV__("HOSTNAME")
                   << ":" << filePath << __E__;
        (*out) << "\nActive ots users: \t"
               << (activeUsers.size() ? activeUsers : "no active users") << __E__;
        (*out) << "Type of dump: \t\t" << dumpType << __E__;
        (*out) << "Time of dump: \t\t" << rawtime;
        (*out) << " \t" << StringMacros::getTimestampString(rawtime) << __E__;
    }
 
    //determine configurationAlias tranlation
    std::pair<std::string, ots::TableGroupKey> configurationTableGroup =
        getTableGroupFromAlias(configurationAlias);
 
    if(dumpType != "JSON All")
    {
        (*out) << "Configuration Alias: \t\t\t" << configurationAlias << "\n";
        (*out) << "Configuration Alias translation: \t" << configurationTableGroup.first
               << "(" << configurationTableGroup.second << ")\n\n";
 
        if(logEntry.size())
            (*out) << "User Log Entry (" << logEntry.size() << " chars):\n"
                   << logEntry << __E__;
    }
 
    // define local "lambda" functions
    //  active groups
    //  active tables
    //  active group members
    //  active table contents
 
    //============================
    auto localDumpActiveGroups = [](const ConfigurationManager* cfgMgr,
                                    std::ostream*               out,
                                    std::string                 subsystemCommonList,
                                    std::string subsystemCommonOverrideList,
                                    bool        jsonify            = false,
                                    std::string configurationAlias = "") {
        std::map<std::string, std::pair<std::string, TableGroupKey>> activeGroups =
            cfgMgr->getActiveTableGroups();
 
        if(jsonify)
        {
            if(!subsystemCommonList.empty())
                (*out) << "\n\t\"subsystem_common_table_list\": \"" << subsystemCommonList
                       << "\"," << __E__;
            if(!subsystemCommonOverrideList.empty())
                (*out) << "\n\t\"subsystem_common_override_table_list\": \""
                       << subsystemCommonOverrideList << "\",\n"
                       << __E__;
            (*out) << "\n\t\"groups\": {\n";
        }
        else
        {
            (*out) << "Subsystem Common Table List: " << subsystemCommonList << __E__;
            (*out) << "Subsystem Common Override Table List: "
                   << subsystemCommonOverrideList << __E__;
            (*out) << "\n\n************************" << __E__;
            (*out) << "Active Groups: " << __E__;
        }
 
        std::map<std::string, std::pair<std::string, TableGroupKey>>::iterator it;
 
        for(it = activeGroups.begin(); it != activeGroups.end(); ++it)
        {
            if(jsonify)
            {
                (*out) << "\t\t\"" << it->first << "_group_name\": \"" << it->second.first
                       << "\",\n";
                (*out) << "\t\t\"" << it->first << "_group_key\": \"" << it->second.second
                       << "\"";
                if(it->first == "Configuration")
                {
                    (*out) << ",\n";
                    (*out) << "\t\t\""
                           << "Configuration_alias\": \"" << configurationAlias << "\"";
                }
                (*out) << (std::next(it) == activeGroups.end() ? "" : ",") << "\n";
            }
            else
            {
                (*out) << "\t" << it->first << " := " << it->second.first << " ("
                       << it->second.second << ")" << __E__;
            }
        }
 
        if(jsonify)
            (*out) << "\t}";
    };  //end localDumpActiveGroups()
 
    //============================
    auto localDumpActiveTables = [](const ConfigurationManager* cfgMgr,
                                    std::ostream*               out,
                                    bool                        jsonify = false) {
        std::map<std::string, TableVersion> activeTables = cfgMgr->getActiveVersions();
 
        if(jsonify)
        {
            (*out) << "\t\"tables\": { " << __E__;
        }
        else
        {
            (*out) << "\n\n************************" << __E__;
            (*out) << "Active Tables:" << __E__;
            (*out) << "Active Tables count = " << activeTables.size() << __E__;
        }
 
        unsigned int                                  i = 0;
        std::map<std::string, TableVersion>::iterator it;
        for(it = activeTables.begin(); it != activeTables.end(); ++it)
        {
            if(jsonify)
            {
                (*out) << "\t\t\""
                       << "active_table_name"
                       << "\": \"" << it->first << "\",\n";
                (*out) << "\t\t\""
                       << "active_table_version"
                       << "\": \"" << it->second << "\"";
                (*out) << (std::next(it) == activeTables.end() ? "" : ",") << "\n";
            }
            else
            {
                (*out) << "\t" << ++i << ". " << it->first << "-v" << it->second << __E__;
            }
        }
 
        if(jsonify)
            (*out) << "\t}";
    };  //end localDumpActiveTables()
 
    //============================
    auto localDumpActiveGroupMembers = [](ConfigurationManager* cfgMgr,
                                          std::ostream*         out,
                                          bool                  jsonify = false) {
        std::map<std::string, std::pair<std::string, TableGroupKey>> activeGroups =
            cfgMgr->getActiveTableGroups();
 
        if(jsonify)
        {
            (*out) << "\t\"group_members\": { " << __E__;
        }
        else
        {
            (*out) << "\n\n************************" << __E__;
            (*out) << "Active Group Members:" << __E__;
        }
 
        int tableCount = 0;
        std::map<std::string, std::pair<std::string, TableGroupKey>>::iterator it;
        for(it = activeGroups.begin(); it != activeGroups.end(); ++it)
        {
            if(!jsonify)
            {
                (*out) << "\t" << it->first << " := " << it->second.first << " ("
                       << it->second.second << ")" << __E__;
            }
 
            if(it->second.first == "")
            {
                if(!jsonify)
                {
                    (*out) << "\t"
                           << "Empty group name. Assuming no active group." << __E__;
                }
                continue;
            }
 
            if(jsonify)
            {
                (*out) << "\t\t\"" << it->first << "\" : {" << __E__;
                (*out) << "\t\t\t\"Name\": \t\"" << it->second.first << "\""
                       << (std::next(it) == activeGroups.end() ? "" : ",") << __E__;
            }
 
            std::map<std::string /*name*/, TableVersion /*version*/> memberMap;
            std::map<std::string /*name*/, std::string /*alias*/>    groupAliases;
            std::string                                              groupComment;
            std::string                                              groupAuthor;
            std::string                                              groupCreateTime;
            time_t                                                   groupCreateTime_t;
 
            cfgMgr->loadTableGroup(it->second.first,
                                   it->second.second,
                                   false /*doActivate*/,
                                   &memberMap /*memberMap*/,
                                   0 /*progressBar*/,
                                   0 /*accumulateErrors*/,
                                   &groupComment,
                                   &groupAuthor,
                                   &groupCreateTime,
                                   true /*doNotLoadMembers*/,
                                   0 /*groupTypeString*/,
                                   &groupAliases);
 
            if(jsonify)
            {
                (*out) << "\t\t\t\"key\": \t\"" << it->second.second << "\"," << __E__;
                (*out) << "\t\t\t\"comment\": \t\"" << groupComment << "\"," << __E__;
                (*out) << "\t\t\t\"author\": \t\"" << groupAuthor << "\"," << __E__;
 
                sscanf(groupCreateTime.c_str(), "%ld", &groupCreateTime_t);
                std::string timeCreated = ctime(&groupCreateTime_t);
                (*out) << "\t\t\t\"create_time\": \t\""
                       << timeCreated.erase(timeCreated.find('\n', 0), 1) << "\","
                       << __E__;
                (*out) << "\t\t\t\"group_aliases\": \t\""
                       << StringMacros::mapToString(groupAliases) << "\"," << __E__;
 
                (*out) << "\t\t\t\"table_count\": \t\"" << memberMap.size() << "\","
                       << __E__;
                tableCount += memberMap.size();
 
                (*out) << "\t\t\t\"tables\": {" << __E__;
 
                std::map<std::string /*name*/, TableVersion /*version*/>::iterator
                    iterMap;
                for(iterMap = memberMap.begin(); iterMap != memberMap.end(); ++iterMap)
                {
                    (*out) << "\t\t\t\t\"" << iterMap->first << "\": \""
                           << iterMap->second << "\""
                           << (std::next(iterMap) == memberMap.end() ? "" : ",") << __E__;
                }
                (*out) << "\t\t\t}" << __E__;
                (*out) << "\t\t}," << __E__;
            }
            else
            {
                (*out) << "\t\tGroup Comment: \t" << groupComment << __E__;
                (*out) << "\t\tGroup Author: \t" << groupAuthor << __E__;
 
                sscanf(groupCreateTime.c_str(), "%ld", &groupCreateTime_t);
                (*out) << "\t\tGroup Create Time: \t" << ctime(&groupCreateTime_t)
                       << __E__;
                (*out) << "\t\tGroup Aliases: \t"
                       << StringMacros::mapToString(groupAliases) << __E__;
 
                (*out) << "\t\tMember table count = " << memberMap.size() << __E__;
                tableCount += memberMap.size();
 
                unsigned int i = 0;
                for(auto& member : memberMap)
                {
                    (*out) << "\t\t\t" << ++i << ". " << member.first << "-v"
                           << member.second << __E__;
                }
            }
        }
 
        if(jsonify)
        {
            (*out) << "\t\"total_table_count\": \"" << tableCount << "\"" << __E__;
            (*out) << "\t}";
        }
        else
        {
            (*out) << "\nActive Group Members total table count = " << tableCount
                   << __E__;
        }
    };  //end localDumpActiveGroupMembers()
 
    //============================
    auto localDumpActiveTableContents = [](const ConfigurationManager* cfgMgr,
                                           std::ostream*               out,
                                           bool                        jsonify = false) {
        std::map<std::string, TableVersion> activeTables = cfgMgr->getActiveVersions();
 
        if(jsonify)
        {
            (*out) << "\t\"tables\": {" << __E__;
        }
        else
        {
            (*out) << "\n\n************************" << __E__;
            (*out) << "Active Table Contents (table count = " << activeTables.size()
                   << "):" << __E__;
        }
 
        unsigned int                                  i = 0;
        std::map<std::string, TableVersion>::iterator it;
        for(it = activeTables.begin(); it != activeTables.end(); ++it)
        {
            if(jsonify)
            {
                __COUTT__ << "localDumpActiveTableContents table: " << it->first << __E__;
                auto table = cfgMgr->nameToTableMap_.find(it->first)->second->getViewP();
                (*out) << "\t\t\"" << it->first << "-v" << it->second << "\": ";
                table->printJSON(*out);
                (*out) << (std::next(it) == activeTables.end() ? "" : ",") << __E__;
            }
            else
            {
                (*out) << "\n\n=========================================================="
                          "===="
                          "================"
                       << __E__;
                (*out) << "=============================================================="
                          "===="
                          "============"
                       << __E__;
                (*out) << "\t" << ++i << ". " << it->first << "-v" << it->second << __E__;
 
                cfgMgr->nameToTableMap_.find(it->first)->second->print(*out);
            }
        }
 
        if(jsonify)
        {
            (*out) << "\t}" << __E__;
        }
    };  //end localDumpActiveTableContents()
 
    //============================
    auto localDumpActiveTableStructureStatus = [](ConfigurationManager* cfgMgr,
                                                  std::ostream*         out) {
        std::map<std::string, TableVersion> activeTables = cfgMgr->getActiveVersions();
 
        __COUT__ << "Active Table size: " << activeTables.size() << __E__;
        (*out) << "\t\"custom\": {" << __E__;
 
        std::string                                   activeTableStructure = "";
        std::map<std::string, TableVersion>::iterator it;
        size_t                                        tableStructureFoundCount = 0;
        for(it = activeTables.begin(); it != activeTables.end(); ++it)
        {
            try
            {
                __COUTT__ << "Trying to retrieve " << it->first << "-v" << it->second
                          << " Structure" << __E__;
                activeTableStructure =
                    cfgMgr->nameToTableMap_.find(it->first)->second->getStructureAsJSON(
                        cfgMgr);
                if(activeTableStructure != "")
                {
                    __COUTT__ << "Found Structure for Active Table: " << it->first << "-v"
                              << it->second << __E__;
 
                    (*out) << (tableStructureFoundCount++ ? "," : "") << __E__;
 
                    (*out) << "\t\"" << it->first << "\": " << __E__;
                    (*out) << activeTableStructure << __E__;
                }
            }
            catch(const std::exception& e)
            {
                __COUTT__ << "Error caught in localDumpActiveTableStructureStatus(): "
                          << e.what();
                __COUTT__ << "Structure Status may not be implemented." << __E__;
            }
        }  //end table structure loop
 
        __COUT__ << "Found " << tableStructureFoundCount << " Active Table Structures."
                 << __E__;
 
        (*out) << "\t}" << __E__;
    };  //end localDumpActiveTableStructureStatus()
 
    //============================
    auto localDumpSoftwareVersions = [](std::ostream* out, bool jsonFormat = false) {
        __COUT__ << "localDumpSoftwareVersions()" << __E__;
        std::vector<std::string> entries;
 
        // collect spack output (split by newlines)
        std::map<std::string, std::string> spackPackages;
        std::map<std::string, std::string> checkedOutRepos;
        std::string                        environment;
 
        {
            std::string        spackOut = StringMacros::exec("spack find");
            std::istringstream iss(spackOut);
            std::string        line;
            while(std::getline(iss, line))
            {
                if(line.empty())
                    continue;
 
                // Extract environment name
                if(line.find("==> In environment") != std::string::npos)
                {
                    size_t start = line.find("environment ") + 12;
                    environment  = line.substr(start);
                }
                else if(line[0] != '[' && line[0] != '-' &&
                        line.find("root specs") == std::string::npos)
                {
                    // Parse spack packages
                    size_t atPos = line.find('@');
                    if(atPos != std::string::npos)
                    {
                        std::string pkgName = line.substr(0, atPos);
                        // Remove leading [+] or [^] markers
                        if(pkgName.find('[') != std::string::npos)
                            pkgName = pkgName.substr(pkgName.find(']') + 2);
                        std::string version    = line.substr(atPos + 1);
                        spackPackages[pkgName] = version;
                    }
                    else if(line.find('[') == std::string::npos && !line.empty() &&
                            line[0] != 'c')
                    {
                        // Plain package name without version
                        std::string pkgName = line;
                        if(pkgName.find('[') != std::string::npos)
                            pkgName = pkgName.substr(pkgName.find(']') + 2);
                        spackPackages[pkgName] = "";
                    }
                }
            }
        }
 
        // Collect checked out repositories
        {
            DIR*           pDIR;
            struct dirent* entry;
            bool           isDir;
            std::string    name;
            int            type;
            std::string    src = __ENV__("OTS_SOURCE");
            if(!(pDIR = opendir((src).c_str())))
            {
                __SS__ << "Path '" << src << "' could not be opened!" << __E__;
                __SS_THROW__;
            }
            while((entry = readdir(pDIR)))
            {
                name = std::string(entry->d_name);
                type = int(entry->d_type);
 
                __COUTS__(2) << type << " " << name << "\n" << std::endl;
                if(name[0] != '.' &&
                   (type == 0 ||  // 0 == UNKNOWN (which can happen - seen in SL7 VM)
                    type == 4 ||  // directory type
                    type == 8 ||  // file type
                    type ==
                        10  // 10 == link (could be directory or file, treat as unknown)
                    ))
                {
                    isDir = false;
 
                    if(type == 0 || type == 10)
                    {
                        // unknown type .. determine if directory
                        DIR* pTmpDIR = opendir((src + "/" + name).c_str());
                        if(pTmpDIR)
                        {
                            isDir = true;
                            closedir(pTmpDIR);
                        }
                        else  //assume file
                            __COUTS__(2) << "Unable to open path as directory: "
                                         << (src + "/" + name) << __E__;
                    }
 
                    if(type == 4)
                        isDir = true;  // flag directory types
 
                    // handle directories
 
                    if(isDir)
                    {
                        __COUTS__(2) << "Directory: " << type << " " << name << __E__;
                        std::string describe = StringMacros::exec(
                            ("cd " + src + "/" + name + "; git describe --tags").c_str());
                        if(describe.size())
                        {
                            // strip trailing newline if any
                            if(describe.back() == '\n')
                                describe.pop_back();
                            checkedOutRepos[name] = describe;
                        }
                    }
                }
            }
            closedir(pDIR);
        }
 
        if(jsonFormat)
        {
            (*out) << "\t\"software_versions\": {" << __E__;
 
            // Output spack packages
            (*out) << "\t\t\"spack\": {" << __E__;
            bool first = true;
            for(const auto& pkg : spackPackages)
            {
                if(!first)
                    (*out) << "," << __E__;
                (*out) << "\t\t\t\"" << StringMacros::escapeJSONStringEntities(pkg.first)
                       << "\": \"" << StringMacros::escapeJSONStringEntities(pkg.second)
                       << "\"";
                first = false;
            }
            (*out) << __E__ << "\t\t}," << __E__;
 
            // Output checked out repositories
            (*out) << "\t\t\"checked_out\": {" << __E__;
            first = true;
            for(const auto& repo : checkedOutRepos)
            {
                if(!first)
                    (*out) << "," << __E__;
                (*out) << "\t\t\t\"" << StringMacros::escapeJSONStringEntities(repo.first)
                       << "\": \"" << StringMacros::escapeJSONStringEntities(repo.second)
                       << "\"";
                first = false;
            }
            (*out) << __E__ << "\t\t}," << __E__;
 
            // Output environment
            (*out) << "\t\t\"environment\": \""
                   << StringMacros::escapeJSONStringEntities(environment) << "\""
                   << __E__;
 
            (*out) << "\t}" << __E__;
        }
        else
        {
            (*out) << "\n\n\"Software Versions\": {" << __E__;
            (*out) << "  \"spack\": " << spackPackages.size() << " packages," << __E__;
            (*out) << "  \"checked_out\": " << checkedOutRepos.size() << " repositories,"
                   << __E__;
            (*out) << "  \"environment\": \"" << environment << "\"" << __E__;
            (*out) << "}" << __E__;
        }
    };  //end localDumpSoftwareVersions
 
    if(dumpType == "Group Keys")
    {
        localDumpActiveGroups(
            this, out, subsystemCommonList, subsystemCommonOverrideList);
    }
    else if(dumpType == "Table Versions")
    {
        localDumpActiveTables(this, out);
    }
    else if(dumpType == "Group Keys and Table Versions")
    {
        localDumpActiveGroups(
            this, out, subsystemCommonList, subsystemCommonOverrideList);
        localDumpActiveTables(this, out);
    }
    else if(dumpType == "All")
    {
        localDumpActiveGroups(
            this, out, subsystemCommonList, subsystemCommonOverrideList);
        localDumpActiveGroupMembers(this, out);
        localDumpActiveTables(this, out);
        localDumpActiveTableContents(this, out);
        localDumpSoftwareVersions(out);
    }
    else if(dumpType == "JSON All")
    {
        localDumpActiveGroups(this,
                              out,
                              subsystemCommonList,
                              subsystemCommonOverrideList,
                              true,
                              configurationAlias);
        (*out) << ",\n";
        localDumpActiveGroupMembers(this, out, true);
        (*out) << ",\n";
        //localDumpActiveTables(this, out, true);
        //(*out) << ",\n" << __E__;
        localDumpActiveTableContents(this, out, true);
        (*out) << ",\n" << __E__;
        localDumpActiveTableStructureStatus(this, out);
        (*out) << ",\n" << __E__;
        localDumpSoftwareVersions(out, true);
        (*out) << "}\n";
    }
    else
    {
        __SS__
            << "Invalid dump type '" << dumpType
            << "' given during dumpActiveConfiguration(). Valid types are as follows:\n"
            <<
 
            // List all choices (must match accepted dumpType strings)
            "Group Keys"
            << ", "
            << "Table Versions"
            << ", "
            << "Group Keys and Table Versions"
            << ", "
            << "All"
            << ", "
            << "JSON All"
            <<
 
            "\n\nPlease change the State Machine configuration to a valid dump type."
            << __E__;
        __SS_THROW__;
    }
 
    if(fs.is_open())
        fs.close();
 
}  //end dumpActiveConfiguration()
 
//==============================================================================
void ConfigurationManager::loadMemberMap(
    const std::map<std::string /*name*/, TableVersion /*version*/>& memberMap,
    std::string* accumulatedWarnings /* =0 */)
{
    __GEN_COUTTV__(runTimeSeconds());
 
    TableBase* tmpTableBasePtr;
 
    //detect if using cache, and decide if multi-threading
    bool usingCache = false;
    if(memberMap.size() > 10 && nameToTableMap_.size() &&
       nameToTableMap_.find(memberMap.begin()->first) != nameToTableMap_.end() &&
       nameToTableMap_.at(memberMap.begin()->first)->isStored(memberMap.begin()->second))
    {
        usingCache = true;
    }
    if(usingCache)
        __GEN_COUTT__ << "Using cache!" << __E__;
 
    //Note: mongodb crashing from too many connections was resolved by increasing ulimit at mongodb launch
    //   i.e. ulimit -n 64000 && ./start_mongod.sh
    const int numOfThreads =
        PROCESSOR_COUNT / 2 > memberMap.size() ? (PROCESSOR_COUNT / 2) : memberMap.size();
    if(memberMap.size() <= 2 /* i.e. is Context group */ || usingCache ||
       numOfThreads < 2)  // no multi-threading
    {
        //  for each member
        //      get()
        for(auto& memberPair : memberMap)
        {
            // if(accumulatedWarnings)
            //  __GEN_COUT__ << "\tFilling member table " << memberPair.first << ":" <<
            //      memberPair.second << __E__;
 
            // get the proper temporary pointer
            //  use 0 if doesn't exist yet.
            //  Note: do not want to give nameToTableMap_[memberPair.first]
            //      in case there is failure in get... (exceptions may be thrown)
            // Note: Default constructor is called by Map, i.e.
            // nameToTableMap_[memberPair.first] = 0; //create pointer and set to 0
            tmpTableBasePtr = nullptr;
            if(nameToTableMap_.find(memberPair.first) != nameToTableMap_.end())
                tmpTableBasePtr = nameToTableMap_.at(memberPair.first);
 
            std::string getError = "";
            try
            {
                theInterface_->get(tmpTableBasePtr,    // tablePtr
                                   memberPair.first,   // tableName
                                   0,                  // groupKey
                                   0,                  // groupName
                                   false,              // dontFill=false to fill
                                   memberPair.second,  // version
                                   false               // resetTable
                );
            }
            catch(const std::runtime_error& e)
            {
                __SS__ << "Failed to load member table '" << memberPair.first << "-v"
                       << memberPair.second << "' - here is the error: \n\n"
                       << e.what() << __E__;
 
                ss << "\nIf the table '" << memberPair.first
                   << "' should not exist, then please remove it from the group. If it "
                      "should exist, then it "
                   << "seems to have a problem; use the Table Editor to fix the table "
                      "definition, or "
                      "edit the table content to match the table definition."
                   << __E__;
 
                // if accumulating warnings and table view was created, then continue
                if(accumulatedWarnings)
                    getError = ss.str();
                else
                    __SS_ONLY_THROW__;
            }
            catch(...)
            {
                __SS__ << "Failed to load member table '" << memberPair.first << " -v"
                       << memberPair.second << "' due to unknown error!" << __E__;
                try
                {
                    throw;
                }  //one more try to printout extra info
                catch(const std::exception& e)
                {
                    ss << "Exception message: " << e.what();
                }
                catch(...)
                {
                }
 
                ss << "\nIf the table '" << memberPair.first
                   << "' should not exist, then please remove it from the group. If it "
                      "should exist, then it "
                   << "seems to have a problem; use the Table Editor to fix the table "
                      "definition, or "
                      "edit the table content to match the table definition."
                   << __E__;
 
                // if accumulating warnings and table view was created, then continue
                if(accumulatedWarnings)
                    getError = ss.str();
                else
                    __SS_THROW__;
            }
 
            //__GEN_COUT__ << "Checking ptr.. " <<  (tmpTableBasePtr?"GOOD":"BAD") << __E__;
            if(!tmpTableBasePtr)
            {
                __SS__ << "Null pointer returned for table '" << memberPair.first << " -v"
                       << memberPair.second << ".' Was the table info deleted?" << __E__;
                __GEN_COUT_ERR__ << ss.str();
 
                nameToTableMap_.erase(memberPair.first);
                if(accumulatedWarnings)
                {
                    *accumulatedWarnings += ss.str();
                    continue;
                }
                else
                    __SS_ONLY_THROW__;
            }
 
            nameToTableMap_[memberPair.first] = tmpTableBasePtr;
            if(nameToTableMap_[memberPair.first]->getViewP())
            {
                //__GEN_COUT__ << "Activated version: " <<
                // nameToTableMap_[memberPair.first]->getViewVersion() << __E__;
 
                if(accumulatedWarnings && getError != "")
                {
                    __SS__ << "Error caught during '" << memberPair.first << " -v"
                           << memberPair.second << "' table retrieval: \n"
                           << getError << __E__;
                    __GEN_COUT_ERR__ << ss.str();
                    *accumulatedWarnings += ss.str();
                }
            }
            else
            {
                __SS__ << nameToTableMap_[memberPair.first]->getTableName() << " -v"
                       << memberPair.second << ": View version not activated properly!";
                __SS_THROW__;
            }
        }  // end member map loop
    }
    else  //multi-threading
    {
        __GEN_COUTT__ << " PROCESSOR_COUNT " << PROCESSOR_COUNT << " ==> " << numOfThreads
                      << " threads for loading member map of size " << memberMap.size()
                      << __E__;
 
        int         threadsLaunched  = 0;
        int         foundThreadIndex = 0;
        std::string threadErrors;
        std::mutex  threadMutex;  // to protect accumulatedWarnings
        std::vector<std::shared_ptr<std::atomic<bool>>> threadDone;
        for(int i = 0; i < numOfThreads; ++i)
            threadDone.push_back(std::make_shared<std::atomic<bool>>(true));
        std::vector<TableBase*> tmpTableBasePtrs;
        for(int i = 0; i < numOfThreads; ++i)
            tmpTableBasePtrs.push_back(nullptr);
 
        for(auto& memberPair : memberMap)
        {
            if(threadsLaunched >= numOfThreads)
            {
                //find availableThreadIndex
                foundThreadIndex = -1;
                while(foundThreadIndex == -1)
                {
                    for(int i = 0; i < numOfThreads; ++i)
                        if(*(threadDone[i]))
                        {
                            foundThreadIndex = i;
                            break;
                        }
                    if(foundThreadIndex == -1)
                    {
                        __GEN_COUTT__ << "Waiting for available thread..." << __E__;
                        usleep(10000);
                    }
                }  //end thread search loop
                threadsLaunched = numOfThreads - 1;
            }
            __GEN_COUTT__ << "Starting filling thread... " << foundThreadIndex << " for "
                          << memberPair.first << " -v" << memberPair.second << __E__;
            *(threadDone[foundThreadIndex]) = false;
 
            // get the proper temporary pointer
            //  use 0 if doesn't exist yet.
            //  Note: do not want to give nameToTableMap_[memberPair.first]
            //      in case there is failure in get... (exceptions may be thrown)
            // Note: Default constructor is called by Map, i.e.
            // nameToTableMap_[memberPair.first] = 0; //create pointer and set to 0
            tmpTableBasePtrs[foundThreadIndex] = nullptr;
            if(nameToTableMap_.find(memberPair.first) != nameToTableMap_.end())
                tmpTableBasePtrs[foundThreadIndex] = nameToTableMap_.at(memberPair.first);
 
            std::thread(
                [](ConfigurationInterface*                 theInterface,
                   std::map<std::string, ots::TableBase*>* theNameToTableMap,
                   ots::TableBase*                         theTable,
                   std::string                             theTableName,
                   ots::TableVersion                       version,
                   std::string*                            theThreadErrors,
                   std::mutex*                             theThreadMutex,
                   std::shared_ptr<std::atomic<bool>>      theThreadDone) {
                    ConfigurationManager::fillTableThread(theInterface,
                                                          theNameToTableMap,
                                                          theTable,
                                                          theTableName,
                                                          version,
                                                          theThreadErrors,
                                                          theThreadMutex,
                                                          theThreadDone);
                },
                theInterface_,
                &nameToTableMap_,
                tmpTableBasePtrs[foundThreadIndex],
                memberPair.first,
                memberPair.second,
                &threadErrors,
                &threadMutex,
                threadDone[foundThreadIndex])
                .detach();
 
            ++threadsLaunched;
            ++foundThreadIndex;
        }  //end table init thread loop
 
        //check for all threads done
        do
        {
            foundThreadIndex = -1;
            for(int i = 0; i < numOfThreads; ++i)
                if(!*(threadDone[i]))
                {
                    foundThreadIndex = i;
                    break;
                }
            if(foundThreadIndex != -1)
            {
                __GEN_COUT_TYPE__(TLVL_DEBUG + 2)
                    << __COUT_HDR__ << "Waiting for thread to finish... "
                    << foundThreadIndex << __E__;
                usleep(10000);
            }
        } while(foundThreadIndex != -1);  //end thread done search loop
        __GEN_COUTT__ << "All threads done." << __E__;
 
        if(threadErrors != "")
        {
            __SS__ << "Error identified in threads during loading of member map: \n"
                   << threadErrors << __E__;
            __GEN_COUTT__ << "\n" << ss.str() << __E__;
            if(accumulatedWarnings)
                *accumulatedWarnings += ss.str();
            else
                __SS_THROW__;
        }
    }  //end multi-thread handling
 
    __GEN_COUTT__ << "loadMemberMap end runTimeSeconds()=" << runTimeSeconds() << __E__;
}  // end loadMemberMap()
 
//==============================================================================
void ConfigurationManager::loadTableGroup(
    const std::string&   groupName,
    const TableGroupKey& groupKey,
    bool                 doActivate /*=false*/,
    std::map<std::string /*table name*/, TableVersion>*
                 groupMembers /*=0 , note: db time intensive! */,
    ProgressBar* progressBar /*=0*/,
    std::string* accumulatedWarnings /*=0*/,
    std::string* groupComment /*=0 , note: in metadata */,
    std::string* groupAuthor /*=0 , note: in metadata */,
    std::string* groupCreateTime /*=0 , note: in metadata */,
    bool         doNotLoadMembers /*=false*/,
    std::string* groupTypeString /*=0 , note: db time intensive! */,
    std::map<std::string /*name*/, std::string /*alias*/>*
        groupAliases /*=0 , note: in metadata */,
    ConfigurationManager::LoadGroupType
         groupTypeToLoad /*=ConfigurationManager::LoadGroupType::ALL_TYPES*/,
    bool ignoreVersionTracking /*=false*/,
    std::map<std::string /* tableName */, TableVersion> mergInTables /*={}*/,
    std::map<std::string /* tableName */, TableVersion> overrideTables /*={}*/)
{
    // clear to defaults
    if(groupComment)
        *groupComment = ConfigurationManager::UNKNOWN_INFO;
    if(groupAuthor)
        *groupAuthor = ConfigurationManager::UNKNOWN_INFO;
    if(groupCreateTime)
        *groupCreateTime = ConfigurationManager::UNKNOWN_TIME;
    if(groupTypeString)
        *groupTypeString = ConfigurationManager::GROUP_TYPE_NAME_UNKNOWN;
    else
        __GEN_COUTT__ << "No group type requested." << __E__;
 
    //  if(groupName == "defaultConfig")
    //  { //debug active versions
    //      std::map<std::string, TableVersion> allActivePairs = getActiveVersions();
    //      for(auto& activePair: allActivePairs)
    //      {
    //          __GEN_COUT__ << "Active table = " <<
    //                  activePair.first << "-v" <<
    //                  getTableByName(activePair.first)->getView().getVersion() <<
    // __E__;
    //      }
    //  }
 
    //  load all members of configuration group
    //  if doActivate
    //      determine the type configuration
    //      deactivate all of that type (invalidate active view)
    //
    //  for each member
    //      get()
    //      if doActivate, configBase->init()
    //
    //  if doActivate
    //      set theConfigurationTableGroup_, theContextTableGroup_, or
    // theBackboneTableGroup_ on success
 
    __GEN_COUTT__ << "Loading Table Group: " << groupName << "(" << groupKey << ")"
                  << " accumulatedWarnings=" << (accumulatedWarnings ? 1 : 0) << __E__;
 
    //failing member map load should be an exception!
 
    std::map<std::string /*name*/, TableVersion /*version*/> memberMap =
        theInterface_->getTableGroupMembers(
            TableGroupKey::getFullGroupString(groupName, groupKey),
            true /*include meta data table*/);
 
    try
    {
        if(progressBar)
            progressBar->step();
 
        // remove meta data table and extract info
        auto metaTablePair = memberMap.find(TableBase::GROUP_METADATA_TABLE_NAME);
        if(metaTablePair != memberMap.end())
        {
            //only lock metadata table if metadata is needed
            if(groupAliases || groupComment || groupAuthor || groupCreateTime)
            {
                std::lock_guard<std::mutex> lock(metaDataTableMutex_);
 
                // clear table
                while(groupMetadataTable_.getView().getNumberOfRows())
                    groupMetadataTable_.getViewP()->deleteRow(0);
 
                // retrieve metadata from database
                try
                {
                    theInterface_->fill(&groupMetadataTable_, metaTablePair->second);
                }
                catch(const std::runtime_error& e)
                {
                    __GEN_COUT_WARN__
                        << "Failed to load " << groupMetadataTable_.getTableName() << "-v"
                        << metaTablePair->second << ". Metadata error: " << e.what()
                        << __E__;
                }
                catch(...)
                {
                    __GEN_COUT_WARN__
                        << "Failed to load " << groupMetadataTable_.getTableName() << "-v"
                        << metaTablePair->second << ". Ignoring unknown metadata error. "
                        << __E__;
                }
 
                // check that there is only 1 row
                if(groupMetadataTable_.getView().getNumberOfRows() != 1)
                {
                    groupMetadataTable_.print();
                    __GEN_COUT_ERR__ << "Ignoring that groupMetadataTable_ has wrong "
                                        "number of rows for '"
                                     << groupName << "(" << groupKey
                                     << ")!' Must "
                                        "be 1. Going with anonymous defaults."
                                     << __E__;
 
                    // fix metadata table
                    while(groupMetadataTable_.getViewP()->getNumberOfRows() > 1)
                        groupMetadataTable_.getViewP()->deleteRow(0);
                    if(groupMetadataTable_.getViewP()->getNumberOfRows() == 0)
                        groupMetadataTable_.getViewP()->addRow();
                }
                else
                {
                    // extract metadata fields
 
                    if(groupAliases)
                        StringMacros::getMapFromString(
                            groupMetadataTable_.getView().getValueAsString(
                                0, ConfigurationManager::METADATA_COL_ALIASES),
                            *groupAliases);
                    if(groupComment)
                        *groupComment = groupMetadataTable_.getView().getValueAsString(
                            0, ConfigurationManager::METADATA_COL_COMMENT);
                    if(groupAuthor)
                        *groupAuthor = groupMetadataTable_.getView().getValueAsString(
                            0, ConfigurationManager::METADATA_COL_AUTHOR);
                    if(groupCreateTime)
                        *groupCreateTime = groupMetadataTable_.getView().getValueAsString(
                            0, ConfigurationManager::METADATA_COL_TIMESTAMP);
                }
            }
 
            memberMap.erase(metaTablePair);  // remove from member map that is returned
 
        }  // end metadata handling
        else
        {
            __GEN_COUTT__ << "Ignoring that groupMetadataTable_ is missing for group '"
                          << groupName << "(" << groupKey
                          << "). Going with anonymous defaults." << __E__;
        }
 
        //NEVER modify members based on aliases
        //  Regarding Member Table Aliases: alias names are tracked in the metadata table,
        //      however! The group member versions are decided at group save time
        //      (loadTableGroup should always return the same groupName -> memberMap translation).
        //      The group member versions do not undergo alias translation at load time (i.e. loadTableGroup).
        //      The alias map can be retrieved using the groupAliases parameter.
        if(0)
        {
            std::map<std::string, std::string>& aliasMap = *groupAliases;
            std::map<std::string /*table*/, std::map<std::string /*alias*/, TableVersion>>
                versionAliases;
            if(aliasMap.size())  // load version aliases
            {
                __GEN_COUTV__(StringMacros::mapToString(aliasMap));
                versionAliases = ConfigurationManager::getVersionAliases();
                __GEN_COUTV__(StringMacros::mapToString(versionAliases));
            }
 
            // convert alias to version
            for(auto& aliasPair : aliasMap)
            {
                // check for alias table in member names
                if(memberMap.find(aliasPair.first) != memberMap.end())
                {
                    __GEN_COUT__ << "Group member '" << aliasPair.first
                                 << "' was found in group member map!" << __E__;
                    __GEN_COUT__ << "Looking for alias '" << aliasPair.second
                                 << "' in active version aliases..." << __E__;
 
                    if(versionAliases.find(aliasPair.first) == versionAliases.end() ||
                       versionAliases[aliasPair.first].find(aliasPair.second) ==
                           versionAliases[aliasPair.first].end())
                    {
                        __SS__ << "Group '" << groupName << "(" << groupKey
                               << ")' requires table version alias '" << aliasPair.first
                               << ":" << aliasPair.second
                               << ",' which was not found in the active Backbone!"
                               << __E__;
                        __SS_ONLY_THROW__;
                    }
 
                    memberMap[aliasPair.first] =
                        versionAliases[aliasPair.first][aliasPair.second];
                    __GEN_COUT__ << "Version alias translated to " << aliasPair.first
                                 << __E__;
                }
            }
        }  // end modify members based on aliases
 
        if(groupMembers)
            *groupMembers = memberMap;  // copy map for return
 
        if(progressBar)
            progressBar->step();
 
        ConfigurationManager::GroupType groupType =
            ConfigurationManager::GroupType::CONFIGURATION_TYPE;
        try
        {
            if(groupTypeString)  // do before exit case
            {
                groupType        = getTypeOfGroup(memberMap);
                *groupTypeString = convertGroupTypeToName(groupType);
            }
            else
                __GEN_COUTT__ << "No group type requested." << __E__;
 
            if(doNotLoadMembers)
                return;  //this is useful if just getting group metadata
 
            // if not already done, determine the type configuration group
            if(!groupTypeString)
                groupType = getTypeOfGroup(memberMap);
 
            if(groupTypeToLoad ==
                   ConfigurationManager::LoadGroupType::ONLY_BACKBONE_OR_CONTEXT_TYPES &&
               groupType != ConfigurationManager::GroupType::CONTEXT_TYPE &&
               groupType != ConfigurationManager::GroupType::BACKBONE_TYPE)
            {
                __GEN_COUT__ << "Not loading group because it is not of type Context or "
                                "Backbone (it is type '"
                             << convertGroupTypeToName(groupType) << "')." << __E__;
                return;
            }
            else if(groupTypeToLoad ==
                        ConfigurationManager::LoadGroupType::ONLY_BACKBONE_TYPE &&
                    groupType != ConfigurationManager::GroupType::BACKBONE_TYPE)
            {
                __GEN_COUT__ << "Not loading group because it is not of type "
                                "Backbone (it is type '"
                             << convertGroupTypeToName(groupType) << "')." << __E__;
                return;
            }
 
            __GEN_COUTTV__(StringMacros::mapToString(getActiveVersions()));
            if(doActivate)
                __GEN_COUT__
                    << "------------------------------------- init start    \t [for all "
                       "plug-ins in "
                    << convertGroupTypeToName(groupType) << " group '" << groupName << "("
                    << groupKey << ")"
                    << "']" << __E__;
 
            if(doActivate)
            {
                std::string groupToDeactivate =
                    groupType == ConfigurationManager::GroupType::CONTEXT_TYPE
                        ? theContextTableGroup_
                        : (groupType == ConfigurationManager::GroupType::BACKBONE_TYPE
                               ? theBackboneTableGroup_
                               : (groupType ==
                                          ConfigurationManager::GroupType::ITERATE_TYPE
                                      ? theIterateTableGroup_
                                      : theConfigurationTableGroup_));
 
                //      deactivate all of that type (invalidate active view)
                if(groupToDeactivate != "")  // deactivate only if pre-existing group
                {
                    __GEN_COUTT__ << "groupToDeactivate '" << groupToDeactivate
                                  << "' of type " << convertGroupTypeToName(groupType)
                                  << __E__;
                    destroyTableGroup(groupToDeactivate, true);
                }
                else
                {
                    //Getting here, is kind of strange:
                    //  - this group may have only been partially loaded before?
                    __GEN_COUTT__ << "no group to deactivate of type "
                                  << convertGroupTypeToName(groupType) << __E__;
                }
                __GEN_COUTTV__(StringMacros::mapToString(getActiveVersions()));
            }
 
            if(progressBar)
                progressBar->step();
 
            loadMemberMap(memberMap, accumulatedWarnings);
 
            if(progressBar)
                progressBar->step();
 
            __GEN_COUTT__ << "loadMemberMap() completed." << __E__;
 
            if(accumulatedWarnings)
            {
                __GEN_COUTT__ << "Checking chosen group for tree errors... here are the "
                                 "current warnings: "
                              << *accumulatedWarnings << __E__;
 
                getChildren(&memberMap, accumulatedWarnings);
                if(*accumulatedWarnings != "")
                {
                    __GEN_COUT_WARN__
                        << "Errors detected while loading Table Group: " << groupName
                        << "(" << groupKey << "). Ignoring the following errors: "
                        << "\n"
                        << *accumulatedWarnings << __E__;
                }
                __GEN_COUTT__ << "After checking children warnings: "
                              << *accumulatedWarnings << __E__;
            }
 
            if(progressBar)
                progressBar->step();
 
            __GEN_COUTT__ << "Tree view check complete." << __E__;
 
            //  for each member
            //      if doActivate, configBase->init()
            if(doActivate)
            {
                __GEN_COUTTV__(StringMacros::mapToString(getActiveVersions()));
 
                if(overrideTables.size())
                {
                    __GEN_COUT__ << "Overriding tables: "
                                 << StringMacros::mapToString(overrideTables) << __E__;
 
                    std::map<std::pair<std::string /*original table*/,
                                       std::string /*original uidB*/>,
                             std::string /*converted uidB*/>
                        uidConversionMap;
                    std::map<std::pair<std::string /*original table*/,
                                       std::pair<std::string /*group linkid*/,
                                                 std::string /*original gidB*/>>,
                             std::string /*converted gidB*/>
                        groupidConversionMap;
 
                    for(const auto& mergeInPair : overrideTables)
                    {
                        if(memberMap.find(mergeInPair.first) == memberMap.end())
                        {
                            __GEN_COUT__ << "Skipping override of table '"
                                         << mergeInPair.first << "-v"
                                         << mergeInPair.second
                                         << "' which is not in group " << groupName << "("
                                         << groupKey << ")." << __E__;
                            continue;
                        }
                        __GEN_COUT__ << "Overriding group member table '"
                                     << mergeInPair.first << "' v"
                                     << memberMap.at(mergeInPair.first)
                                     << " with version v" << mergeInPair.second << __E__;
 
                        std::stringstream mergeReport;
                        TableVersion      newVersion =
                            nameToTableMap_.at(mergeInPair.first)
                                ->mergeViews(
                                    getVersionedTableByName(
                                        mergeInPair.first,
                                        memberMap.at(mergeInPair.first))
                                        ->getView() /* sourceViewA */,
                                    getVersionedTableByName(mergeInPair.first,
                                                            mergeInPair.second)
                                        ->getView() /* sourceViewB*/,
                                    TableVersion() /* destinationVersion*/,
                                    "override-table",
                                    TableBase::MergeApproach::REPLACE,  //mergeApproach
                                    uidConversionMap,  //should not used for Replace mode
                                    groupidConversionMap,  //should not used for Replace mode
                                    false /* fillRecordConversionMaps */,
                                    true /* applyRecordConversionMaps */,
                                    false /* generateUniqueDataColumns */,
                                    &mergeReport);  // dont make destination version the first time
 
                        __GEN_COUTV__(newVersion);
                        nameToTableMap_.at(mergeInPair.first)->setActiveView(newVersion);
                        nameToTableMap_.at(mergeInPair.first)
                            ->getViewP()
                            ->setComment(nameToTableMap_.at(mergeInPair.first)
                                             ->getView()
                                             .getComment() +
                                         "\n" + mergeReport.str());
                        __GEN_COUT__ << "Overriding table '" << mergeInPair.first
                                     << "' resulting version v" << newVersion << __E__;
                        __GEN_COUTV__(mergeReport.str());
                    }  //end merge-in table loop
 
                    __GEN_COUTV__(StringMacros::mapToString(getActiveVersions()));
                }
 
                if(mergInTables.size())
                {
                    __GEN_COUT__ << "Merging-in tables: "
                                 << StringMacros::mapToString(mergInTables) << __E__;
 
                    std::map<std::pair<std::string /*original table*/,
                                       std::string /*original uidB*/>,
                             std::string /*converted uidB*/>
                        uidConversionMap;
                    std::map<std::pair<std::string /*original table*/,
                                       std::pair<std::string /*group linkid*/,
                                                 std::string /*original gidB*/>>,
                             std::string /*converted gidB*/>
                        groupidConversionMap;
 
                    for(const auto& mergeInPair : mergInTables)
                    {
                        if(memberMap.find(mergeInPair.first) == memberMap.end())
                        {
                            __GEN_COUT__ << "Skipping merging-in of table '"
                                         << mergeInPair.first << "-v"
                                         << mergeInPair.second
                                         << "' which is not in group " << groupName << "("
                                         << groupKey << ")." << __E__;
                            continue;
                        }
 
                        __GEN_COUT__ << "Merging-in group member table '"
                                     << mergeInPair.first << "' v"
                                     << memberMap.at(mergeInPair.first)
                                     << " with version v" << mergeInPair.second << __E__;
 
                        std::stringstream mergeReport;
                        TableVersion      newVersion =
                            nameToTableMap_.at(mergeInPair.first)
                                ->mergeViews(
                                    getVersionedTableByName(
                                        mergeInPair.first,
                                        memberMap.at(mergeInPair.first))
                                        ->getView() /* sourceViewA */,
                                    getVersionedTableByName(mergeInPair.first,
                                                            mergeInPair.second)
                                        ->getView() /* sourceViewB*/,
                                    TableVersion() /* destinationVersion*/,
                                    "merge-in-table",
                                    TableBase::MergeApproach::SKIP,  //mergeApproach
                                    uidConversionMap,      //should not used for Skip mode
                                    groupidConversionMap,  //should not used for Skip mode
                                    false /* fillRecordConversionMaps */,
                                    true /* applyRecordConversionMaps */,
                                    false /* generateUniqueDataColumns */,
                                    &mergeReport);  // dont make destination version the first time
 
                        __GEN_COUTV__(newVersion);
                        nameToTableMap_.at(mergeInPair.first)->setActiveView(newVersion);
                        nameToTableMap_.at(mergeInPair.first)
                            ->getViewP()
                            ->setComment(nameToTableMap_.at(mergeInPair.first)
                                             ->getView()
                                             .getComment() +
                                         "\n" + mergeReport.str());
                        __GEN_COUT__ << "Merging-in table '" << mergeInPair.first
                                     << "' resulting version v" << newVersion << __E__;
                        __GEN_COUTV__(mergeReport.str());
                    }  //end merge-in table loop
 
                    __GEN_COUTV__(StringMacros::mapToString(getActiveVersions()));
                }  //end merge-in table handling
 
                if(progressBar)
                    progressBar->step();
 
                const int numOfThreads = PROCESSOR_COUNT / 2;
                __GEN_COUTT__ << " PROCESSOR_COUNT " << PROCESSOR_COUNT << " ==> "
                              << numOfThreads
                              << " threads for initializing tables for Table Group '"
                              << groupName << "(" << groupKey << ")'." << __E__;
                if(groupType != ConfigurationManager::GroupType::CONFIGURATION_TYPE ||
                   numOfThreads < 2)  // no multi-threading
                {
                    for(auto& memberPair : memberMap)
                    {
                        // do NOT allow activating Scratch versions if tracking is ON!
                        if(!ignoreVersionTracking &&
                           ConfigurationInterface::isVersionTrackingEnabled() &&
                           memberPair.second.isScratchVersion())
                        {
                            __SS__
                                << "Error while activating member Table '"
                                << nameToTableMap_[memberPair.first]->getTableName()
                                << "-v" << memberPair.second << " for Table Group '"
                                << groupName << "(" << groupKey
                                << ")'. When version tracking is enabled, Scratch views"
                                << " are not allowed! Please only use unique, persistent "
                                   "versions when version tracking is enabled."
                                << __E__;
                            __SS_ONLY_THROW__;
                        }
 
                        // attempt to init using the configuration's specific init
                        //  this could be risky user code, try and catch
                        try
                        {
                            nameToTableMap_.at(memberPair.first)->init(this);
                        }
                        catch(std::runtime_error& e)
                        {
                            __SS__ << "Error detected calling " << memberPair.first
                                   << ".init()!\n\n " << e.what() << __E__;
 
                            if(accumulatedWarnings)
                            {
                                *accumulatedWarnings += ss.str();
                            }
                            else
                            {
                                ss << StringMacros::stackTrace();
                                __SS_ONLY_THROW__;
                            }
                        }
                        catch(...)
                        {
                            __SS__ << "Unknown Error detected calling "
                                   << memberPair.first << ".init()!\n\n " << __E__;
                            try
                            {
                                throw;
                            }  //one more try to printout extra info
                            catch(const std::exception& e)
                            {
                                ss << "Exception message: " << e.what();
                            }
                            catch(...)
                            {
                            }
                            //__SS_THROW__;
 
                            if(accumulatedWarnings)
                            {
                                *accumulatedWarnings += ss.str();
                            }
                            else  // ignore error
                                __GEN_COUT_WARN__ << ss.str();
                        }
                    }
                }
                else  //multi-threading
                {
                    int         threadsLaunched  = 0;
                    int         foundThreadIndex = 0;
                    std::string threadErrors;
                    std::mutex  threadMutex;  // to protect accumulatedWarnings
                    std::vector<std::shared_ptr<std::atomic<bool>>> threadDone;
                    for(int i = 0; i < numOfThreads; ++i)
                        threadDone.push_back(std::make_shared<std::atomic<bool>>(true));
 
                    if(!ignoreVersionTracking &&
                       ConfigurationInterface::isVersionTrackingEnabled())
                        for(auto& memberPair : memberMap)
                        {
                            // do NOT allow activating Scratch versions if tracking is ON!
                            if(memberPair.second.isScratchVersion())
                            {
                                __SS__
                                    << "Error while activating member Table '"
                                    << nameToTableMap_[memberPair.first]->getTableName()
                                    << "-v" << memberPair.second << " for Table Group '"
                                    << groupName << "(" << groupKey
                                    << ")'. When version tracking is enabled, Scratch "
                                       "views"
                                    << " are not allowed! Please only use unique, "
                                       "persistent "
                                       "versions when version tracking is enabled."
                                    << __E__;
                                __SS_ONLY_THROW__;
                            }
                        }
 
                    for(auto& memberPair : memberMap)
                    {
                        if(threadsLaunched >= numOfThreads)
                        {
                            //find availableThreadIndex
                            foundThreadIndex = -1;
                            while(foundThreadIndex == -1)
                            {
                                for(int i = 0; i < numOfThreads; ++i)
                                    if(*(threadDone[i]))
                                    {
                                        foundThreadIndex = i;
                                        break;
                                    }
                                if(foundThreadIndex == -1)
                                {
                                    __GEN_COUTT__ << "Waiting for available thread..."
                                                  << __E__;
                                    usleep(10000);
                                }
                            }  //end thread search loop
                            threadsLaunched = numOfThreads - 1;
                        }
                        __GEN_COUTT__ << "Starting init table thread... "
                                      << foundThreadIndex << " for " << memberPair.first
                                      << __E__;
                        *(threadDone[foundThreadIndex]) = false;
 
                        std::thread(
                            [](ConfigurationManager*              cfgMgr,
                               ots::TableBase*                    theTable,
                               std::string*                       theThreadErrors,
                               std::mutex*                        theThreadMutex,
                               std::shared_ptr<std::atomic<bool>> theThreadDone) {
                                ConfigurationManager::initTableThread(cfgMgr,
                                                                      theTable,
                                                                      theThreadErrors,
                                                                      theThreadMutex,
                                                                      theThreadDone);
                            },
                            this,
                            nameToTableMap_.at(memberPair.first),
                            &threadErrors,
                            &threadMutex,
                            threadDone[foundThreadIndex])
                            .detach();
 
                        ++threadsLaunched;
                        ++foundThreadIndex;
                    }  //end table init thread loop
 
                    //check for all threads done
                    do
                    {
                        foundThreadIndex = -1;
                        for(int i = 0; i < numOfThreads; ++i)
                            if(!*(threadDone[i]))
                            {
                                foundThreadIndex = i;
                                break;
                            }
                        if(foundThreadIndex != -1)
                        {
                            __GEN_COUTT__ << "Waiting for thread to finish... "
                                          << foundThreadIndex << __E__;
                            usleep(10000);
                        }
                    } while(foundThreadIndex != -1);  //end thread done search loop
                    __GEN_COUTT__ << "All threads done." << __E__;
 
                    if(threadErrors != "")
                    {
                        __SS__ << "Error identified in threads during init of table "
                                  "group: \n"
                               << threadErrors << __E__;
                        __GEN_COUTT__ << "\n" << ss.str() << __E__;
                        if(accumulatedWarnings)
                            *accumulatedWarnings += ss.str();
                        else
                            __SS_THROW__;
                    }
                }  //end multi-thread handling
 
                __GEN_COUTTV__(StringMacros::mapToString(getActiveVersions()));
            }  //end activate/init of member tables
 
            if(progressBar)
                progressBar->step();
 
            //  if doActivate
            //      set theConfigurationTableGroup_, theContextTableGroup_, or
            // theBackboneTableGroup_ on
            // success
 
            if(doActivate)
            {
                if(groupType == ConfigurationManager::GroupType::CONTEXT_TYPE)  //
                {
                    //          __GEN_COUT_INFO__ << "Type=Context, Group loaded: " <<
                    // groupName
                    //<<
                    //                  "(" << groupKey << ")" << __E__;
                    theContextTableGroup_ = groupName;
                    theContextTableGroupKey_ =
                        std::shared_ptr<TableGroupKey>(new TableGroupKey(groupKey));
                }
                else if(groupType == ConfigurationManager::GroupType::BACKBONE_TYPE)
                {
                    //          __GEN_COUT_INFO__ << "Type=Backbone, Group loaded: " <<
                    // groupName <<
                    //                  "(" << groupKey << ")" << __E__;
                    theBackboneTableGroup_ = groupName;
                    theBackboneTableGroupKey_ =
                        std::shared_ptr<TableGroupKey>(new TableGroupKey(groupKey));
                }
                else if(groupType == ConfigurationManager::GroupType::ITERATE_TYPE)
                {
                    //          __GEN_COUT_INFO__ << "Type=Iterate, Group loaded: " <<
                    // groupName
                    //<<
                    //                  "(" << groupKey << ")" << __E__;
                    theIterateTableGroup_ = groupName;
                    theIterateTableGroupKey_ =
                        std::shared_ptr<TableGroupKey>(new TableGroupKey(groupKey));
                }
                else  // is theConfigurationTableGroup_
                {
                    //          __GEN_COUT_INFO__ << "Type=Configuration, Group loaded: " <<
                    // groupName <<
                    //                  "(" << groupKey << ")" << __E__;
                    theConfigurationTableGroup_ = groupName;
                    theConfigurationTableGroupKey_ =
                        std::shared_ptr<TableGroupKey>(new TableGroupKey(groupKey));
                }
            }
 
            if(progressBar)
                progressBar->step();
 
            if(doActivate)
                __GEN_COUT__
                    << "------------------------------------- init complete \t [for all "
                       "plug-ins in "
                    << convertGroupTypeToName(groupType) << " group '" << groupName << "("
                    << groupKey << ")"
                    << "']" << __E__;
        }  // end failed group load try
        catch(...)
        {
            // save group name and key of failed load attempt
            lastFailedGroupLoad_[convertGroupTypeToName(groupType)] =
                std::pair<std::string, TableGroupKey>(groupName, TableGroupKey(groupKey));
 
            try
            {
                throw;
            }
            catch(const std::runtime_error& e)
            {
                __SS__ << "Error occurred while loading table group '" << groupName << "("
                       << groupKey << ")': \n"
                       << e.what() << __E__;
 
                if(accumulatedWarnings)
                    *accumulatedWarnings += ss.str();
                else
                    __SS_ONLY_THROW__;
            }
            catch(...)
            {
                __SS__ << "An unknown error occurred while loading table group '"
                       << groupName << "(" << groupKey << ")." << __E__;
                try
                {
                    throw;
                }  //one more try to printout extra info
                catch(const std::exception& e)
                {
                    ss << "Exception message: " << e.what();
                }
                catch(...)
                {
                }
                if(accumulatedWarnings)
                    *accumulatedWarnings += ss.str();
                else
                    __SS_ONLY_THROW__;
            }
        }
 
        __GEN_COUTT__ << "loadTableGroup() complete for Table Group '" << groupName << "("
                      << groupKey << ")'." << __E__;
        lastGroupLoad_[convertGroupTypeToName(groupType)] =
            std::make_pair(std::make_pair(groupName, TableGroupKey(groupKey)), memberMap);
        return;
    }
    catch(...)
    {
        __GEN_COUTT__ << "loadTableGroup() failed." << __E__;
 
        // save group name and key of failed load attempt
        lastFailedGroupLoad_[ConfigurationManager::GROUP_TYPE_NAME_UNKNOWN] =
            std::pair<std::string, TableGroupKey>(groupName, TableGroupKey(groupKey));
 
        try
        {
            throw;
        }
        catch(const std::runtime_error& e)
        {
            __SS__ << "Error occurred while loading table group '" << groupName << "("
                   << groupKey << ")': \n"
                   << e.what() << __E__;
 
            if(accumulatedWarnings)
                *accumulatedWarnings += ss.str();
            else
                __SS_ONLY_THROW__;
        }
        catch(...)
        {
            __SS__ << "An unknown error occurred while loading table group '" << groupName
                   << "(" << groupKey << ")." << __E__;
            try
            {
                throw;
            }  //one more try to printout extra info
            catch(const std::exception& e)
            {
                ss << "Exception message: " << e.what();
            }
            catch(...)
            {
            }
            __GEN_COUT__ << StringMacros::stackTrace();
 
            if(accumulatedWarnings)
                *accumulatedWarnings += ss.str();
            else
                __SS_ONLY_THROW__;
        }
    }
}  // end loadTableGroup()
 
//==============================================================================
void ConfigurationManager::copyTableGroupFromCache(
    const ConfigurationManager&                cacheConfigMgr,
    const std::map<std::string, TableVersion>& memberMap,
    const std::string&                         groupName /* = "" */,
    const TableGroupKey&                       groupKey /* = TableGroupKey::Invalid */,
    bool                                       doActivate /* = false */,
    bool                                       ignoreVersionTracking /* = false */)
{
    //Note: mostly copied from onfigurationManager::loadTableGroup()
 
    // determine the type table group type for activation and to save last loaded types
    ConfigurationManager::GroupType groupType = getTypeOfGroup(memberMap);
    try
    {
        if(doActivate)
            __GEN_COUT__ << "------------------------------------- cacheCopy init start  "
                            "  \t [for all "
                            "plug-ins in member map"
                         << "']" << __E__;
 
        if(doActivate)
        {
            std::string groupToDeactivate =
                groupType == ConfigurationManager::GroupType::CONTEXT_TYPE
                    ? theContextTableGroup_
                    : (groupType == ConfigurationManager::GroupType::BACKBONE_TYPE
                           ? theBackboneTableGroup_
                           : (groupType == ConfigurationManager::GroupType::ITERATE_TYPE
                                  ? theIterateTableGroup_
                                  : theConfigurationTableGroup_));
 
            // deactivate all of that type (invalidate active view)
            if(groupToDeactivate != "")  // deactivate only if pre-existing group
            {
                //__GEN_COUT__ << "groupToDeactivate '" << groupToDeactivate << "'" <<
                // __E__;
                destroyTableGroup(groupToDeactivate, true);
            }
            //      else
            //      {
            //          //Getting here, is kind of strange:
            //          //  - this group may have only been partially loaded before?
            //      }
        }
 
        //Now load member map, copied from ConfigurationManager::loadMemberMap
        // loadMemberMap(memberMap, accumulatedWarnings);
        //  for each member
        //      get()
        for(auto& memberPair : memberMap)
        {
            __GEN_COUTT__ << "Copying " << memberPair.first << "-v" << memberPair.second
                          << __E__;
 
            //if table does not exist, create it
            if(nameToTableMap_.find(memberPair.first) == nameToTableMap_.end())
            {
                TableBase* table = 0;
                theInterface_->get(table,             // configurationPtr
                                   memberPair.first,  // tableName
                                   0,                 // groupKey
                                   0,                 // groupName
                                   true               // dontFill=false to fill
                );
 
                nameToTableMap_[memberPair.first] = table;
            }
            nameToTableMap_.at(memberPair.first)
                ->copyView(cacheConfigMgr.getTableByName(memberPair.first)
                               ->getView(memberPair.second),
                           memberPair.second,
                           cacheConfigMgr.getTableByName(memberPair.first)
                               ->getView(memberPair.second)
                               .getAuthor(),
                           true /* looseColumnMatching */);
 
            //Note: copyView does not make the new view the active view,
            //  to make the new view the active view do this:
            //      nameToTableMap_.at(memberPair.first)->setActiveView(memberPair.second);
        }  //end member map copy loop
        __GEN_COUTT__ << "Done with member copy loop." << __E__;
 
        //  for each member
        //      if doActivate, configBase->init()
        if(doActivate)
        {
            std::string accumulatedWarnings;
            const int   numOfThreads = PROCESSOR_COUNT / 2;
            __GEN_COUT__ << " PROCESSOR_COUNT " << PROCESSOR_COUNT << " ==> "
                         << numOfThreads << " threads for initializing tables." << __E__;
            if(groupType != ConfigurationManager::GroupType::CONFIGURATION_TYPE ||
               numOfThreads < 2)  // no multi-threading
            {
                for(auto& memberPair : memberMap)
                {
                    // do NOT allow activating Scratch versions if tracking is ON!
                    if(!ignoreVersionTracking &&
                       ConfigurationInterface::isVersionTrackingEnabled() &&
                       memberPair.second.isScratchVersion())
                    {
                        __SS__ << "Error while activating member Table '"
                               << nameToTableMap_[memberPair.first]->getTableName()
                               << "-v" << memberPair.second
                               << " for member map. When version tracking is enabled, "
                                  "Scratch views"
                               << " are not allowed! Please only use unique, persistent "
                                  "versions when version tracking is enabled."
                               << __E__;
                        __SS_ONLY_THROW__;
                    }
 
                    // attempt to init using the configuration's specific init
                    //  this could be risky user code, try and catch
                    try
                    {
                        nameToTableMap_.at(memberPair.first)->init(this);
                    }
                    catch(std::runtime_error& e)
                    {
                        __SS__ << "Error detected calling " << memberPair.first
                               << ".init()!\n\n " << e.what() << __E__;
                        accumulatedWarnings += ss.str();
                    }
                    catch(...)
                    {
                        __SS__ << "Unknown Error detected calling " << memberPair.first
                               << ".init()!\n\n " << __E__;
                        try
                        {
                            throw;
                        }  //one more try to printout extra info
                        catch(const std::exception& e)
                        {
                            ss << "Exception message: " << e.what();
                        }
                        catch(...)
                        {
                        }
                        accumulatedWarnings += ss.str();
                    }
                }
            }
            else  //multi-threading
            {
                int        threadsLaunched  = 0;
                int        foundThreadIndex = 0;
                std::mutex threadMutex;  // to protect accumulatedWarnings
                std::vector<std::shared_ptr<std::atomic<bool>>> threadDone;
                for(int i = 0; i < numOfThreads; ++i)
                    threadDone.push_back(std::make_shared<std::atomic<bool>>(true));
 
                if(!ignoreVersionTracking &&
                   ConfigurationInterface::isVersionTrackingEnabled())
                    for(auto& memberPair : memberMap)
                    {
                        // do NOT allow activating Scratch versions if tracking is ON!
                        if(memberPair.second.isScratchVersion())
                        {
                            __SS__
                                << "Error while activating member Table '"
                                << nameToTableMap_[memberPair.first]->getTableName()
                                << "-v" << memberPair.second
                                << " for member map. When version tracking is enabled, "
                                   "Scratch views"
                                << " are not allowed! Please only use unique, persistent "
                                   "versions when version tracking is enabled."
                                << __E__;
                            __SS_ONLY_THROW__;
                        }
                    }
 
                for(auto& memberPair : memberMap)
                {
                    if(threadsLaunched >= numOfThreads)
                    {
                        //find availableThreadIndex
                        foundThreadIndex = -1;
                        while(foundThreadIndex == -1)
                        {
                            for(int i = 0; i < numOfThreads; ++i)
                                if(*(threadDone[i]))
                                {
                                    foundThreadIndex = i;
                                    break;
                                }
                            if(foundThreadIndex == -1)
                            {
                                __GEN_COUTT__ << "Waiting for available thread..."
                                              << __E__;
                                usleep(10000);
                            }
                        }  //end thread search loop
                        threadsLaunched = numOfThreads - 1;
                    }
                    __GEN_COUTT__ << "Starting init table thread... " << foundThreadIndex
                                  << " for " << memberPair.first << __E__;
                    *(threadDone[foundThreadIndex]) = false;
 
                    std::thread(
                        [](ConfigurationManager*              cfgMgr,
                           ots::TableBase*                    theTable,
                           std::string*                       theAccumulatedWarnings,
                           std::mutex*                        theThreadMutex,
                           std::shared_ptr<std::atomic<bool>> theThreadDone) {
                            ConfigurationManager::initTableThread(cfgMgr,
                                                                  theTable,
                                                                  theAccumulatedWarnings,
                                                                  theThreadMutex,
                                                                  theThreadDone);
                        },
                        this,
                        nameToTableMap_.at(memberPair.first),
                        &accumulatedWarnings,
                        &threadMutex,
                        threadDone[foundThreadIndex])
                        .detach();
 
                    ++threadsLaunched;
                    ++foundThreadIndex;
                }  //end table init thread loop
 
                //check for all threads done
                do
                {
                    foundThreadIndex = -1;
                    for(int i = 0; i < numOfThreads; ++i)
                        if(!*(threadDone[i]))
                        {
                            foundThreadIndex = i;
                            break;
                        }
                    if(foundThreadIndex != -1)
                    {
                        __GEN_COUTT__ << "Waiting for thread to finish... "
                                      << foundThreadIndex << __E__;
                        usleep(10000);
                    }
                } while(foundThreadIndex != -1);  //end thread done search loop
 
            }  //end multi-thread handling
 
            if(accumulatedWarnings != "")
            {
                __GEN_COUT__ << "Activating the member map after copying cache had the "
                                "following warnings: "
                             << accumulatedWarnings << __E__;
            }
        }  //end activate/init of member tables
 
        //  if doActivate
        //      set theConfigurationTableGroup_, theContextTableGroup_, or
        // theBackboneTableGroup_ on
        // success
 
        if(doActivate)
        {
            if(groupType == ConfigurationManager::GroupType::CONTEXT_TYPE)  //
            {
                //          __GEN_COUT_INFO__ << "Type=Context, Group loaded: " <<
                // groupName
                //<<
                //                  "(" << groupKey << ")" << __E__;
                theContextTableGroup_ = groupName;
                theContextTableGroupKey_ =
                    std::shared_ptr<TableGroupKey>(new TableGroupKey(groupKey));
            }
            else if(groupType == ConfigurationManager::GroupType::BACKBONE_TYPE)
            {
                //          __GEN_COUT_INFO__ << "Type=Backbone, Group loaded: " <<
                // groupName <<
                //                  "(" << groupKey << ")" << __E__;
                theBackboneTableGroup_ = groupName;
                theBackboneTableGroupKey_ =
                    std::shared_ptr<TableGroupKey>(new TableGroupKey(groupKey));
            }
            else if(groupType == ConfigurationManager::GroupType::ITERATE_TYPE)
            {
                //          __GEN_COUT_INFO__ << "Type=Iterate, Group loaded: " <<
                // groupName
                //<<
                //                  "(" << groupKey << ")" << __E__;
                theIterateTableGroup_ = groupName;
                theIterateTableGroupKey_ =
                    std::shared_ptr<TableGroupKey>(new TableGroupKey(groupKey));
            }
            else  // is theConfigurationTableGroup_
            {
                //          __GEN_COUT_INFO__ << "Type=Configuration, Group loaded: " <<
                // groupName <<
                //                  "(" << groupKey << ")" << __E__;
                theConfigurationTableGroup_ = groupName;
                theConfigurationTableGroupKey_ =
                    std::shared_ptr<TableGroupKey>(new TableGroupKey(groupKey));
            }
        }
 
        if(doActivate)
            __GEN_COUT__ << "------------------------------------- cacheCopy init "
                            "complete \t [for all "
                            "plug-ins in member map"
                         << "']" << __E__;
 
        __GEN_COUTT__ << "Completed cache copy." << __E__;
        if(groupName != "" && !TableGroupKey(groupKey).isInvalid())
            lastGroupLoad_[convertGroupTypeToName(groupType)] =
                make_pair(make_pair(groupName, TableGroupKey(groupKey)), memberMap);
    }  // end failed group load try
    catch(...)
    {
        __GEN_COUT__ << "Unknown failure in cache copy." << __E__;
        // save group name and key of failed load attempt
        lastFailedGroupLoad_[convertGroupTypeToName(groupType)] =
            std::pair<std::string, TableGroupKey>(groupName, TableGroupKey(groupKey));
        throw;
    }  //end unknown failure handling
}  // end copyTableGroupFromCache()
 
//==============================================================================
std::pair<std::string /* groupName */, TableGroupKey>
ConfigurationManager::getGroupOfLoadedTable(const std::string& tableName) const
{
    for(const auto& loadedGroup : lastGroupLoad_)  //search the loaded group member map
        if(loadedGroup.second.second.find(tableName) != loadedGroup.second.second.end())
            return loadedGroup.second.first;  //found! so return group name/key
    return std::make_pair("", TableGroupKey(TableGroupKey::INVALID));
}  // end getGroupOfLoadedTable()
 
//==============================================================================
void ConfigurationManager::initTableThread(ConfigurationManager* cfgMgr,
                                           ots::TableBase*       table,
                                           std::string*          threadErrors,
                                           std::mutex*           threadMutex,
                                           std::shared_ptr<std::atomic<bool>> threadDone)
try
{
    __COUTT__ << "Thread init of " << table->getTableName() << "-v"
              << table->getViewVersion() << " threadErrors=" << (threadErrors ? 1 : 0)
              << __E__;
 
    // attempt to init using the configuration's specific init
    //  this could be risky user code, try and catch
    try
    {
        __COUTTV__(StringMacros::mapToString(cfgMgr->getActiveVersions()));
        table->init(cfgMgr);
    }
    catch(std::runtime_error& e)
    {
        __SS__ << "Error detected calling " << table->getTableName() << ".init()!\n\n "
               << e.what() << __E__;
 
        if(threadErrors)
        {
            std::lock_guard<std::mutex> lock(*threadMutex);
            *threadErrors += ss.str();
        }
        else
        {
            ss << StringMacros::stackTrace();
            __SS_ONLY_THROW__;
        }
    }
    catch(...)
    {
        __SS__ << "Unknown Error detected calling " << table->getTableName()
               << ".init()!\n\n " << __E__;
        try
        {
            throw;
        }  //one more try to printout extra info
        catch(const std::exception& e)
        {
            ss << "Exception message: " << e.what();
        }
        catch(...)
        {
        }
 
        ss << StringMacros::stackTrace();
 
        if(threadErrors)
        {
            std::lock_guard<std::mutex> lock(*threadMutex);
            *threadErrors += ss.str();
        }
        else
            __SS_ONLY_THROW__;
    }
 
    *(threadDone) = true;
}  // end initTableThread()
catch(...)
{
    __SS__ << "Error occurred initializing table '" << table->getTableName() << "-v"
           << table->getViewVersion() << "'..." << __E__;
    try
    {
        throw;
    }
    catch(const std::runtime_error& e)
    {
        ss << " Run-time Exception message: " << e.what();
    }
    catch(const std::exception& e)
    {
        ss << " Exception message: " << e.what();
    }
    __COUT_WARN__ << ss.str() << __E__;
 
    if(threadErrors)
    {
        std::lock_guard<std::mutex> lock(*threadMutex);
        *threadErrors += ss.str();
    }
 
    *(threadDone) = true;
}  // end initTableThread catch
 
//==============================================================================
void ConfigurationManager::fillTableThread(
    ConfigurationInterface*                 theInterface,
    std::map<std::string, ots::TableBase*>* nameToTableMap,
    ots::TableBase*                         table,
    std::string                             tableName,
    ots::TableVersion                       version,
    std::string*                            threadErrors,
    std::mutex*                             threadMutex,
    std::shared_ptr<std::atomic<bool>>      threadDone)
try
{
    __COUTT__ << "Thread fill of " << tableName << "-v" << version << __E__;
 
    // std::map<std::string, ots::TableBase *> n;
    // std::map<std::string, ots::TableBase *>*nameToTableMap = &n;
    // ots::TableBase*                          table;
    // // ots::TableVersion                     v;
    // // ots::TableVersion*                        version = &v;
    // std::string                              a;
    // std::string*                         accumulatedWarnings = &a;
    // std::string tableName = "";
    std::string getError = "";
    // attempt to init using the configuration's specific init
    //  this could be risky user code, try and catch
    try
    {
        theInterface->get(table,      // tablePtr
                          tableName,  // tableName
                          0,          // groupKey
                          0,          // groupName
                          false,      // dontFill=false to fill
                          version,    // version
                          false       // resetTable
        );
    }
    catch(const std::runtime_error& e)
    {
        __SS__ << "Failed to load member table '" << tableName << "-v" << version
               << "' - here is the error: \n\n"
               << e.what() << __E__;
 
        ss << "\nIf the table '" << tableName
           << "' should not exist, then please remove it from the group. If it "
              "should exist, then it "
           << "seems to have a problem; use the Table Editor to fix the table "
              "definition, or "
              "edit the table content to match the table definition."
           << __E__;
 
        // if accumulating warnings and table view was created, then continue
        if(threadErrors)
            getError = ss.str();
        else
            __SS_ONLY_THROW__;
    }
    catch(...)
    {
        __SS__ << "Failed to load member table '" << tableName << "-v" << version
               << "' due to unknown error!" << __E__;
        try
        {
            throw;
        }  //one more try to printout extra info
        catch(const std::exception& e)
        {
            ss << "Exception message: " << e.what();
        }
        catch(...)
        {
        }
        ss << "\nIf the table '" << tableName
           << "' should not exist, then please remove it from the group. If it "
              "should exist, then it "
           << "seems to have a problem; use the Table Editor to fix the table "
              "definition, or "
              "edit the table content to match the table definition."
           << __E__;
 
        // if accumulating warnings and table view was created, then continue
        if(threadErrors)
            getError = ss.str();
        else
            __SS_THROW__;
    }
 
    if(getError != "")
        __COUTV__(getError);
 
    __COUT_TYPE__(TLVL_TRACE + 1)
        << __COUT_HDR__ << "Checking ptr.. " << (table ? "GOOD" : "BAD") << __E__;
    if(!table)
    {
        __SS__ << "Null pointer returned for table '" << tableName
               << ".' Was the table info deleted?" << __E__;
        __COUT_ERR__ << ss.str();
 
        std::lock_guard<std::mutex> lock(*threadMutex);
        nameToTableMap->erase(tableName);
 
        if(threadErrors)
        {
            *threadErrors += ss.str();
            *(threadDone) = true;
            return;
        }
        else
            __SS_ONLY_THROW__;
    }
    else
    {
        std::lock_guard<std::mutex> lock(*threadMutex);
        (*nameToTableMap)[tableName] = table;
    }
 
    if(nameToTableMap->at(tableName)->getViewP())
    {
        __COUT_TYPE__(TLVL_TRACE + 1)
            << __COUT_HDR__
            << "Activated version: " << nameToTableMap->at(tableName)->getViewVersion()
            << __E__;
 
        if(threadErrors && getError != "")
        {
            __SS__ << "Error caught during '" << tableName << "' table retrieval: \n"
                   << getError << __E__;
            __COUT_ERR__ << ss.str();
            std::lock_guard<std::mutex> lock(*threadMutex);
            *threadErrors += ss.str();
        }
    }
    else
    {
        __SS__ << tableName << ": View version not activated properly!";
        __SS_THROW__;
    }
 
    __COUTT__ << "end Thread fill of " << tableName << "-v" << version << __E__;
    *(threadDone) = true;
}  // end fillTableThread()
catch(const std::runtime_error& e)
{
    __SS__ << "Error occurred filling table '" << tableName << "-v" << version
           << "': " << e.what() << __E__;
    __COUT_ERR__ << ss.str();
 
    if(threadErrors)
    {
        std::lock_guard<std::mutex> lock(*threadMutex);
        *threadErrors += ss.str();
    }
 
    *(threadDone) = true;
}
catch(...)
{
    __SS__ << "Unknwon error occurred filling table '" << tableName << "-v" << version
           << "'..." << __E__;
    try
    {
        throw;
    }  //one more try to printout extra info
    catch(const std::exception& e)
    {
        ss << "Exception message: " << e.what();
    }
    catch(...)
    {
    }
    __COUT_ERR__ << ss.str();
 
    if(threadErrors)
    {
        std::lock_guard<std::mutex> lock(*threadMutex);
        *threadErrors += ss.str();
    }
 
    *(threadDone) = true;
}  // end fillTableThread catch
 
//==============================================================================
TableBase* ConfigurationManager::getVersionedTableByName(
    const std::string& tableName,
    TableVersion       version,
    bool               looseColumnMatching /* = false */,
    std::string*       accumulatedErrors /* = 0 */,
    bool               getRawData /* = false */,
    bool               touchLastAccessTime /* = true */)
{
    auto it = nameToTableMap_.find(tableName);
    if(it == nameToTableMap_.end())
    {
        __SS__ << "\nCan not find table named '" << tableName
               << "'\n\n\n\nYou need to load the table before it can be used."
               << "It probably is missing from the member list of the Table "
                  "Group that was loaded?\n\n\n\n\n"
               << __E__;
        __SS_THROW__;
    }
    TableBase* table = it->second;
 
    if(version.isTemporaryVersion())
    {
        table->setActiveView(version);
 
        if(getRawData)
        {
            std::stringstream jsonSs;
            table->getViewP()->printJSON(jsonSs);
            table->getViewP()->doGetSourceRawData(true);
            table->getViewP()->fillFromJSON(jsonSs.str());
        }
    }
    else
    {
        theInterface_->get(table,
                           tableName,
                           0 /* groupKey */,
                           0 /* groupName */,
                           false /* dontFill */,  // false to fill w/version
                           version,
                           false /* resetConfiguration*/,  // false to not reset
                           looseColumnMatching,
                           getRawData,
                           accumulatedErrors,
                           touchLastAccessTime);
    }
    return table;
}  // end getVersionedTableByName()
 
//==============================================================================
std::map<std::string, std::pair<std::string, TableGroupKey>>
ConfigurationManager::getActiveTableGroups(void) const
{
    //   map<type,        pair     <groupName  , TableGroupKey> >
    std::map<std::string, std::pair<std::string, TableGroupKey>> retMap;
 
    retMap[ConfigurationManager::GROUP_TYPE_NAME_CONTEXT] =
        std::pair<std::string, TableGroupKey>(
            theContextTableGroup_,
            theContextTableGroupKey_ ? *theContextTableGroupKey_ : TableGroupKey());
    retMap[ConfigurationManager::GROUP_TYPE_NAME_BACKBONE] =
        std::pair<std::string, TableGroupKey>(
            theBackboneTableGroup_,
            theBackboneTableGroupKey_ ? *theBackboneTableGroupKey_ : TableGroupKey());
    retMap[ConfigurationManager::GROUP_TYPE_NAME_ITERATE] =
        std::pair<std::string, TableGroupKey>(
            theIterateTableGroup_,
            theIterateTableGroupKey_ ? *theIterateTableGroupKey_ : TableGroupKey());
    retMap[ConfigurationManager::GROUP_TYPE_NAME_CONFIGURATION] =
        std::pair<std::string, TableGroupKey>(theConfigurationTableGroup_,
                                              theConfigurationTableGroupKey_
                                                  ? *theConfigurationTableGroupKey_
                                                  : TableGroupKey());
    return retMap;
}  // end getActiveTableGroups()
 
//==============================================================================
const std::string& ConfigurationManager::getActiveGroupName(
    const ConfigurationManager::GroupType& type) const
{
    if(type == ConfigurationManager::GroupType::CONFIGURATION_TYPE)
        return theConfigurationTableGroup_;
    else if(type == ConfigurationManager::GroupType::CONTEXT_TYPE)
        return theContextTableGroup_;
    else if(type == ConfigurationManager::GroupType::BACKBONE_TYPE)
        return theBackboneTableGroup_;
    else if(type == ConfigurationManager::GroupType::ITERATE_TYPE)
        return theIterateTableGroup_;
 
    __SS__ << "IMPOSSIBLE! Invalid type requested '" << (int)type << "'" << __E__;
    __SS_THROW__;
}  // end getActiveGroupName()
 
//==============================================================================
TableGroupKey ConfigurationManager::getActiveGroupKey(
    const ConfigurationManager::GroupType& type) const
{
    if(type == ConfigurationManager::GroupType::CONFIGURATION_TYPE)
        return theConfigurationTableGroupKey_ ? *theConfigurationTableGroupKey_
                                              : TableGroupKey();
    else if(type == ConfigurationManager::GroupType::CONTEXT_TYPE)
        return theContextTableGroupKey_ ? *theContextTableGroupKey_ : TableGroupKey();
    else if(type == ConfigurationManager::GroupType::BACKBONE_TYPE)
        return theBackboneTableGroupKey_ ? *theBackboneTableGroupKey_ : TableGroupKey();
    else if(type == ConfigurationManager::GroupType::ITERATE_TYPE)
        return theIterateTableGroupKey_ ? *theIterateTableGroupKey_ : TableGroupKey();
 
    __SS__ << "IMPOSSIBLE! Invalid type requested '" << (int)type << "'" << __E__;
    __SS_THROW__;
}  // end getActiveGroupKey()
 
//==============================================================================
ConfigurationTree ConfigurationManager::getContextNode(
    const std::string& contextUID, const std::string& /*applicationUID*/) const
{
    return getNode("/" + getTableByName(XDAQ_CONTEXT_TABLE_NAME)->getTableName() + "/" +
                   contextUID);
}  // end getContextNode()
 
//==============================================================================
ConfigurationTree ConfigurationManager::getSupervisorNode(
    const std::string& contextUID, const std::string& applicationUID) const
{
    return getNode("/" + getTableByName(XDAQ_CONTEXT_TABLE_NAME)->getTableName() + "/" +
                   contextUID + "/LinkToApplicationTable/" + applicationUID);
}  // end getSupervisorNode()
 
//==============================================================================
ConfigurationTree ConfigurationManager::getSupervisorTableNode(
    const std::string& contextUID, const std::string& applicationUID) const
{
    return getNode("/" + getTableByName(XDAQ_CONTEXT_TABLE_NAME)->getTableName() + "/" +
                   contextUID + "/LinkToApplicationTable/" + applicationUID +
                   "/LinkToSupervisorTable");
}  // end getSupervisorTableNode()
 
//==============================================================================
ConfigurationTree ConfigurationManager::getGatewaySupervisorNode() const
{
    auto contextChildren =
        getNode("/" + getTableByName(XDAQ_CONTEXT_TABLE_NAME)->getTableName())
            .getChildren();
    for(const auto& contextChild : contextChildren)
    {
        auto appChildren = contextChild.second.getNode("LinkToApplicationTable")
                               .getChildren();  //colContext_.colLinkToApplicationTable_
        for(const auto& appChild : appChildren)
        {
            if(appChild.second.getNode("Class").getValue() ==
               "ots::GatewaySupervisor")  //colApplication_.colClass_ ... XDAQContextTable::GATEWAY_SUPERVISOR_CLASS)
                return appChild.second;
        }
    }
    __SS__ << "No Gateway Supervisor node found!" << __E__;
    __SS_THROW__;
}  // end getGatewaySupervisorNode()
 
//==============================================================================
ConfigurationTree ConfigurationManager::getNode(const std::string& nodeString,
                                                bool doNotThrowOnBrokenUIDLinks) const
{
    // __GEN_COUT__ << "nodeString=" << nodeString << " len=" << nodeString.length() << __E__;
 
    // get nodeName (in case of / syntax)
    if(nodeString.length() < 1)
    {
        __SS__ << ("Invalid empty node name") << __E__;
        __GEN_SS_THROW__;
    }
 
    // ignore multiple starting slashes
    size_t startingIndex = 0;
    while(startingIndex < nodeString.length() && nodeString[startingIndex] == '/')
        ++startingIndex;
    size_t endingIndex = nodeString.find('/', startingIndex);
    if(endingIndex == std::string::npos)
        endingIndex = nodeString.length();
 
    std::string nodeName = nodeString.substr(startingIndex, endingIndex - startingIndex);
    // __GEN_COUT__ << "nodeName=" << nodeName << " len" << nodeName.length() << __E__;
    if(nodeName.length() < 1)
    {
        // return root node
        return ConfigurationTree(this, 0);
 
        //      __SS__ << "Invalid node name: " << nodeName << __E__;
        //      __GEN_COUT_ERR__ << ss.str();
        //      __SS_THROW__;
    }
    ++endingIndex;
    std::string childPath =
        (endingIndex >= nodeString.length() ? "" : nodeString.substr(endingIndex));
 
    // __GEN_COUT__ << "childPath=" << childPath << " len=" << childPath.length() << " endingIndex=" << endingIndex << " nodeString.length()=" << nodeString.length() << __E__;
 
    ConfigurationTree configTree(this, getTableByName(nodeName));
 
    if(childPath.length() > 1)
        return configTree.getNode(childPath, doNotThrowOnBrokenUIDLinks);
    else
        return configTree;
}  // end getNode()
 
//==============================================================================
std::map<std::string, ConfigurationTree> ConfigurationManager::getNodes(
    const std::string& nodeString) const
{
    return getNode(nodeString).getChildrenMap();
}
 
//==============================================================================
std::string ConfigurationManager::getFirstPathToNode(
    const ConfigurationTree& /*node*/, const std::string& /*startPath*/) const
{
    std::string path = "/";
    return path;
}  // end getFirstPathToNode()
 
//==============================================================================
std::vector<std::pair<std::string, ConfigurationTree>> ConfigurationManager::getChildren(
    std::map<std::string, TableVersion>* memberMap,
    std::string*                         accumulatedTreeErrors) const
{
    std::vector<std::pair<std::string, ConfigurationTree>> retVector;
 
    // if(accumulatedTreeErrors)
    //  *accumulatedTreeErrors = "";
 
    bool filtering = memberMap && memberMap->size();
 
    //from root node, want active tables:
    for(auto& tablePair : nameToTableMap_)
    {
        if(filtering)
        {
            //if not in member map, ignore
            if(memberMap->find(tablePair.first) == memberMap->end())
                continue;
 
            //if in member map, and not active - that is a problem!
            try
            {
                if(!tablePair.second->isActive())
                {
                    __SS__ << "Get Children with member map requires a child '"
                           << tablePair.first << "' that is not active!" << __E__;
                    __SS_THROW__;
                }
            }
            catch(const std::runtime_error& e)
            {
                if(accumulatedTreeErrors)
                {
                    *accumulatedTreeErrors += e.what();
                    __GEN_COUT_ERR__ << "Skipping " << tablePair.first
                                     << " since the table "
                                        "is not active."
                                     << __E__;
                    continue;
                }
                throw;
            }
        }
 
        if(!tablePair.second->isActive())  // only consider if active
            continue;
 
        ConfigurationTree newNode(this, tablePair.second);
        if(accumulatedTreeErrors)  // check for disconnects
        {
            try
            {
                std::vector<std::pair<std::string, ConfigurationTree>> newNodeChildren =
                    newNode.getChildren();
                for(auto& newNodeChild : newNodeChildren)
                {
                    if(newNodeChild.second.getTableName() ==
                           ConfigurationManager::DESKTOP_ICON_TABLE_NAME &&
                       !newNodeChild.second.isEnabled())
                        continue;  //skip check for Desktop Icons that are disabled.
 
                    std::vector<std::pair<std::string, ConfigurationTree>>
                        twoDeepChildren = newNodeChild.second.getChildren();
 
                    for(auto& twoDeepChild : twoDeepChildren)
                    {
                        //__GEN_COUT__ << tablePair.first << " " <<
                        // newNodeChild.first << " " <<         twoDeepChild.first
                        // <<  __E__;
                        if(twoDeepChild.second.isLinkNode() &&
                           twoDeepChild.second.isDisconnected() &&
                           twoDeepChild.second.getDisconnectedTableName() !=
                               TableViewColumnInfo::DATATYPE_LINK_DEFAULT)
                        {
                            __SS__ << "At node '" + tablePair.first +
                                          "' with entry UID '" + newNodeChild.first +
                                          "' there is a disconnected child node at link "
                                          "column '" +
                                          twoDeepChild.first + "'" +
                                          " that points to table named '" +
                                          twoDeepChild.second.getDisconnectedTableName() +
                                          "' ...";
                            *accumulatedTreeErrors += ss.str();
                        }
                    }
                }
            }
            catch(std::runtime_error& e)
            {
                __SS__ << "At node '" + tablePair.first +
                              "' error detected descending through children:\n" +
                              e.what();
                *accumulatedTreeErrors += ss.str();
            }
        }  // done checking for disconnects
 
        retVector.push_back(
            std::pair<std::string, ConfigurationTree>(tablePair.first, newNode));
    }  //end active table loop
 
    return retVector;
}  // end getChildren()
 
//==============================================================================
std::map<std::string /* childName */, ConfigurationTree>
ConfigurationManager::getChildrenMap(std::map<std::string, TableVersion>* memberMap,
                                     std::string* accumulatedTreeErrors) const
{
    std::map<std::string /* childName */, ConfigurationTree> retMap;
 
    // if(accumulatedTreeErrors)
    //  *accumulatedTreeErrors = "";
 
    bool filtering = memberMap && memberMap->size();
 
    //from root node, want active tables:
    for(auto& tablePair : nameToTableMap_)
    {
        if(filtering)
        {
            //if not in member map, ignore
            if(memberMap->find(tablePair.first) == memberMap->end())
                continue;
 
            //if in member map, and not active - that is a problem!
            try
            {
                if(!tablePair.second->isActive())
                {
                    __SS__ << "Get Children with member map requires a child '"
                           << tablePair.first << "' that is not active!" << __E__;
                    __SS_THROW__;
                }
            }
            catch(const std::runtime_error& e)
            {
                if(accumulatedTreeErrors)
                {
                    *accumulatedTreeErrors += e.what();
                    __GEN_COUT_ERR__ << "Skipping " << tablePair.first
                                     << " since the table "
                                        "is not active."
                                     << __E__;
                    continue;
                }
                throw;
            }
        }
 
        if(!tablePair.second->isActive())  // only consider if active
            continue;
 
        ConfigurationTree newNode(this, tablePair.second);
        if(accumulatedTreeErrors)  // check for disconnects
        {
            try
            {
                std::vector<std::pair<std::string, ConfigurationTree>> newNodeChildren =
                    newNode.getChildren();
                for(auto& newNodeChild : newNodeChildren)
                {
                    if(newNodeChild.second.getTableName() ==
                           ConfigurationManager::DESKTOP_ICON_TABLE_NAME &&
                       !newNodeChild.second.isEnabled())
                        continue;  //skip check for Desktop Icons that are disabled.
 
                    std::vector<std::pair<std::string, ConfigurationTree>>
                        twoDeepChildren = newNodeChild.second.getChildren();
 
                    for(auto& twoDeepChild : twoDeepChildren)
                    {
                        //__GEN_COUT__ << tablePair.first << " " <<
                        // newNodeChild.first << " " <<         twoDeepChild.first
                        // <<  __E__;
                        if(twoDeepChild.second.isLinkNode() &&
                           twoDeepChild.second.isDisconnected() &&
                           twoDeepChild.second.getDisconnectedTableName() !=
                               TableViewColumnInfo::DATATYPE_LINK_DEFAULT)
                        {
                            __SS__ << "At node '" + tablePair.first +
                                          "' with entry UID '" + newNodeChild.first +
                                          "' there is a disconnected child node at link "
                                          "column '" +
                                          twoDeepChild.first + "'" +
                                          " that points to table named '" +
                                          twoDeepChild.second.getDisconnectedTableName() +
                                          "' ...";
                            *accumulatedTreeErrors += ss.str();
                        }
                    }
                }
            }
            catch(std::runtime_error& e)
            {
                __SS__ << "At node '" + tablePair.first +
                              "' error detected descending through children:\n" +
                              e.what();
                *accumulatedTreeErrors += ss.str();
            }
        }  // done checking for disconnects
 
        retMap.emplace(
            std::pair<std::string, ConfigurationTree>(tablePair.first, newNode));
    }  //end active table loop
 
    return retMap;
}  // end getChildrenMap()
 
//==============================================================================
const TableBase* ConfigurationManager::getTableByName(const std::string& tableName) const
{
    std::map<std::string, TableBase*>::const_iterator it;
    if((it = nameToTableMap_.find(tableName)) == nameToTableMap_.end())
    {
        __SS__ << "Cannot find table named '" << tableName
               << "' - you need to load the table before it can be used.";
 
        if(nameToTableMap_.size() == 0)
            ss << "\n\nAll tables are missing. Your configuration database connection "
                  "may have been interrupted. Did an ssh tunnel disconnect?"
               << __E__;
        else
        {
            if(tableName == XDAQ_CONTEXT_TABLE_NAME)
                ss << "\n\nThe XDAQ Context Table is essential to the operation of ots. "
                      "Without it, ots can not determine which applications are running "
                      "on which hosts. Make sure that you have loaded a valid "
                      "Configuration Context group that contains the XDAQ Context "
                      "Table."
                   << __E__;
            else
                ss << " It is likely missing from the member list of the Table "
                      "Group that was loaded."
                   << __E__;
 
            ss << "\nYou may need to enter wiz mode to remedy the situation, use the "
                  "following:\n"
                  "\n\t ots --wiz"
                  "\n\n\n"
               << __E__;
 
            ss << __E__ << StringMacros::stackTrace() << __E__;
        }
 
        __SS_ONLY_THROW__;
    }
    TLOG_DEBUG(55) << "Table " << tableName << " is at "
                   << static_cast<void*>(it->second);
    return it->second;
}  // end getTableByName()
 
//==============================================================================
TableGroupKey ConfigurationManager::loadConfigurationBackbone()
{
    if(!theBackboneTableGroupKey_)  // no active backbone
    {
        __GEN_COUT_WARN__ << "getTableGroupKey() Failed! No active backbone currently."
                          << __E__;
        return TableGroupKey();
    }
 
    // may already be loaded, but that's ok, load anyway to be sure
    loadTableGroup(theBackboneTableGroup_, *theBackboneTableGroupKey_);
 
    return *theBackboneTableGroupKey_;
}  // end loadConfigurationBackbone()
 
//==============================================================================
std::pair<std::string, TableGroupKey> ConfigurationManager::getTableGroupFromAlias(
    std::string systemAlias, ProgressBar* progressBar)
{
    // steps
    //  check if special alias
    //  if so, parse and return name/key
    //  else, load active backbone
    //  find runType in Group Aliases table
    //  return key
 
    if(progressBar)
        progressBar->step();
 
    if(systemAlias.find("GROUP:") == 0)
    {
        if(progressBar)
            progressBar->step();
 
        unsigned int i = strlen("GROUP:");
        unsigned int j = systemAlias.find(':', i);
 
        if(progressBar)
            progressBar->step();
        if(j > i)  // success
            return std::pair<std::string, TableGroupKey>(
                systemAlias.substr(i, j - i), TableGroupKey(systemAlias.substr(j + 1)));
        else  // failure
            return std::pair<std::string, TableGroupKey>("", TableGroupKey());
    }
 
    loadConfigurationBackbone();
 
    if(progressBar)
        progressBar->step();
 
    try
    {
        //  find runType in Group Aliases table
        ConfigurationTree entry =
            getNode(ConfigurationManager::GROUP_ALIASES_TABLE_NAME).getNode(systemAlias);
 
        if(progressBar)
            progressBar->step();
 
        return std::pair<std::string, TableGroupKey>(
            entry.getNode("GroupName").getValueAsString(),
            TableGroupKey(entry.getNode("GroupKey").getValueAsString()));
    }
    catch(...)
    {
    }
 
    // on failure, here
 
    if(progressBar)
        progressBar->step();
 
    return std::pair<std::string, TableGroupKey>("", TableGroupKey());
}  // end getTableGroupFromAlias()
 
//==============================================================================
std::map<std::string /*groupAlias*/, std::pair<std::string /*groupName*/, TableGroupKey>>
ConfigurationManager::getActiveGroupAliases(void)
{
    restoreActiveTableGroups(
        false /* throwErrors */,
        "" /* pathToActiveGroupsFile */,
        ConfigurationManager::LoadGroupType::
            ONLY_BACKBONE_TYPE);  // make sure the active configuration backbone is
    // loaded from disk (i.e. the latest activated at the ConfigurationGUISupervisor)!
 
    std::map<std::string /*groupAlias*/,
             std::pair<std::string /*groupName*/, TableGroupKey>>
        retMap;
 
    std::vector<std::pair<std::string, ConfigurationTree>> entries =
        getNode(ConfigurationManager::GROUP_ALIASES_TABLE_NAME).getChildren();
    for(auto& entryPair : entries)
    {
        retMap[entryPair.first] = std::pair<std::string, TableGroupKey>(
            entryPair.second.getNode("GroupName").getValueAsString(),
            TableGroupKey(entryPair.second.getNode("GroupKey").getValueAsString()));
    }
    return retMap;
}  // end getActiveGroupAliases()
 
//==============================================================================
std::set<std::pair<std::string /*table name*/, TableVersion /*aliased version*/>>
ConfigurationManager::getVersionAliases(const std::string& tableAliasNeedle) const
{
    std::set<std::pair<std::string /*table name*/, TableVersion /*aliased version*/>>
        retSet;
 
    auto tableAliasMap = getVersionAliases();
 
    for(auto& tableAliasMap : tableAliasMap)
        for(auto& tableAliasPair : tableAliasMap.second)
            if(tableAliasPair.first == tableAliasNeedle)  //then table alias match!
                retSet.insert(std::pair<std::string /*table name*/,
                                        TableVersion /*aliased version*/>(
                    tableAliasMap.first, tableAliasPair.second));
 
    return retSet;
}  //end getVersionAliases()
 
//==============================================================================
std::map<std::string /*table name*/,
         std::map<std::string /*version alias*/, TableVersion /*aliased version*/>>
ConfigurationManager::getVersionAliases(void) const
{
    //__GEN_COUT__ << "getVersionAliases()" << __E__;
 
    std::map<std::string /*table name*/,
             std::map<std::string /*version alias*/, TableVersion /*aliased version*/>>
        retMap;
 
    std::map<std::string, TableVersion> activeVersions = getActiveVersions();
    std::string                         versionAliasesTableName =
        ConfigurationManager::VERSION_ALIASES_TABLE_NAME;
    if(activeVersions.find(versionAliasesTableName) == activeVersions.end())
    {
        __SS__ << "Active version of VersionAliases  missing!"
               << " Make sure you have a valid active Backbone Group." << __E__;
        __GEN_COUT_WARN__ << "\n" << ss.str();
        return retMap;
    }
 
    //__GEN_COUT__ << "activeVersions[\"" << versionAliasesTableName << "\"]=" << activeVersions[versionAliasesTableName] << __E__;
 
    std::vector<std::pair<std::string, ConfigurationTree>> aliasNodePairs =
        getNode(versionAliasesTableName).getChildren();
 
    // create map
    //  add the first of each tableName, versionAlias pair encountered
    //  ignore any repeats (Note: this also prevents overwriting of Scratch alias)
    std::string tableName, versionAlias;
    for(auto& aliasNodePair : aliasNodePairs)
    {
        tableName    = aliasNodePair.second.getNode("TableName").getValueAsString();
        versionAlias = aliasNodePair.second.getNode("VersionAlias").getValueAsString();
 
        if(retMap.find(tableName) != retMap.end() &&
           retMap[tableName].find(versionAlias) != retMap[tableName].end())
            continue;  // skip repeats (Note: this also prevents overwriting of Scratch
                       // alias)
 
        // else add version to map
        retMap[tableName][versionAlias] =
            TableVersion(aliasNodePair.second.getNode("Version").getValueAsString());
    }
 
    return retMap;
}  // end getVersionAliases()
 
//==============================================================================
std::map<std::string, TableVersion> ConfigurationManager::getActiveVersions(void) const
{
    std::map<std::string, TableVersion> retMap;
    for(auto& table : nameToTableMap_)
    {
        __GEN_COUTS__(2) << table.first << __E__;
 
        // check configuration pointer is not null and that there is an active view
        if(table.second && table.second->isActive())
        {
            __GEN_COUTS__(2) << table.first << "_v" << table.second->getViewVersion()
                             << __E__;
            retMap.insert(std::pair<std::string, TableVersion>(
                table.first, table.second->getViewVersion()));
        }
    }
 
    return retMap;
}  // end getActiveVersions()
 
//{
//
//  //fixme/todo this is called before setupAll so it breaks!
//  //====================================================
//  const DetectorConfiguration* detectorConfiguration =
//__GET_CONFIG__(DetectorConfiguration);    for(auto& type :
// detectorConfiguration->getDetectorTypes())       theDACsConfigurations_[type] =
//(DACsTableBase*)(getTableByName(type + "DACsConfiguration"));
//  //====================================================
//
//  theDACStreams_[fecName].makeStream(fecName,
//          __GET_CONFIG__(DetectorConfiguration),
//          __GET_CONFIG__(DetectorToFEConfiguration),
//          theDACsConfigurations_,
//          __GET_CONFIG__(MaskConfiguration));//, theTrimConfiguration_);
//
//  __GEN_COUT__ << "Done with DAC stream!" << __E__;
//  return theDACStreams_[fecName];
//}
 
//==============================================================================
std::shared_ptr<TableGroupKey> ConfigurationManager::makeTheTableGroupKey(
    TableGroupKey key)
{
    if(theConfigurationTableGroupKey_)
    {
        if(*theConfigurationTableGroupKey_ != key)
            destroyTableGroup();
        else
            return theConfigurationTableGroupKey_;
    }
    return std::shared_ptr<TableGroupKey>(new TableGroupKey(key));
}  // end makeTheTableGroupKey()
 
//==============================================================================
const std::set<std::string>& ConfigurationManager::getActiveContextMemberNames()
{
    //copy fixed context tables, then add optional tables if active
    contextMemberNames_ = ConfigurationManager::fixedContextMemberNames_;
 
    auto it =
        nameToTableMap_.find(ConfigurationManager::CONTEXT_SUBSYSTEM_OPTIONAL_TABLE);
    if(it == nameToTableMap_.end())
        return contextMemberNames_;
 
    if(!it->second->isActive())  //if optional table is active, add it
    {
        contextMemberNames_.emplace(
            ConfigurationManager::CONTEXT_SUBSYSTEM_OPTIONAL_TABLE);
    }
    return contextMemberNames_;
}  // end getContextMemberNames()
 
//==============================================================================
const std::set<std::string>& ConfigurationManager::getFixedContextMemberNames()
{
    return ConfigurationManager::fixedContextMemberNames_;
}  // end getContextMemberNames()
 
//==============================================================================
const std::set<std::string>& ConfigurationManager::getBackboneMemberNames()
{
    return ConfigurationManager::backboneMemberNames_;
}  // end getBackboneMemberNames()
 
//==============================================================================
const std::set<std::string>& ConfigurationManager::getIterateMemberNames()
{
    return ConfigurationManager::iterateMemberNames_;
}  // end getIterateMemberNames()
 
//==============================================================================
const std::set<std::string>& ConfigurationManager::getConfigurationMemberNames(void)
{
    configurationMemberNames_.clear();
 
    std::map<std::string, TableVersion> activeTables = getActiveVersions();
 
    for(auto& tablePair : activeTables)
        if(
            //check if not context table
            ConfigurationManager::fixedContextMemberNames_.find(tablePair.first) ==
                ConfigurationManager::fixedContextMemberNames_.end() &&
            tablePair.first != ConfigurationManager::CONTEXT_SUBSYSTEM_OPTIONAL_TABLE &&
 
            //check if not backbone table
            ConfigurationManager::backboneMemberNames_.find(tablePair.first) ==
                ConfigurationManager::backboneMemberNames_.end() &&
 
            //check if not iterate table
            ConfigurationManager::iterateMemberNames_.find(tablePair.first) ==
                ConfigurationManager::iterateMemberNames_.end())
        {
            // else, it is a configuration table
            configurationMemberNames_.emplace(tablePair.first);
        }
 
    return configurationMemberNames_;
}  // end getConfigurationMemberNames()
 
//==============================================================================
void ConfigurationManager::initializeFromFhicl(const std::string& fhiclPath)
{
    __GEN_COUT__ << "Initializing from fhicl: " << fhiclPath << __E__;
 
    // https://cdcvs.fnal.gov/redmine/projects/fhicl-cpp/wiki
 
    // LoadParameterSet() ... from  $ARTDAQ_INC/artdaq/Application/LoadParameterSet.hh
    fhicl::ParameterSet pset = LoadParameterSet(fhiclPath);
 
    if(pset.get_names().size() == 0)
    {
        __GEN_SS__ << "Empty fcl configuration parameter set found! File: " << fhiclPath
                   << __E__;
        __SS_THROW__;
    }
 
    //===========================
    // fcl should be FE record(s):
    //  interface0: {
    //      FEInterfacePluginName:  "FEOtsUDPTemplateInterface"
    //      LinkToFETypeTable_FEOtsUDPTemplateInterfaceTable:       {
    //          OtsInterface0:          {
    //              InterfaceIPAddress:     "127.0.0.1"
    //              InterfacePort:          4000
    //              HostIPAddress:          "127.0.0.1"
    //              HostPort:               4020
    //              StreamToIPAddress:      "127.0.0.1"
    //              StreamToPort:           4021
    //          }
    //      } //end FEOtsUDPTemplateInterfaceTable link record
    //  } //end interface0
    //===========================
 
    // Steps:
    //  Create one context with one FE supervisor
    //      and one/many FEs specified by fcl
    //
 
    TableBase* table;
 
    // create context and add context record
    {
        table = 0;
        theInterface_->get(table,  // configurationPtr
                           ConfigurationManager::XDAQ_CONTEXT_TABLE_NAME,  // tableName
                           0,                                              // groupKey
                           0,                                              // groupName
                           true  // dontFill=false to fill
        );
 
        nameToTableMap_[ConfigurationManager::XDAQ_CONTEXT_TABLE_NAME] = table;
 
        table->setupMockupView(TableVersion(TableVersion::DEFAULT));
        table->setActiveView(TableVersion(TableVersion::DEFAULT));
 
        TableView* view = table->getViewP();
        __GEN_COUT__ << "Activated version: " << view->getVersion() << __E__;
 
        // add context record       ---------------------
        view->addRow();
        auto colMap = view->getColumnNamesMap();
 
        view->setValue("MacroMakerFEContext", 0, colMap["ContextUID"]);
        view->setValue("XDAQApplicationTable", 0, colMap["LinkToApplicationTable"]);
        view->setValue("MacroMakerFEContextApps", 0, colMap["LinkToApplicationGroupID"]);
        view->setValue("1", 0, colMap[TableViewColumnInfo::COL_NAME_STATUS]);
 
        __GEN_COUT__ << "Done adding context record..." << __E__;
        if(TTEST(1))
        {
            std::stringstream ss;
            view->print(ss);
            __GEN_COUTT__ << "view->print()" << ss.str() << __E__;
        }
 
    }  // done with context record
 
    // create app table and add application record
    {
        table = 0;
        theInterface_->get(
            table,                                              // configurationPtr
            ConfigurationManager::XDAQ_APPLICATION_TABLE_NAME,  // tableName
            0,                                                  // groupKey
            0,                                                  // groupName
            true                                                // dontFill=false to fill
        );
 
        nameToTableMap_[ConfigurationManager::XDAQ_APPLICATION_TABLE_NAME] = table;
 
        table->setupMockupView(TableVersion(TableVersion::DEFAULT));
        table->setActiveView(TableVersion(TableVersion::DEFAULT));
 
        TableView* view = table->getViewP();
        __GEN_COUT__ << "Activated version: " << view->getVersion() << __E__;
 
        // add application record       ---------------------
        view->addRow();
        auto colMap = view->getColumnNamesMap();
 
        view->setValue("MacroMakerFEContextApps", 0, colMap["ApplicationGroupID"]);
        view->setValue("MacroMakerFESupervisor", 0, colMap["ApplicationUID"]);
        view->setValue("FESupervisorTable", 0, colMap["LinkToSupervisorTable"]);
        view->setValue("MacroMakerFESupervisor", 0, colMap["LinkToSupervisorUID"]);
        view->setValue("1", 0, colMap[TableViewColumnInfo::COL_NAME_STATUS]);
        view->setValue(__ENV__("FE_SUPERVISOR_ID"), 0, colMap["Id"]);  // XDAQ LID
 
        __GEN_COUT__ << "Done adding application record..." << __E__;
        if(TTEST(1))
        {
            std::stringstream ss;
            view->print(ss);
            __GEN_COUTT__ << "view->print()" << ss.str() << __E__;
        }
    }  // done with app record
 
    // create FE Supervisor table and Supervisor record
    {
        table = 0;
        theInterface_->get(table,                // configurationPtr
                           "FESupervisorTable",  // tableName
                           0,                    // groupKey
                           0,                    // groupName
                           true                  // dontFill=false to fill
        );
 
        nameToTableMap_["FESupervisorTable"] = table;
 
        table->setupMockupView(TableVersion(TableVersion::DEFAULT));
        table->setActiveView(TableVersion(TableVersion::DEFAULT));
 
        TableView* view = table->getViewP();
        __GEN_COUT__ << "Activated version: " << view->getVersion() << __E__;
 
        // add application record       ---------------------
        view->addRow();
        auto colMap = view->getColumnNamesMap();
 
        view->setValue("MacroMakerFESupervisor", 0, colMap["SupervisorUID"]);
        view->setValue("FEInterfaceTable", 0, colMap["LinkToFEInterfaceTable"]);
        view->setValue(
            "MacroMakerFESupervisorInterfaces", 0, colMap["LinkToFEInterfaceGroupID"]);
 
        __GEN_COUT__ << "Done adding supervisor record..." << __E__;
        if(TTEST(1))
        {
            std::stringstream ss;
            view->print(ss);
            __GEN_COUTT__ << "view->print()" << ss.str() << __E__;
        }
    }  // done with app record
 
    // create FE Interface table and interface record(s)
    recursiveInitFromFhiclPSet("FEInterfaceTable" /*tableName*/,
                               pset /*fhicl parameter set*/,
                               "" /*uid*/,
                               "MacroMakerFESupervisorInterfaces" /*groupID*/,
                               "FE" /*childLinkIndex*/);
 
    // init every table after modifications
    for(auto& table : nameToTableMap_)
    {
        table.second->getViewP()->init();
    }
 
    // verify extraction
    if(0)
    {
        __GEN_COUT__ << "================================================" << __E__;
        nameToTableMap_["FESupervisorTable"]->getViewP()->print();
        nameToTableMap_["FEInterfaceTable"]->getViewP()->print();
 
        auto sups = getNode("FESupervisorTable").getChildrenNames();
        __GEN_COUT__ << "Supervisors extracted from fhicl: " << sups.size() << __E__;
        auto fes = getNode("FEInterfaceTable").getChildrenNames();
        __GEN_COUT__ << "Front-ends extracted from fhicl: " << fes.size() << __E__;
        {
            auto a = getNode(ConfigurationManager::XDAQ_CONTEXT_TABLE_NAME);
            __GEN_COUTV__(a.getValueAsString());
 
            auto b = a.getNode("MacroMakerFEContext");
            __GEN_COUTV__(b.getValueAsString());
 
            auto c = b.getNode("LinkToApplicationTable");
            __GEN_COUTV__(c.getValueAsString());
 
            auto d = c.getNode("MacroMakerFESupervisor");
            __GEN_COUTV__(d.getValueAsString());
 
            auto e = d.getNode("LinkToSupervisorTable");
            __GEN_COUTV__(e.getValueAsString());
 
            auto f = e.getNode("LinkToFEInterfaceTable");
            __GEN_COUTV__(f.getValueAsString());
 
            auto z = f.getChildrenNames();
            __GEN_COUTV__(StringMacros::vectorToString(z));
            __GEN_COUTV__(z.size());
            auto y = f.getChildrenNames(false /*byPriority*/, true /*onlyStatusTrue*/);
            __GEN_COUTV__(StringMacros::vectorToString(y));
            __GEN_COUTV__(y.size());
            auto x = f.getChildrenNames(true /*byPriority*/, true /*onlyStatusTrue*/);
            __GEN_COUTV__(StringMacros::vectorToString(x));
            __GEN_COUTV__(x.size());
 
            auto g = f.getNode("dtc0");
            __GEN_COUTV__(g.getValueAsString());
            auto h = f.getNode("interface0");
            __GEN_COUTV__(h.getValueAsString());
 
            auto fes =
                getNode(ConfigurationManager::XDAQ_CONTEXT_TABLE_NAME)
                    .getNode(
                        "MacroMakerFEContext/LinkToApplicationTable/"
                        "MacroMakerFESupervisor/LinkToSupervisorTable")
                    .getNode("LinkToFEInterfaceTable")
                    .getChildrenNames(true /*byPriority*/, true /*onlyStatusTrue*/);
            __GEN_COUTV__(fes.size());
            __GEN_COUTV__(StringMacros::vectorToString(fes));
        }
    }
 
}  // end initializeFromFhicl()
 
//==============================================================================
void ConfigurationManager::recursiveInitFromFhiclPSet(const std::string& tableName,
                                                      const fhicl::ParameterSet& pset,
                                                      const std::string& recordName,
                                                      const std::string& groupName,
                                                      const std::string& groupLinkIndex)
{
    __GEN_COUTT__ << "recursiveInitFromFhiclPSet() "
                  << "Adding table '" << tableName << "' record(s)..." << __E__;
 
    TableBase* table;
    // create context and add context record
    {
        table = 0;
        if(nameToTableMap_.find(tableName) == nameToTableMap_.end())
        {
            __GEN_COUTT__ << "Table not found, so making '" << tableName
                          << "' instance..." << __E__;
            theInterface_->get(table,      // configurationPtr
                               tableName,  // tableName
                               0,          // groupKey
                               0,          // groupName
                               true        // dontFill=false to fill
            );
 
            nameToTableMap_[tableName] = table;
            table->setupMockupView(TableVersion(TableVersion::DEFAULT));
        }
        else
        {
            __GEN_COUTT__ << "Existing table found, so using '" << tableName
                          << "'instance..." << __E__;
            table = nameToTableMap_[tableName];
        }
 
        table->setActiveView(TableVersion(TableVersion::DEFAULT));
 
        TableView* view = table->getViewP();
        __GEN_COUTT__ << "Activated version: " << view->getVersion() << __E__;
        // view->print();
 
        if(recordName != "")  // then add this record
        {
            // Steps:
            //  - add row
            //  - set UID and enable (if possible)
            //  - set values for parameter columns
            //  - define links
 
            __GEN_COUTTV__(recordName);
 
            // add row and get column map
            unsigned int r      = view->addRow();
            auto         colMap = view->getColumnNamesMap();
 
            // set UID and enable (if possible)
            view->setValue(recordName, r, view->getColUID());
            try
            {
                view->setValue("1", r, view->getColStatus());
            }
            catch(...)
            {
                __GEN_COUTT__ << "No status column to set for '" << recordName << "'"
                              << __E__;
            }
 
            if(groupName != "")  // then set groupID for this record
            {
                __GEN_COUTT__ << "Setting group ID for group link index '"
                              << groupLinkIndex << "'" << __E__;
 
                int groupIDCol = view->getLinkGroupIDColumn(groupLinkIndex);
                __GEN_COUTT__ << "Setting group ID for group link index '"
                              << groupLinkIndex << "' at column " << groupIDCol << " to '"
                              << groupName << ".'" << __E__;
 
                view->setValue(groupName, r, groupIDCol);
            }
 
            // then set parameters
            auto names = pset.get_names();
            for(const auto& colName : names)
            {
                if(!pset.is_key_to_atom(colName))
                    continue;
 
                auto colIt = colMap.find(colName);
                if(colIt == colMap.end())
                {
                    __SS__ << "Field '" << colName << "' of record '" << recordName
                           << "' in table '" << tableName << "' was not found in columns."
                           << "\n\nHere are the existing column names:\n";
                    unsigned int i = 0;
                    for(const auto& col : colMap)
                        ss << "\n" << ++i << ".\t" << col.first;
                    ss << __E__;
                    __SS_THROW__;
                }
                // skip overwriting group ID - already setup by parent group link
                if(view->getColumnInfo(colIt->second).isGroupID())
                    continue;
 
                const std::string value = pset.get<std::string>(colName);
                __GEN_COUTT__ << "Setting '" << recordName << "' parameter at column "
                              << colIt->second << ", '" << colName << "'\t = " << value
                              << __E__;
                view->setValueAsString(value, r, colIt->second);
            }  // end set parameters
 
            // then define links
            for(const auto& linkName : names)
            {
                if(pset.is_key_to_atom(linkName))
                    continue;
 
                __GEN_COUTTV__(linkName);
 
                // split into column name and table
                unsigned int c = linkName.size() - 1;
                for(; c >= 1; --c)
                    if(linkName[c] == '_')  // find first underscore to split linkName
                        break;
 
                if(c == 0)
                {
                    __SS__ << "Illegal link name '" << linkName
                           << "' found. The format must be <Column name>_<Target table "
                              "name>,.. for example '"
                           << "LinkToFETypeTable_FEOtsUDPTemplateInterfaceTable'"
                           << __E__;
                    __SS_THROW__;
                }
                std::string colName = linkName.substr(0, c);
                __GEN_COUTTV__(colName);
 
                auto colIt = colMap.find(colName);
                if(colIt == colMap.end())
                {
                    __SS__ << "Link '" << colName << "' of record '" << recordName
                           << "' in table '" << tableName << "' was not found in columns."
                           << "\n\nHere are the existing column names:\n";
                    unsigned int i = 0;
                    for(const auto& col : colMap)
                        ss << "\n" << i << ".\t" << col.first << __E__;
                    __SS_THROW__;
                }
                //__GEN_COUT__ << "Setting link at column " << colIt->second << __E__;
 
                std::pair<unsigned int /*link col*/, unsigned int /*link id col*/>
                     linkPair;
                bool isGroupLink;
                view->getChildLink(colIt->second, isGroupLink, linkPair);
 
                //__GEN_COUTV__(isGroupLink);
                //__GEN_COUTV__(linkPair.first);
                //__GEN_COUTV__(linkPair.second);
 
                std::string linkTableName = linkName.substr(c + 1);
                __GEN_COUTTV__(linkTableName);
 
                auto linkPset    = pset.get<fhicl::ParameterSet>(linkName);
                auto linkRecords = linkPset.get_pset_names();
                if(!isGroupLink && linkRecords.size() > 1)
                {
                    __SS__ << "A Unique Link can only point to one record. "
                           << "The specified link '" << colName << "' of record '"
                           << recordName << "' in table '" << tableName << "' has "
                           << linkRecords.size() << " children records specified. "
                           << __E__;
                    __SS_THROW__;
                }
 
                if(linkRecords.size() == 0)
                {
                    __GEN_COUTT__ << "No child records, so leaving link disconnected."
                                  << __E__;
                    continue;
                }
 
                __GEN_COUTT__ << "Setting Link at columns [" << linkPair.first << ","
                              << linkPair.second << "]" << __E__;
                view->setValue(linkTableName, r, linkPair.first);
 
                if(!isGroupLink)
                {
                    __GEN_COUTT__ << "Setting up Unique link to " << linkRecords[0]
                                  << __E__;
 
                    view->setValue(linkRecords[0], r, linkPair.second);
 
                    recursiveInitFromFhiclPSet(
                        linkTableName /*tableName*/,
                        linkPset.get<fhicl::ParameterSet>(
                            linkRecords[0]) /*fhicl parameter set*/,
                        linkRecords[0] /*uid*/,
                        "" /*groupID*/);
                }
                else
                {
                    std::string childLinkIndex =
                        view->getColumnInfo(linkPair.first).getChildLinkIndex();
                    std::string groupName = recordName + "Group";
 
                    view->setValue(groupName, r, linkPair.second);
 
                    for(const auto& groupRecord : linkRecords)
                    {
                        __GEN_COUTT__ << "Setting '" << childLinkIndex
                                      << "' Group link to '" << groupName << "' record '"
                                      << groupRecord << "'" << __E__;
 
                        recursiveInitFromFhiclPSet(
                            linkTableName /*tableName*/,
                            linkPset.get<fhicl::ParameterSet>(
                                groupRecord) /*fhicl parameter set*/,
                            groupRecord /*uid*/,
                            groupName /*groupID*/,
                            childLinkIndex /*groupLinkIndex*/);
                    }
                }
 
            }  // end link handling
        }
        else if(groupName != "")  // then add group of records
        {
            // get_pset_names();
            // get_names
            __GEN_COUTTV__(groupName);
            auto psets = pset.get_pset_names();
            for(const auto& ps : psets)
            {
                __GEN_COUTTV__(ps);
                recursiveInitFromFhiclPSet(
                    tableName /*tableName*/,
                    pset.get<fhicl::ParameterSet>(ps) /*fhicl parameter set*/,
                    ps /*uid*/,
                    groupName /*groupID*/,
                    groupLinkIndex /*groupLinkIndex*/);
            }
        }
        else
        {
            __SS__ << "Illegal recursive parameters!" << __E__;
            __SS_THROW__;
        }
        __GEN_COUT__ << "recursiveInitFromFhiclPSet() "
                     << "Done adding table '" << tableName << "' record(s)..." << __E__;
        if(TTEST(1))
        {
            std::stringstream ss;
            view->print(ss);
            __GEN_COUTT__ << "view->print()" << ss.str() << __E__;
        }
    }
 
}  // end recursiveInitFromFhiclPSet()
 
//==============================================================================
bool ConfigurationManager::isOwnerFirstAppInContext()
{
    __GEN_COUTS__(11) << "Checking if owner '" << ownerContextUID_ << "/" << ownerAppUID_
                      << "' is first App in Context:\n"
                      << StringMacros::stackTrace() << __E__;
 
    if(ownerContextUID_ == "" || ownerAppUID_ == "")
    {
        __GEN_COUTTV__(!forceNotFirstInContext_);
        return !forceNotFirstInContext_;  // default to 'yes' unless forced
    }
 
    __GEN_COUTVS__(10, ownerContextUID_);
    __GEN_COUTVS__(10, ownerAppUID_);
 
    try
    {
        auto contextChildren =
            getNode(ConfigurationManager::XDAQ_CONTEXT_TABLE_NAME + "/" +
                    ownerContextUID_ + "/LinkToApplicationTable")
                .getChildrenNames(false /* byPriority */, true /* onlyStatusTrue */);
 
        if(contextChildren.size() == 0)  // no enabled apps, check if owner is app[0]
        {
            contextChildren =
                getNode(ConfigurationManager::XDAQ_CONTEXT_TABLE_NAME + "/" +
                        ownerContextUID_ + "/LinkToApplicationTable")
                    .getChildrenNames(false /* byPriority */, false /* onlyStatusTrue */);
            __GEN_COUTVS__(10, StringMacros::vectorToString(contextChildren));
        }
        else
            __GEN_COUTVS__(10, StringMacros::vectorToString(contextChildren));
 
        bool isFirstAppInContext =
            contextChildren.size() == 0 || contextChildren[0] == ownerAppUID_;
 
        __GEN_COUTVS__(10, isFirstAppInContext);
 
        return isFirstAppInContext;
    }
    catch(...)
    {
        __GEN_COUTS__(10) << "Exception caught looking for XDAQ Context '"
                          << ownerContextUID_ << "' in tree, so defaulting to 'yes'."
                          << __E__;
        return true;  // default to 'yes' if XDAQ Context doesn't exist
    }
}  // end isOwnerFirstAppInContext()
 
//==============================================================================
void ConfigurationManager::getOtherSubsystemInstanceInfo(
    const std::string& otherSubsystemUID,
    std::string*       userDataPathPtr /* = nullptr */,
    std::string*       hostnamePtr /* = nullptr */,
    std::string*       usernamePtr /* = nullptr */,
    std::string*       fullNamePtr /* = nullptr */)
{
    __GEN_COUTTV__(otherSubsystemUID);
 
    ConfigurationTree node =
        getNode(ConfigurationManager::CONTEXT_SUBSYSTEM_OPTIONAL_TABLE)
            .getNode(otherSubsystemUID);
    std::string userPath = node.getNode("SubsystemUserDataPath").getValue();
    if(fullNamePtr)
        *fullNamePtr = node.getNode("SubsystemFullName").getValue();
 
    auto splitPath = StringMacros::getVectorFromString(userPath, {':'});
    __GEN_COUTTV__(StringMacros::vectorToString(splitPath));
 
    if(!splitPath.size() || splitPath.size() > 2)
    {
        __GEN_SS__ << "Illegal user data path specified for subsystem '"
                   << otherSubsystemUID << "': " << userPath << __E__;
        __SS_ONLY_THROW__;
    }
    std::string userDataPath = splitPath[splitPath.size() - 1];
 
    //since we are running exec, cleanse the filename path for alphanumeric,_,-,/ only
    for(unsigned int i = 0; i < userDataPath.length(); ++i)
        if(!((userDataPath[i] >= 'a' && userDataPath[i] <= 'z') ||
             (userDataPath[i] >= 'A' && userDataPath[i] <= 'Z') ||
             (userDataPath[i] >= '0' && userDataPath[i] <= '9') ||
             userDataPath[i] == '-' || userDataPath[i] == '_' || userDataPath[i] == '/'))
        {
            __GEN_SS__ << "Illegal user data path specified (no special characters "
                          "allowed) for subsystem '"
                       << otherSubsystemUID << "': " << userPath << __E__;
            __SS_ONLY_THROW__;
        }  // end filename cleanse
 
    if(userDataPathPtr)
        *userDataPathPtr = userDataPath;
 
    std::string username, hostname;
    if(splitPath.size() == 2)  //then need to scp the file
    {
        //since we are running exec, cleanse the username@host path for alphanumeric,_,-,/ only
        std::vector<std::string> userHostSplit =
            StringMacros::getVectorFromString(splitPath[0], {'@'});
        __GEN_COUTTV__(userHostSplit.size());
        if(userHostSplit.size() == 1)
            hostname = userHostSplit[0];
        else if(userHostSplit.size() == 2)
        {
            username = userHostSplit[0];
            hostname = userHostSplit[1];
        }
        else
        {
            __GEN_SS__ << "Illegal remote username/host specified for subsystem '"
                       << otherSubsystemUID << "': " << userPath << __E__;
            __SS_ONLY_THROW__;
        }
 
        for(unsigned int i = 0; userHostSplit.size() == 2 && i < username.length(); ++i)
            if(!((username[i] >= 'a' && username[i] <= 'z') ||
                 (username[i] >= 'A' && username[i] <= 'Z') ||
                 (username[i] >= '0' && username[i] <= '9') || username[i] == '-' ||
                 username[i] == '_'))
            {
                __GEN_SS__ << "Illegal remote username specified for subsystem '"
                           << otherSubsystemUID << "': " << userPath << __E__;
                __SS_ONLY_THROW__;
            }
        unsigned int ii = 0;  //track last . to prevent weird . usage
        for(unsigned int i = 0; i < hostname.length(); ++i)
            if(!((hostname[i] >= 'a' && hostname[i] <= 'z') ||
                 (hostname[i] >= 'A' && hostname[i] <= 'Z') ||
                 (hostname[i] >= '0' && hostname[i] <= '9') || hostname[i] == '-' ||
                 hostname[i] == '_'))
            {
                if(hostname[i] == '.' && i > ii + 1)
                {
                    //its ok to have this . so track position
                    ii = i;
                }
                else  //else not ok to have .. or other characters
                {
                    __GEN_SS__ << "Illegal remote hostname '" << hostname
                               << "' specified for subsystem '" << otherSubsystemUID
                               << "': " << userPath << __E__;
                    __SS_ONLY_THROW__;
                }
            }
    }
    else if(splitPath.size() == 1)  //then can just directly access the file
    {
        __GEN_COUT__ << "Local user date path identified." << __E__;
    }
    else
    {
        __GEN_SS__ << "Illegal user data path specified for subsystem '"
                   << otherSubsystemUID << "': " << userPath << __E__;
        __SS_ONLY_THROW__;
    }
 
    if(hostnamePtr)
        *hostnamePtr = hostname;
    if(usernamePtr)
        *usernamePtr = username;
 
}  // end getOtherSubsystemInstanceInfo()
 
//==============================================================================
std::map<std::string /*groupType*/, std::pair<std::string /*groupName*/, TableGroupKey>>
ConfigurationManager::getOtherSubsystemActiveTableGroups(
    const std::string& otherSubsystemUID,
    std::string*       userDataPathPtr /* = nullptr */,
    std::string*       hostnamePtr /* = nullptr */,
    std::string*       usernamePtr /* = nullptr */)
{
    std::map<std::string /*groupType*/,
             std::pair<std::string /*groupName*/, TableGroupKey>>
        retMap;
 
    __GEN_COUTTV__(otherSubsystemUID);
 
    std::string userDataPath;
    std::string username, hostname;
 
    getOtherSubsystemInstanceInfo(otherSubsystemUID, &userDataPath, &hostname, &username);
 
    __GEN_COUTTV__(userDataPath);
    __GEN_COUTTV__(username);
    __GEN_COUTTV__(hostname);
 
    if(userDataPathPtr)
        *userDataPathPtr = userDataPath;
    if(hostnamePtr)
        *hostnamePtr = hostname;
    if(usernamePtr)
        *usernamePtr = username;
 
    //enforce filename ends correctly
    std::string filename = userDataPath + "/ServiceData/ActiveTableGroups.cfg";
 
    std::string cmdResult;
 
    if(hostname != "")
    {
        std::string tmpSubsystemFilename =
            ConfigurationManager::ACTIVE_GROUPS_FILENAME + "." + otherSubsystemUID;
        __GEN_COUTTV__(tmpSubsystemFilename);
        if(username != "")  //has username
        {
            cmdResult = StringMacros::exec(
                ("rm " + tmpSubsystemFilename + " 2>/dev/null; scp " + username + "@" +
                 hostname + ":" + filename + " " + tmpSubsystemFilename + " 2>&1; cat " +
                 tmpSubsystemFilename + " 2>&1")
                    .c_str());
        }
        else
            cmdResult = StringMacros::exec(
                ("rm " + tmpSubsystemFilename + " 2>/dev/null; scp " + hostname + ":" +
                 filename + " " + tmpSubsystemFilename + " 2>&1; cat " +
                 tmpSubsystemFilename + " 2>&1")
                    .c_str());
    }
    else  //then can just directly access the file
    {
        __GEN_COUT__ << "Local user date path identified." << __E__;
        cmdResult = StringMacros::exec(("cat " + filename + " 2>&1").c_str());
    }
 
    __GEN_COUTTV__(cmdResult);
    if(cmdResult.find("Permission denied") != std::string::npos)
    {
        __GEN_SS__
            << "\n\nPermission denied accessing user data path specified for subsystem '"
            << otherSubsystemUID << "': ";
        if(username != "")
            ss << username << "@";
        if(hostname != "")
            ss << hostname << ":";
        ss << userDataPath << __E__;
        __SS_ONLY_THROW__;
    }
    else if(cmdResult.find("No such file or directory") != std::string::npos)
    {
        __GEN_SS__ << "\n\nActive tables groups file not found at user data path "
                      "specified for subsystem '"
                   << otherSubsystemUID << "': ";
        if(username != "")
            ss << username << "@";
        if(hostname != "")
            ss << hostname << ":";
        ss << userDataPath << __E__;
        __SS_ONLY_THROW__;
    }
 
    auto subsystemActiveGroupMap = StringMacros::getVectorFromString(
        cmdResult, {'\n'} /* delimieter*/, {' ', '\t'} /* whitespace*/);
    __GEN_COUTTV__(StringMacros::vectorToString(subsystemActiveGroupMap));
    __GEN_COUTTV__(subsystemActiveGroupMap.size());
 
    std::string  //groupComment, groupAuthor, groupCreationTime,
        groupType;
    for(unsigned int i = 0; i + 1 < subsystemActiveGroupMap.size(); i += 2)
    {
        if(subsystemActiveGroupMap[i] == "" || subsystemActiveGroupMap[i + 1] == "-1")
            continue;
 
        __GEN_COUTT__ << "Loading type of subsystem '" << otherSubsystemUID << "' group "
                      << subsystemActiveGroupMap[i] << "("
                      << subsystemActiveGroupMap[i + 1] << ")" << __E__;
 
        try
        {
            loadTableGroup(subsystemActiveGroupMap[i] /*groupName*/,
                           TableGroupKey(subsystemActiveGroupMap[i + 1]),
                           false /*doActivate*/,
                           0 /*groupMembers*/,
                           0 /*progressBar*/,
                           0 /*accumulateErrors*/,
                           0,  // &groupComment,
                           0,  //&groupAuthor,
                           0,  //&groupCreationTime,
                           true /*doNotLoadMember*/,
                           &groupType);
        }
        catch(const std::runtime_error& e)
        {
            __GEN_COUTT__ << "Ignoring error loading subsystem '" << otherSubsystemUID
                          << "' group " << subsystemActiveGroupMap[i] << "("
                          << subsystemActiveGroupMap[i + 1] << "): " << __E__ << e.what()
                          << __E__;
            groupType = ConfigurationManager::GROUP_TYPE_NAME_UNKNOWN;
        }
        retMap[groupType] = std::make_pair(subsystemActiveGroupMap[i],
                                           TableGroupKey(subsystemActiveGroupMap[i + 1]));
    }  //end load table group loop
 
    __GEN_COUTTV__(StringMacros::mapToString(retMap));
    return retMap;
}  //end getOtherSubsystemActiveTableGroups()
 
//==============================================================================
std::set<std::string /* configAlias */>
ConfigurationManager::getOtherSubsystemConfigAliases(const std::string& otherSubsystemUID)
{
    std::set<std::string> retSet;
 
    __GEN_COUTTV__(otherSubsystemUID);
 
    std::map<std::string /*groupType*/,
             std::pair<std::string /*groupName*/, TableGroupKey>>
        retMap = getOtherSubsystemActiveTableGroups(otherSubsystemUID);
 
    __GEN_COUTTV__(StringMacros::mapToString(retMap));
 
    //load backbone
    auto it = retMap.find(
        ConfigurationManager::convertGroupTypeToName(GroupType::BACKBONE_TYPE));
    if(it == retMap.end())
    {
        __GEN_SS__
            << "No active Backbone group found in the active groups of remote subsystem '"
            << otherSubsystemUID << "!'" << __E__;
        __GEN_SS_THROW__;
    }
    auto it2 = retMap.find(
        ConfigurationManager::convertGroupTypeToName(GroupType::CONTEXT_TYPE));
    if(it2 == retMap.end())
    {
        __GEN_SS__
            << "No active Context group found in the active groups of remote subsystem '"
            << otherSubsystemUID << "!'" << __E__;
        __GEN_SS_THROW__;
    }
 
    std::string accumulatedWarnings;
 
    // be careful to not activate! which calls init() and then generates output files to disk
    //  and changes the system active group; instead only setActiveView
    loadTableGroup(it->second.first,
                   it->second.second,
                   false /*doActivate*/,
                   0 /*groupMembers*/,
                   0 /*progressBar*/,
                   &accumulatedWarnings /*accumulateWarnings = 0*/
    );
    __GEN_COUTTV__(accumulatedWarnings);
 
    //get aliases (a la ConfigurationManager::getActiveGroupAliases:2888)
    std::vector<std::pair<std::string, ConfigurationTree>> entries =
        getNode(ConfigurationManager::GROUP_ALIASES_TABLE_NAME).getChildren();
 
    for(auto& entry : entries)
    {
        if(entry.first.find("Context") == std::string::npos &&
           entry.first.find("Iterat") == std::string::npos)
            retSet.emplace(entry.first);
    }
    __GEN_COUTTV__(StringMacros::setToString(retSet));
    return retSet;
}  //end getOtherSubsystemConfigAliases()
 
//==============================================================================
std::set<std::string /* configAlias */>
ConfigurationManager::getOtherSubsystemFilteredConfigAliases(
    const std::string& otherSubsystemUID, const std::string& otherSubsystemFsmName)
{
    std::set<std::string> retSet;
 
    std::map<std::string /*groupType*/,
             std::pair<std::string /*groupName*/, TableGroupKey>>
        retMap = getOtherSubsystemActiveTableGroups(otherSubsystemUID);
 
    //load backbone
    auto it = retMap.find(
        ConfigurationManager::convertGroupTypeToName(GroupType::BACKBONE_TYPE));
    if(it == retMap.end())
    {
        __GEN_SS__
            << "No active Backbone group found in the active groups of remote subsystem '"
            << otherSubsystemUID << "!'" << __E__;
        __GEN_SS_THROW__;
    }
    auto it2 = retMap.find(
        ConfigurationManager::convertGroupTypeToName(GroupType::CONTEXT_TYPE));
    if(it2 == retMap.end())
    {
        __GEN_SS__
            << "No active Context group found in the active groups of remote subsystem '"
            << otherSubsystemUID << "!'" << __E__;
        __GEN_SS_THROW__;
    }
 
    std::string accumulatedWarnings;
 
    // be careful to not activate! which calls init() and then generates output files to disk
    //  and changes the system active group; instead only setActiveView
    loadTableGroup(it->second.first,
                   it->second.second,
                   false /*doActivate*/,
                   0 /*groupMembers*/,
                   0 /*progressBar*/,
                   &accumulatedWarnings /*accumulateWarnings = 0*/
    );
    loadTableGroup(it2->second.first,
                   it2->second.second,
                   false /*doActivate*/,
                   0 /*groupMembers*/,
                   0 /*progressBar*/,
                   &accumulatedWarnings /*accumulateWarnings = 0*/
    );
    __GEN_COUTTV__(accumulatedWarnings);
 
    //get aliases (a la ConfigurationManager::getActiveGroupAliases:2888)
    std::vector<std::pair<std::string, ConfigurationTree>> entries =
        getNode(ConfigurationManager::GROUP_ALIASES_TABLE_NAME).getChildren();
 
    //apply filter (a la GatewaySupervisor::addFilteredConfigAliasesToXML:5357)
 
    std::string stateMachineAliasFilter = "*";  // default to all
    try                                         // if cant find alias, default to all
    {
        ConfigurationTree otherGatewayNode = getGatewaySupervisorNode();
        ConfigurationTree fsmFilterNode =
            otherGatewayNode.getNode("LinkToStateMachineTable")
                .getNode(otherSubsystemFsmName + "/SystemAliasFilter");
        if(!fsmFilterNode.isDefaultValue())
            stateMachineAliasFilter = fsmFilterNode.getValue<std::string>();
        else
            __GEN_COUT_INFO__ << "FSM has no SystemAliasFilter value." << __E__;
    }
    catch(std::runtime_error& e)
    {
        __COUT__ << "Ignoring unsetup SystemAliasFilter value: " << e.what() << __E__;
    }
    catch(...)
    {
        __COUT__ << "Ignoring unsetup SystemAliasFilter value." << __E__;
    }
 
    __COUT__ << "Applying alias filter for other user_data path FSM '"
             << otherSubsystemFsmName
             << "' and stateMachineAliasFilter  = " << stateMachineAliasFilter << __E__;
 
    // filter list of aliases based on stateMachineAliasFilter
    //  ! as first character means choose those that do NOT match filter
    //  * can be used as wild card.
    {
        bool invertFilter =
            stateMachineAliasFilter.size() && stateMachineAliasFilter[0] == '!';
        std::vector<std::string> filterArr;
 
        size_t i = 0;
        if(invertFilter)
            ++i;
        size_t      f;
        std::string tmp;
        while((f = stateMachineAliasFilter.find('*', i)) != std::string::npos)
        {
            tmp = stateMachineAliasFilter.substr(i, f - i);
            i   = f + 1;
            filterArr.push_back(tmp);
            __COUTS__(20) << filterArr[filterArr.size() - 1] << " " << i << " of "
                          << stateMachineAliasFilter.size() << __E__;
        }
        if(i <= stateMachineAliasFilter.size())
        {
            tmp = stateMachineAliasFilter.substr(i);
            filterArr.push_back(tmp);
            __COUTS__(20) << filterArr[filterArr.size() - 1] << " last." << __E__;
        }
 
        bool filterMatch;
 
        for(auto& aliasMapPair : entries)
        {
            __COUTS__(20) << "aliasMapPair.first: " << aliasMapPair.first << __E__;
 
            filterMatch = true;
 
            if(filterArr.size() == 1)
            {
                if(filterArr[0] != "" && filterArr[0] != "*" &&
                   aliasMapPair.first != filterArr[0])
                    filterMatch = false;
            }
            else
            {
                i = -1;
                for(f = 0; f < filterArr.size(); ++f)
                {
                    if(!filterArr[f].size())
                        continue;  // skip empty filters
 
                    if(f == 0)  // must start with this filter
                    {
                        if((i = aliasMapPair.first.find(filterArr[f])) != 0)
                        {
                            filterMatch = false;
                            break;
                        }
                    }
                    else if(f == filterArr.size() - 1)  // must end with this filter
                    {
                        if(aliasMapPair.first.rfind(filterArr[f]) !=
                           aliasMapPair.first.size() - filterArr[f].size())
                        {
                            filterMatch = false;
                            break;
                        }
                    }
                    else if((i = aliasMapPair.first.find(filterArr[f])) ==
                            std::string::npos)
                    {
                        filterMatch = false;
                        break;
                    }
                }
            }
 
            if(invertFilter)
                filterMatch = !filterMatch;
 
            __COUTS__(20) << "filterMatch=" << filterMatch << __E__;
 
            if(!filterMatch)
                continue;
 
            retSet.emplace(aliasMapPair.first);
 
            //If need more alias details, see ConfigurationGUISupervisor::handleGroupAliasesXML
        }
    }
 
    return retSet;
}  //end getOtherSubsystemFilteredConfigAliases()
 
//==============================================================================
void ConfigurationManager::getOtherSubsystemConfigAliasInfo(
    const std::string&                     otherSubsystemUID,
    const std::string&                     configAlias,
    std::pair<std::string, TableGroupKey>& groupTranslation,
    std::string&                           groupComment,
    std::string&                           groupAuthor,
    std::string&                           groupCreationTime)
{
    __GEN_COUTV__(otherSubsystemUID);
 
    std::map<std::string /*groupType*/,
             std::pair<std::string /*groupName*/, TableGroupKey>>
        retMap = getOtherSubsystemActiveTableGroups(otherSubsystemUID);
 
    //load backbone
    auto it = retMap.find(
        ConfigurationManager::convertGroupTypeToName(GroupType::BACKBONE_TYPE));
    if(it == retMap.end())
    {
        __GEN_SS__
            << "No active Backbone group found in the active groups of remote subsystem '"
            << otherSubsystemUID << "!'" << __E__;
        __GEN_SS_THROW__;
    }
    auto it2 = retMap.find(
        ConfigurationManager::convertGroupTypeToName(GroupType::CONTEXT_TYPE));
    if(it2 == retMap.end())
    {
        __GEN_SS__
            << "No active Context group found in the active groups of remote subsystem '"
            << otherSubsystemUID << "!'" << __E__;
        __GEN_SS_THROW__;
    }
 
    std::string accumulatedWarnings;
 
    // be careful to not activate! which calls init() and then generates output files to disk
    //  and changes the system active group; instead only setActiveView
    loadTableGroup(it->second.first,
                   it->second.second,
                   false /*doActivate*/,
                   0 /*groupMembers*/,
                   0 /*progressBar*/,
                   &accumulatedWarnings /*accumulateWarnings = 0*/
    );
    __GEN_COUTTV__(accumulatedWarnings);
 
    // (a la ConfigurationManager::getTableGroupFromAlias)
    try
    {
        //  find runType in Group Aliases table
        ConfigurationTree entry =
            getNode(ConfigurationManager::GROUP_ALIASES_TABLE_NAME).getNode(configAlias);
 
        groupTranslation = std::pair<std::string, TableGroupKey>(
            entry.getNode("GroupName").getValueAsString(),
            TableGroupKey(entry.getNode("GroupKey").getValueAsString()));
        __COUT__ << "Found " << configAlias << " translates to " << groupTranslation.first
                 << "(" << groupTranslation.second << ")" << __E__;
 
        //get comment, author, creationTime
        try
        {
            loadTableGroup(groupTranslation.first,
                           groupTranslation.second,
                           false /*doActivate*/,
                           0 /*groupMembers*/,
                           0 /*progressBar*/,
                           &accumulatedWarnings,
                           &groupComment,
                           &groupAuthor,
                           &groupCreationTime,
                           true /*doNotLoadMembers*/);
        }
        catch(...)
        {
            __COUT_WARN__ << "Failed to load group metadata." << __E__;
        }
        __COUT__ << "Found " << configAlias << " author: " << groupAuthor
                 << ", createTime: " << groupCreationTime << ", comment: " << groupComment
                 << __E__;
    }
    catch(...)
    {
        __GEN_SS__ << "Did not find the Configuration Alias '" << configAlias
                   << "' in the active Backbone group of remote subsystem '"
                   << otherSubsystemUID << "!'" << __E__;
        __GEN_SS_THROW__;
    }
 
}  //end getOtherSubsystemConfigAliasInfo()
 
//==============================================================================
TableBase* ConfigurationManager::getDesktopIconTable(void)
{
    if(nameToTableMap_.find(DESKTOP_ICON_TABLE_NAME) == nameToTableMap_.end())
    {
        __SS__ << "Desktop icon table not found!" << __E__;
        ss << StringMacros::stackTrace() << __E__;
        __SS_THROW__;
    }
 
    return nameToTableMap_.at(DESKTOP_ICON_TABLE_NAME);
}  // end dynamicDesktopIconChange()
 
//==============================================================================
void ConfigurationManager::saveGroupNameAndKey(
    const std::pair<std::string /*group name*/, TableGroupKey>& theGroup,
    const std::string&                                          fileName,
    bool                                                        appendMode /* = false */,
    const std::string&                                          associatedUser /* = "" */)
{
    std::string fullPath =
        ConfigurationManager::LAST_TABLE_GROUP_SAVE_PATH + "/" + fileName;
    __COUTT__ << "Saving group " << theGroup.first << "(" << theGroup.second << ") to "
              << (appendMode ? "history " : "") << "file: " << fullPath << __E__;
 
    std::ofstream groupFile;
    if(appendMode)
    {
        //force size to MAX record count
        const size_t MAX_RECORDS = 200;
        auto         records     = loadGroupHistory(fullPath);
        while(records.size() >= MAX_RECORDS)
            records.erase(records.begin());  //remove oldest record
        //rewrite file
        groupFile.open(fullPath.c_str());
        for(const auto& record : records)
        {
            groupFile << record.at("groupName") << "\n"
                      << record.at("groupKey") << "\n"
                      << record.at("time") << " , " << record.at("user") << "\n";
        }  //end rewrite records loop
    }
    else  //if not append mode, just overwrite
        groupFile.open(fullPath.c_str());
    if(!groupFile.is_open())
    {
        __SS__ << "Error. Can't open file to save group activity: " << fullPath << __E__;
        __SS_THROW__;
    }
    std::stringstream outss;
    outss << theGroup.first << "\n" << theGroup.second << "\n";
    outss << time(0);
    if(associatedUser != "")  //add user on same line as time if available
        outss << " , " << associatedUser;
    outss << "\n";
    groupFile << outss.str().c_str();
    groupFile.close();
}  // end saveGroupNameAndKey()
 
//==============================================================================
std::pair<std::string /*group name*/, TableGroupKey>
ConfigurationManager::loadGroupNameAndKey(const std::string& fileName,
                                          std::string&       returnedTimeString)
{
    std::string fullPath =
        ConfigurationManager::LAST_TABLE_GROUP_SAVE_PATH + "/" + fileName;
 
    FILE* groupFile = fopen(fullPath.c_str(), "r");
    if(!groupFile)
    {
        __COUT__ << "Can't open file: " << fullPath
                 << ". Returning empty groupName and key -1" << __E__;
 
        return std::pair<std::string /*group name*/, TableGroupKey>("", TableGroupKey());
    }
 
    char line[500];  // assuming no group names longer than 500 chars
    // name and then key
    std::pair<std::string /*group name*/, TableGroupKey> theGroup;
 
    fgets(line, 500, groupFile);  // name
    if(strlen(line) && line[strlen(line) - 1] == '\n')
        line[strlen(line) - 1] = '\0';  // remove trailing newline
    theGroup.first = line;
 
    fgets(line, 500, groupFile);  // key
    int key;
    sscanf(line, "%d", &key);
    theGroup.second = key;
 
    fgets(line, 500, groupFile);  // time
    time_t timestamp;
    sscanf(line, "%ld", &timestamp);  // type long int
                                      //    struct tm tmstruct;
                                      //    ::localtime_r(&timestamp, &tmstruct);
                                      //    ::strftime(line, 30, "%c %Z", &tmstruct);
    returnedTimeString = StringMacros::getTimestampString(timestamp);  // line;
    fclose(groupFile);
 
    __COUTS__(2) << "theGroup.first=" << theGroup.first
                 << " theGroup.second=" << theGroup.second << __E__;
 
    return theGroup;
}  // end loadGroupNameAndKey()
 
//==============================================================================
std::vector<
    std::map<std::string /* group field key */, std::string /* group field value */>>
ConfigurationManager::loadGroupHistory(const std::string& groupAction,
                                       const std::string& groupType,
                                       bool               formatTime /* = false */)
{
    __COUTTV__(groupAction);
    __COUTTV__(groupType);
 
    std::string fullPath = ConfigurationManager::LAST_TABLE_GROUP_SAVE_PATH + "/";
 
    if(groupAction == "Activated")
    {
        if(groupType == ConfigurationManager::GROUP_TYPE_NAME_BACKBONE)
            fullPath += ConfigurationManager::ACTIVATED_BACKBONES_FILE;
        else if(groupType == ConfigurationManager::GROUP_TYPE_NAME_CONTEXT)
            fullPath += ConfigurationManager::ACTIVATED_CONTEXTS_FILE;
        else if(groupType == ConfigurationManager::GROUP_TYPE_NAME_CONFIGURATION)
            fullPath += ConfigurationManager::ACTIVATED_CONFIGS_FILE;
        else if(groupType == ConfigurationManager::GROUP_TYPE_NAME_ITERATE)
            fullPath += ConfigurationManager::ACTIVATED_ITERATES_FILE;
    }
    else if(groupAction == "Attempted Configure")
    {
        if(groupType == ConfigurationManager::GROUP_TYPE_NAME_CONFIGURATION)
            fullPath += ConfigurationManager::ATTEMPTED_CONFIGURE_CONFIGS_FILE;
        else if(groupType == "Config Alias")
            fullPath += ConfigurationManager::ATTEMPTED_CONFIGURE_CONFIG_ALIASES_FILE;
    }
    else if(groupAction == "Configured")
    {
        if(groupType == ConfigurationManager::GROUP_TYPE_NAME_BACKBONE)
            fullPath += ConfigurationManager::CONFIGURED_BACKBONES_FILE;
        else if(groupType == ConfigurationManager::GROUP_TYPE_NAME_CONTEXT)
            fullPath += ConfigurationManager::CONFIGURED_CONTEXTS_FILE;
        else if(groupType == ConfigurationManager::GROUP_TYPE_NAME_CONFIGURATION)
            fullPath += ConfigurationManager::CONFIGURED_CONFIGS_FILE;
        else if(groupType == ConfigurationManager::GROUP_TYPE_NAME_ITERATE)
            fullPath += ConfigurationManager::CONFIGURED_ITERATES_FILE;
        else if(groupType == "Config Alias")
            fullPath += ConfigurationManager::CONFIGURED_CONFIG_ALIASES_FILE;
    }
    else if(groupAction == "Started")
    {
        if(groupType == ConfigurationManager::GROUP_TYPE_NAME_BACKBONE)
            fullPath += ConfigurationManager::STARTED_BACKBONES_FILE;
        else if(groupType == ConfigurationManager::GROUP_TYPE_NAME_CONTEXT)
            fullPath += ConfigurationManager::STARTED_CONTEXTS_FILE;
        else if(groupType == ConfigurationManager::GROUP_TYPE_NAME_CONFIGURATION)
            fullPath += ConfigurationManager::STARTED_CONFIGS_FILE;
        else if(groupType == ConfigurationManager::GROUP_TYPE_NAME_ITERATE)
            fullPath += ConfigurationManager::STARTED_ITERATES_FILE;
        else if(groupType == "Config Alias")
            fullPath += ConfigurationManager::STARTED_CONFIG_ALIASES_FILE;
    }
    else if(groupAction == "Configured or Started")
    {
        if(groupType == ConfigurationManager::GROUP_TYPE_NAME_BACKBONE)
            fullPath += ConfigurationManager::CONFIGURED_OR_STARTED_BACKBONES_FILE;
        else if(groupType == ConfigurationManager::GROUP_TYPE_NAME_CONTEXT)
            fullPath += ConfigurationManager::CONFIGURED_OR_STARTED_CONTEXTS_FILE;
        else if(groupType == ConfigurationManager::GROUP_TYPE_NAME_CONFIGURATION)
            fullPath += ConfigurationManager::CONFIGURED_OR_STARTED_CONFIGS_FILE;
        else if(groupType == ConfigurationManager::GROUP_TYPE_NAME_ITERATE)
            fullPath += ConfigurationManager::CONFIGURED_OR_STARTED_ITERATES_FILE;
        else if(groupType == "Config Alias")
            fullPath += ConfigurationManager::CONFIGURED_OR_STARTED_CONFIG_ALIASES_FILE;
    }
 
    if(fullPath == ConfigurationManager::LAST_TABLE_GROUP_SAVE_PATH + "/")
    {
        __SS__ << "Illegal attempted group history request combination of groupAction: "
               << groupAction << ", and groupType: " << groupType << __E__;
        __SS_THROW__;
    }
    return loadGroupHistory(fullPath, formatTime);
}  // end loadGroupHistory()
 
//==============================================================================
std::vector<
    std::map<std::string /* group field key */, std::string /* group field value */>>
ConfigurationManager::loadGroupHistory(const std::string& fullPath,
                                       bool               formatTime /* = false */)
{
    std::vector<
        std::map<std::string /* group field key */, std::string /* group field value */>>
        retVec;
 
    __COUTTV__(fullPath);
    FILE* groupFile = fopen(fullPath.c_str(), "r");
    if(!groupFile)
    {
        __COUT_WARN__ << "Can't open group history file (assuming no history yet): "
                      << fullPath << __E__;
 
        __COUTTV__(retVec.size());
        return retVec;
    }
 
    char line[500];  // assuming no group names longer than 500 chars
    // name and then key
    std::pair<std::string /*group name*/, TableGroupKey> theGroup;
    std::string returnedTimeString, associatedUser;
    char        user[500];
 
    while(fgets(line, 500, groupFile))  // name
    {
        if(strlen(line) && line[strlen(line) - 1] == '\n')
            line[strlen(line) - 1] = '\0';  // remove trailing newline
        theGroup.first = line;
 
        fgets(line, 500, groupFile);  // key
        int key;
        sscanf(line, "%d", &key);
        theGroup.second = key;
 
        fgets(line, 500, groupFile);  // time
        time_t timestamp;
        user[0] = '\0';                              //clear in case not present in line
        sscanf(line, "%ld , %s", &timestamp, user);  // type long int
                                                     // struct tm tmstruct;
        //  ::localtime_r(&timestamp, &tmstruct);
        //  ::strftime(line, 30, "%c %Z", &tmstruct);
 
        __COUTS__(20) << "Read group from history file: " << theGroup.first << "("
                      << theGroup.second << "), timestamp=" << timestamp
                      << ", user=" << user << __E__;
 
        retVec.push_back({{"groupName", theGroup.first},
                          {"groupKey", theGroup.second.toString()},
                          {"time",
                           formatTime ? StringMacros::getTimestampString(timestamp)
                                      : std::to_string(timestamp)},
                          {"user", user}});
    }  //end traversing group history file
 
    fclose(groupFile);
 
    __COUTTV__(retVec.size());
 
    return retVec;
}  // end loadGroupHistory()
 
//==============================================================================
void ConfigurationManager::initPrereqsForARTDAQ()
try
{
    __COUTT__ << "Initializing prerequisites for artdaq!" << __E__;
 
    auto activeTables = getActiveVersions();
    for(auto& tablePair : activeTables)
    {
        __COUTVS__(2, tablePair.first);
        try
        {
            nameToTableMap_.at(tablePair.first)->initPrereqsForARTDAQ(this);
        }
        catch(const std::runtime_error& e)
        {
            __COUTVS__(2, e.what());
            if(std::string(e.what()).find(
                   "initPrereqsForARTDAQ() is not implemented for this table") ==
               std::string::npos)
                throw;
            //else ignore undefined virtual function error
        }
    }  //end table loop
 
    __COUTT__ << "Done initializing prerequisites for artdaq!" << __E__;
}  // end initPrereqsForARTDAQ()
catch(...)
{
    __SS__ << "Error caught while initializing prerequisites for artdaq!";
    try
    {
        throw;
    }
    catch(const std::runtime_error& e)
    {
        ss << " Here was the error: " << e.what() << __E__;
    }
    __SS_THROW__;
}  // end initPrereqsForARTDAQ()