1 #include "otsdaq/ConfigurationInterface/ConfigurationManagerRW.h"
30 #define __MF_SUBJECT__ "ConfigurationManagerRW"
32 #define TABLE_INFO_PATH std::string(__ENV__("TABLE_INFO_PATH")) + "/"
33 #define TABLE_INFO_EXT "Info.xml"
35 #define CORE_TABLE_INFO_FILENAME \
36 ((getenv("SERVICE_DATA_PATH") == NULL) \
37 ? (std::string(__ENV__("USER_DATA")) + "/ServiceData") \
38 : (std::string(__ENV__("SERVICE_DATA_PATH")))) + \
39 "/CoreTableInfoNames.dat"
43 ConfigurationManagerRW::ConfigurationManagerRW(
const std::string& username)
46 __COUT__ <<
"Using Config Mgr with Write Access! (for " << username <<
")" << __E__;
50 ConfigurationInterface::getInstance(
false);
59 const std::set<std::string>& contextMemberNames = getContextMemberNames();
60 const std::set<std::string>& backboneMemberNames = getBackboneMemberNames();
61 const std::set<std::string>& iterateMemberNames = getIterateMemberNames();
63 FILE* fp = fopen((CORE_TABLE_INFO_FILENAME).c_str(),
"r");
65 __COUT__ <<
"Updating core tables table..." << __E__;
69 std::vector<unsigned int> foundVector;
71 for(
const auto& name : contextMemberNames)
73 foundVector.push_back(
false);
75 while(fgets(line, 100, fp))
79 line[strlen(line) - 1] =
'\0';
80 if(strcmp(line, (
"ContextGroup/" + name).c_str()) == 0)
82 foundVector.back() =
true;
89 for(
const auto& name : backboneMemberNames)
91 foundVector.push_back(
false);
93 while(fgets(line, 100, fp))
97 line[strlen(line) - 1] =
'\0';
98 if(strcmp(line, (
"BackboneGroup/" + name).c_str()) == 0)
100 foundVector.back() =
true;
107 for(
const auto& name : iterateMemberNames)
109 foundVector.push_back(
false);
111 while(fgets(line, 100, fp))
115 line[strlen(line) - 1] =
'\0';
116 if(strcmp(line, (
"IterateGroup/" + name).c_str()) == 0)
118 foundVector.back() =
true;
131 fp = fopen((CORE_TABLE_INFO_FILENAME).c_str(),
"a");
135 for(
const auto& name : contextMemberNames)
138 fprintf(fp,
"\nContextGroup/%s", name.c_str());
142 for(
const auto& name : backboneMemberNames)
145 fprintf(fp,
"\nBackboneGroup/%s", name.c_str());
149 for(
const auto& name : iterateMemberNames)
152 fprintf(fp,
"\nIterateGroup/%s", name.c_str());
160 __SS__ <<
"Failed to open core table info file for appending: "
161 << CORE_TABLE_INFO_FILENAME << __E__;
167 fp = fopen((CORE_TABLE_INFO_FILENAME).c_str(),
"w");
170 for(
const auto& name : contextMemberNames)
171 fprintf(fp,
"\nContextGroup/%s", name.c_str());
172 for(
const auto& name : backboneMemberNames)
173 fprintf(fp,
"\nBackboneGroup/%s", name.c_str());
174 for(
const auto& name : iterateMemberNames)
175 fprintf(fp,
"\nIterateGroup/%s", name.c_str());
180 __SS__ <<
"Failed to open core table info file: "
181 << CORE_TABLE_INFO_FILENAME << __E__;
194 const std::map<std::string, TableInfo>& ConfigurationManagerRW::getAllTableInfo(
195 bool refresh, std::string* accumulatedErrors,
const std::string& errorFilterName)
203 return allTableInfo_;
206 allTableInfo_.clear();
207 allGroupInfo_.clear();
214 __COUT__ <<
"======================================================== "
215 "getAllTableInfo start"
217 __COUT__ <<
"Refreshing all! Extracting list of tables..." << __E__;
219 struct dirent* entry;
220 std::string path = TABLE_INFO_PATH;
221 char fileExt[] = TABLE_INFO_EXT;
222 const unsigned char MIN_TABLE_NAME_SZ = 3;
223 if((pDIR = opendir(path.c_str())) != 0)
225 while((entry = readdir(pDIR)) != 0)
228 if(strlen(entry->d_name) < strlen(fileExt) + MIN_TABLE_NAME_SZ)
232 if(strcmp(&(entry->d_name[strlen(entry->d_name) - strlen(fileExt)]),
236 entry->d_name[strlen(entry->d_name) - strlen(fileExt)] =
246 theInterface_->get(table, entry->d_name, 0, 0,
249 catch(cet::exception
const&)
255 __COUT__ <<
"Skipping! No valid class found for... " << entry->d_name
259 catch(std::runtime_error& e)
265 __COUT__ <<
"Skipping! No valid class found for... " << entry->d_name
267 __COUT__ <<
"Error: " << e.what() << __E__;
272 if(accumulatedErrors)
274 if(errorFilterName ==
"" || errorFilterName == entry->d_name)
276 *accumulatedErrors += std::string(
"\nIn table '") +
277 entry->d_name +
"'..." +
280 __SS__ <<
"Attempting to allow illegal columns!" << __E__;
281 *accumulatedErrors += ss.str();
285 __COUT__ <<
"Attempting to allow illegal columns!" << __E__;
287 std::string returnedAccumulatedErrors;
292 table =
new TableBase(entry->d_name, &returnedAccumulatedErrors);
297 <<
"Skipping! Allowing illegal columns didn't work either... "
298 << entry->d_name <<
"\n";
301 __COUT__ <<
"Error (but allowed): " << returnedAccumulatedErrors
304 if(errorFilterName ==
"" || errorFilterName == entry->d_name)
305 *accumulatedErrors +=
306 std::string(
"\nIn table '") + entry->d_name +
"'..." +
307 returnedAccumulatedErrors;
315 if(nameToTableMap_[entry->d_name])
318 std::set<TableVersion> versions =
319 nameToTableMap_[entry->d_name]->getStoredVersions();
320 for(
auto& version : versions)
321 if(version.isTemporaryVersion())
327 nameToTableMap_[entry->d_name]->setActiveView(version);
329 nameToTableMap_[entry->d_name]->getView(),
339 delete nameToTableMap_[entry->d_name];
340 nameToTableMap_[entry->d_name] = 0;
343 nameToTableMap_[entry->d_name] = table;
345 allTableInfo_[entry->d_name].tablePtr_ = table;
346 allTableInfo_[entry->d_name].versions_ = theInterface_->getVersions(table);
350 std::set<TableVersion> versions =
351 nameToTableMap_[entry->d_name]->getStoredVersions();
352 for(
auto& version : versions)
353 if(version.isTemporaryVersion())
356 allTableInfo_[entry->d_name].versions_.emplace(version);
361 __COUT__ <<
"Extracting list of tables complete. Now initializing..." << __E__;
364 init(accumulatedErrors);
367 <<
"======================================================== getAllTableInfo end"
375 std::set<std::string > tableGroups =
376 theInterface_->getAllTableGroupNames();
377 __COUT__ <<
"Number of Groups: " << tableGroups.size() << __E__;
381 for(
const auto& fullName : tableGroups)
383 TableGroupKey::getGroupNameAndKey(fullName, name, key);
384 cacheGroupKey(name, key);
388 for(
auto& groupInfo : allGroupInfo_)
392 loadTableGroup(groupInfo.first ,
393 groupInfo.second.getLatestKey(),
395 &groupInfo.second.latestKeyMemberMap_ ,
398 &groupInfo.second.latestKeyGroupComment_,
399 &groupInfo.second.latestKeyGroupAuthor_,
400 &groupInfo.second.latestKeyGroupCreationTime_,
402 &groupInfo.second.latestKeyGroupTypeString_);
407 <<
"Error occurred loading latest group info into cache for '"
408 << groupInfo.first <<
"'..." << __E__;
409 groupInfo.second.latestKeyGroupComment_ =
"UNKNOWN";
410 groupInfo.second.latestKeyGroupAuthor_ =
"UNKNOWN";
411 groupInfo.second.latestKeyGroupCreationTime_ =
"0";
412 groupInfo.second.latestKeyGroupTypeString_ =
"UNKNOWN";
416 catch(
const std::runtime_error& e)
418 __SS__ <<
"A fatal error occurred reading the info for all table groups. Error: "
419 << e.what() << __E__;
420 __COUT_ERR__ <<
"\n" << ss.str();
421 if(accumulatedErrors)
422 *accumulatedErrors += ss.str();
428 __SS__ <<
"An unknown fatal error occurred reading the info for all table groups."
430 __COUT_ERR__ <<
"\n" << ss.str();
431 if(accumulatedErrors)
432 *accumulatedErrors += ss.str();
437 return allTableInfo_;
444 std::map<std::string ,
446 ConfigurationManagerRW::getVersionAliases(
void)
const
449 std::map<std::string ,
451 retMap = ConfigurationManager::getVersionAliases();
455 if(!ConfigurationInterface::isVersionTrackingEnabled())
456 for(
const auto& tableInfo : allTableInfo_)
457 for(
const auto& version : tableInfo.second.versions_)
458 if(version.isScratchVersion())
459 retMap[tableInfo.first][ConfigurationManager::SCRATCH_VERSION_ALIAS] =
469 void ConfigurationManagerRW::activateTableGroup(
const std::string& configGroupName,
471 std::string* accumulatedTreeErrors)
475 __COUTV__(accumulatedTreeErrors);
476 loadTableGroup(configGroupName,
481 accumulatedTreeErrors);
485 __COUT_ERR__ <<
"There were errors, so de-activating group: " << configGroupName
486 <<
" (" << tableGroupKey <<
")" << __E__;
489 destroyTableGroup(configGroupName,
true);
497 __COUT_INFO__ <<
"Updating persistent active groups to "
498 << ConfigurationManager::ACTIVE_GROUPS_FILENAME <<
" ..." << __E__;
499 __MOUT_INFO__ <<
"Updating persistent active groups to "
500 << ConfigurationManager::ACTIVE_GROUPS_FILENAME <<
" ..." << __E__;
502 std::string fn = ConfigurationManager::ACTIVE_GROUPS_FILENAME;
503 FILE* fp = fopen(fn.c_str(),
"w");
506 __SS__ <<
"Fatal Error! Unable to open the file "
507 << ConfigurationManager::ACTIVE_GROUPS_FILENAME
508 <<
" for editing! Is there a permissions problem?" << __E__;
509 __COUT_ERR__ << ss.str();
514 __MCOUT_INFO__(
"Active Context table group: "
515 << theContextTableGroup_ <<
"("
516 << (theContextTableGroupKey_
517 ? theContextTableGroupKey_->toString().c_str()
520 __MCOUT_INFO__(
"Active Backbone table group: "
521 << theBackboneTableGroup_ <<
"("
522 << (theBackboneTableGroupKey_
523 ? theBackboneTableGroupKey_->toString().c_str()
526 __MCOUT_INFO__(
"Active Iterate table group: "
527 << theIterateTableGroup_ <<
"("
528 << (theIterateTableGroupKey_
529 ? theIterateTableGroupKey_->toString().c_str()
532 __MCOUT_INFO__(
"Active Configuration table group: "
533 << theConfigurationTableGroup_ <<
"("
534 << (theConfigurationTableGroupKey_
535 ? theConfigurationTableGroupKey_->toString().c_str()
539 fprintf(fp,
"%s\n", theContextTableGroup_.c_str());
543 theContextTableGroupKey_ ? theContextTableGroupKey_->toString().c_str() :
"-1");
544 fprintf(fp,
"%s\n", theBackboneTableGroup_.c_str());
548 theBackboneTableGroupKey_ ? theBackboneTableGroupKey_->toString().c_str() :
"-1");
549 fprintf(fp,
"%s\n", theIterateTableGroup_.c_str());
553 theIterateTableGroupKey_ ? theIterateTableGroupKey_->toString().c_str() :
"-1");
554 fprintf(fp,
"%s\n", theConfigurationTableGroup_.c_str());
557 theConfigurationTableGroupKey_
558 ? theConfigurationTableGroupKey_->toString().c_str()
568 TableVersion ConfigurationManagerRW::createTemporaryBackboneView(
571 __COUT_INFO__ <<
"Creating temporary backbone view from version " << sourceViewVersion
576 TableVersion::getNextTemporaryVersion();
578 auto backboneMemberNames = ConfigurationManager::getBackboneMemberNames();
579 for(
auto& name : backboneMemberNames)
582 ConfigurationManager::getTableByName(name)->getNextTemporaryVersion();
583 if(retTmpVersion < tmpVersion)
584 tmpVersion = retTmpVersion;
587 __COUT__ <<
"Common temporary backbone version found as " << tmpVersion << __E__;
590 for(
auto& name : backboneMemberNames)
593 getTableByName(name)->createTemporaryView(sourceViewVersion, tmpVersion);
594 if(retTmpVersion != tmpVersion)
596 __SS__ <<
"Failure! Temporary view requested was " << tmpVersion
597 <<
". Mismatched temporary view created: " << retTmpVersion << __E__;
598 __COUT_ERR__ << ss.str();
607 TableBase* ConfigurationManagerRW::getTableByName(
const std::string& tableName)
609 if(nameToTableMap_.find(tableName) == nameToTableMap_.end())
611 __SS__ <<
"Table not found with name: " << tableName << __E__;
613 if((f = tableName.find(
' ')) != std::string::npos)
614 ss <<
"There was a space character found in the table name needle at "
616 << f <<
" in the string (was this intended?). " << __E__;
617 __COUT_ERR__ <<
"\n" << ss.str();
620 return nameToTableMap_[tableName];
628 TableBase* ConfigurationManagerRW::getVersionedTableByName(
629 const std::string& tableName,
631 bool looseColumnMatching ,
632 std::string* accumulatedErrors )
634 auto it = nameToTableMap_.find(tableName);
635 if(it == nameToTableMap_.end())
637 __SS__ <<
"\nCan not find table named '" << tableName
638 <<
"'\n\n\n\nYou need to load the table before it can be used."
639 <<
"It probably is missing from the member list of the Table "
640 "Group that was loaded?\n\n\n\n\n"
645 theInterface_->get(table,
660 TableVersion ConfigurationManagerRW::saveNewTable(
const std::string& tableName,
668 TableBase* table = getTableByName(tableName);
669 table->getTemporaryView(temporaryVersion)->setAuthor(username_);
673 newVersion = theInterface_->saveNewVersion(table, temporaryVersion);
675 table->setActiveView(newVersion);
678 while(!makeTemporary && !newVersion.isScratchVersion() &&
679 allTableInfo_[tableName].versions_.find(newVersion) !=
680 allTableInfo_[tableName].versions_.end())
682 __COUT_ERR__ <<
"What happenened!?? ERROR::: new persistent version v"
684 <<
" already exists!? How is it possible? Retrace your steps and "
689 temporaryVersion = table->createTemporaryView(newVersion);
691 if(newVersion.isTemporaryVersion())
692 newVersion = temporaryVersion;
694 newVersion = TableVersion::getNextVersion(newVersion);
696 __COUT_WARN__ <<
"Attempting to recover and use v" << newVersion << __E__;
700 theInterface_->saveNewVersion(table, temporaryVersion, newVersion);
702 table->setActiveView(newVersion);
705 if(newVersion.isInvalid())
707 __SS__ <<
"Something went wrong saving the new version v" << newVersion
708 <<
". What happened?! (duplicates? database error?)" << __E__;
709 __COUT_ERR__ <<
"\n" << ss.str();
714 allTableInfo_[tableName].versions_.insert(newVersion);
716 __COUT__ <<
"New version added to info " << newVersion << __E__;
727 void ConfigurationManagerRW::eraseTemporaryVersion(
const std::string& tableName,
730 TableBase* table = getTableByName(tableName);
732 table->trimTemporary(targetVersion);
735 if(allTableInfo_.find(tableName) == allTableInfo_.end())
739 if(targetVersion.isInvalid())
742 for(
auto it = allTableInfo_[tableName].versions_.begin();
743 it != allTableInfo_[tableName].versions_.end();
746 if(it->isTemporaryVersion())
748 __COUT__ <<
"Removing version info: " << *it << __E__;
749 allTableInfo_[tableName].versions_.erase(it++);
757 __COUT__ <<
"Removing version info: " << targetVersion << __E__;
758 auto it = allTableInfo_[tableName].versions_.find(targetVersion);
759 if(it == allTableInfo_[tableName].versions_.end())
761 __COUT__ <<
"Target version was not found in info versions..." << __E__;
764 allTableInfo_[tableName].versions_.erase(
765 allTableInfo_[tableName].versions_.find(targetVersion));
766 __COUT__ <<
"Target version was erased from info." << __E__;
775 void ConfigurationManagerRW::clearCachedVersions(
const std::string& tableName)
777 TableBase* table = getTableByName(tableName);
787 void ConfigurationManagerRW::clearAllCachedVersions()
789 for(
auto configInfo : allTableInfo_)
790 configInfo.second.tablePtr_->trimCache(0);
795 TableVersion ConfigurationManagerRW::copyViewToCurrentColumns(
796 const std::string& tableName,
TableVersion sourceVersion)
798 getTableByName(tableName)->reset();
803 getVersionedTableByName(tableName,
TableVersion(sourceVersion),
true);
807 table->copyView(table->getView(),
TableVersion(), username_);
810 allTableInfo_[tableName].versions_.insert(newTemporaryVersion);
812 return newTemporaryVersion;
817 void ConfigurationManagerRW::cacheGroupKey(
const std::string& groupName,
820 allGroupInfo_[groupName].keys_.emplace(key);
827 const GroupInfo& ConfigurationManagerRW::getGroupInfo(
const std::string& groupName)
835 auto it = allGroupInfo_.find(groupName);
836 if(it == allGroupInfo_.end())
838 __SS__ <<
"Group name '" << groupName
839 <<
"' not found in group info! (creating empty info)" << __E__;
840 __COUT_WARN__ << ss.str();
842 return allGroupInfo_[groupName];
859 const std::string& groupName,
860 const std::map<std::string, TableVersion>& groupMemberMap,
861 const std::map<std::string /*name*/, std::string /*alias*/>& groupAliases)
867 const GroupInfo& groupInfo = getGroupInfo(groupName);
871 std::map<std::string ,
TableVersion > compareToMemberMap;
872 std::map<std::string , std::string > compareToGroupAliases;
875 const unsigned int MAX_DEPTH_TO_CHECK = 20;
876 unsigned int keyMinToCheck = 0;
878 if(groupInfo.keys_.size())
879 keyMinToCheck = groupInfo.keys_.rbegin()->key();
880 if(keyMinToCheck > MAX_DEPTH_TO_CHECK)
882 keyMinToCheck -= MAX_DEPTH_TO_CHECK;
883 __COUT__ <<
"Checking groups back to key... " << keyMinToCheck << __E__;
888 __COUT__ <<
"Checking all groups." << __E__;
893 for(
const auto& key : groupInfo.keys_)
897 if(key.key() < keyMinToCheck)
907 loadTableGroup(groupName,
910 &compareToMemberMap ,
918 &compareToGroupAliases);
921 for(
auto& memberPair : groupMemberMap)
925 if(groupAliases.find(memberPair.first) != groupAliases.end())
928 if(compareToGroupAliases.find(memberPair.first) ==
929 compareToGroupAliases.end() ||
930 groupAliases.at(memberPair.first) !=
931 compareToGroupAliases.at(memberPair.first))
940 else if(compareToGroupAliases.find(memberPair.first) !=
941 compareToGroupAliases.end())
949 else if(compareToMemberMap.find(memberPair.first) ==
950 compareToMemberMap.end() ||
952 compareToMemberMap.at(memberPair.first))
963 if(groupMemberMap.size() != compareToMemberMap.size())
967 __COUT__ <<
"Found exact match with key: " << key << __E__;
971 __COUT__ <<
"No match found - this group is new!" << __E__;
984 const std::string& groupName,
985 std::map<std::string, TableVersion>& groupMembers,
986 const std::string& groupComment,
987 std::map<std::string /*table*/, std::string /*alias*/>* groupAliases)
995 if(groupMembers.size() == 0)
997 __SS__ <<
"Empty group member list. Can not create a group without members!"
1004 TableGroupKey::getNextKey(theInterface_->findLatestGroupKey(groupName));
1006 __COUT__ <<
"New Key for group: " << groupName <<
" found as " << newKey << __E__;
1010 std::map<std::string, TableInfo> allCfgInfo = getAllTableInfo();
1011 for(
auto& memberPair : groupMembers)
1014 if(allCfgInfo.find(memberPair.first) == allCfgInfo.end())
1016 __COUT_ERR__ <<
"Group member \"" << memberPair.first
1017 <<
"\" not found in database!";
1019 if(groupMetadataTable_.getTableName() == memberPair.first)
1022 <<
"Looks like this is the groupMetadataTable_ '"
1023 << ConfigurationInterface::GROUP_METADATA_TABLE_NAME
1024 <<
".' Note that this table is added to the member map when groups "
1026 <<
"It should not be part of member map when calling this function."
1028 __COUT__ <<
"Attempting to recover." << __E__;
1029 groupMembers.erase(groupMembers.find(memberPair.first));
1033 __SS__ << (
"Group member not found!") << __E__;
1038 if(allCfgInfo[memberPair.first].versions_.find(memberPair.second) ==
1039 allCfgInfo[memberPair.first].versions_.end())
1041 __SS__ <<
"Group member \"" << memberPair.first <<
"\" version \""
1042 << memberPair.second <<
"\" not found in database!";
1050 for(
auto& aliasPair : *groupAliases)
1053 if(groupMembers.find(aliasPair.first) == groupMembers.end())
1055 __COUT_ERR__ <<
"Group member \"" << aliasPair.first
1056 <<
"\" not found in group member map!";
1058 __SS__ << (
"Alias table not found in member list!") << __E__;
1068 std::string groupAliasesString =
"";
1070 groupAliasesString = StringMacros::mapToString(
1071 *groupAliases,
"," ,
":" );
1072 __COUT__ <<
"Metadata: " << username_ <<
" " << time(0) <<
" " << groupComment
1073 <<
" " << groupAliasesString << __E__;
1077 while(groupMetadataTable_.getViewP()->getNumberOfRows() > 1)
1078 groupMetadataTable_.getViewP()->deleteRow(0);
1079 if(groupMetadataTable_.getViewP()->getNumberOfRows() == 0)
1080 groupMetadataTable_.getViewP()->addRow();
1083 groupMetadataTable_.getViewP()->setValue(
1084 groupAliasesString, 0, ConfigurationManager::METADATA_COL_ALIASES);
1085 groupMetadataTable_.getViewP()->setValue(
1086 groupComment, 0, ConfigurationManager::METADATA_COL_COMMENT);
1087 groupMetadataTable_.getViewP()->setValue(
1088 username_, 0, ConfigurationManager::METADATA_COL_AUTHOR);
1089 groupMetadataTable_.getViewP()->setValue(
1090 time(0), 0, ConfigurationManager::METADATA_COL_TIMESTAMP);
1093 groupMetadataTable_.getViewP()->setVersion(TableVersion::getNextVersion(
1094 theInterface_->findLatestVersion(&groupMetadataTable_)));
1098 theInterface_->saveActiveVersion(&groupMetadataTable_);
1101 groupMembers[groupMetadataTable_.getTableName()] =
1102 groupMetadataTable_.getViewVersion();
1104 theInterface_->saveTableGroup(
1105 groupMembers, TableGroupKey::getFullGroupString(groupName, newKey));
1106 __COUT__ <<
"Created table group: " << groupName <<
":" << newKey << __E__;
1108 catch(std::runtime_error& e)
1110 __COUT_ERR__ <<
"Failed to create table group: " << groupName <<
":" << newKey
1112 __COUT_ERR__ <<
"\n\n" << e.what() << __E__;
1117 __COUT_ERR__ <<
"Failed to create table group: " << groupName <<
":" << newKey
1123 cacheGroupKey(groupName, newKey);
1135 __COUT_INFO__ <<
"Creating new backbone from temporary version " << temporaryVersion
1141 auto backboneMemberNames = ConfigurationManager::getBackboneMemberNames();
1142 for(
auto& name : backboneMemberNames)
1144 retNewVersion = ConfigurationManager::getTableByName(name)->getNextVersion();
1145 __COUT__ <<
"New version for backbone member (" << name <<
"): " << retNewVersion
1147 if(retNewVersion > newVersion)
1148 newVersion = retNewVersion;
1151 __COUT__ <<
"Common new backbone version found as " << newVersion << __E__;
1154 for(
auto& name : backboneMemberNames)
1157 retNewVersion = getConfigurationInterface()->saveNewVersion(
1158 getTableByName(name), temporaryVersion, newVersion);
1159 if(retNewVersion != newVersion)
1161 __SS__ <<
"Failure! New view requested was " << newVersion
1162 <<
". Mismatched new view created: " << retNewVersion << __E__;
1163 __COUT_ERR__ << ss.str();
1172 void ConfigurationManagerRW::testXDAQContext()
1176 __COUT__ <<
"Loading table..." << __E__;
1184 __COUT__ <<
"Value: " << v << __E__;
1185 __COUT__ <<
"Value index: " << t.getValue<
int>() << __E__;
1191 __COUT__ <<
"Failed to load table..." << __E__;