1 #include "otsdaq-core/ConfigurationInterface/ConfigurationManagerRW.h"
30 #define __MF_SUBJECT__ "ConfigurationManagerRW"
32 #define TABLE_INFO_PATH std::string(getenv("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(getenv("USER_DATA")) + "/ServiceData") \
38 : (std::string(getenv("SERVICE_DATA_PATH")))) + \
39 "/CoreTableInfoNames.dat"
43 ConfigurationManagerRW::ConfigurationManagerRW(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,
"ContextGroup/%s\n", name.c_str());
142 for(
const auto& name : backboneMemberNames)
145 fprintf(fp,
"BackboneGroup/%s\n", name.c_str());
149 for(
const auto& name : iterateMemberNames)
152 fprintf(fp,
"IterateGroup/%s\n", 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,
"ContextGroup/%s\n", name.c_str());
172 for(
const auto& name : backboneMemberNames)
173 fprintf(fp,
"BackboneGroup/%s\n", name.c_str());
174 for(
const auto& name : iterateMemberNames)
175 fprintf(fp,
"IterateGroup/%s\n", 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)
199 if(accumulatedErrors)
200 *accumulatedErrors =
"";
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)
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" << __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)
473 loadTableGroup(configGroupName,
478 accumulatedTreeErrors);
480 if(accumulatedTreeErrors && *accumulatedTreeErrors !=
"")
482 __COUT_ERR__ <<
"Errors were accumulated so de-activating group: "
483 << configGroupName <<
" (" << configGroupKey <<
")" << __E__;
486 destroyTableGroup(configGroupName,
true);
493 __COUT_INFO__ <<
"Updating persistent active groups to "
494 << ConfigurationManager::ACTIVE_GROUPS_FILENAME <<
" ..." << __E__;
495 __MOUT_INFO__ <<
"Updating persistent active groups to "
496 << ConfigurationManager::ACTIVE_GROUPS_FILENAME <<
" ..." << __E__;
498 std::string fn = ConfigurationManager::ACTIVE_GROUPS_FILENAME;
499 FILE* fp = fopen(fn.c_str(),
"w");
502 __SS__ <<
"Fatal Error! Unable to open the file "
503 << ConfigurationManager::ACTIVE_GROUPS_FILENAME
504 <<
" for editing! Is there a permissions problem?" << __E__;
505 __COUT_ERR__ << ss.str();
510 __MCOUT_INFO__(
"Active Context table group: "
511 << theContextTableGroup_ <<
"("
512 << (theContextTableGroupKey_
513 ? theContextTableGroupKey_->toString().c_str()
516 __MCOUT_INFO__(
"Active Backbone table group: "
517 << theBackboneTableGroup_ <<
"("
518 << (theBackboneTableGroupKey_
519 ? theBackboneTableGroupKey_->toString().c_str()
522 __MCOUT_INFO__(
"Active Iterate table group: "
523 << theIterateTableGroup_ <<
"("
524 << (theIterateTableGroupKey_
525 ? theIterateTableGroupKey_->toString().c_str()
528 __MCOUT_INFO__(
"Active Configuration table group: "
529 << theConfigurationTableGroup_ <<
"("
530 << (theConfigurationTableGroupKey_
531 ? theConfigurationTableGroupKey_->toString().c_str()
535 fprintf(fp,
"%s\n", theContextTableGroup_.c_str());
539 theContextTableGroupKey_ ? theContextTableGroupKey_->toString().c_str() :
"-1");
540 fprintf(fp,
"%s\n", theBackboneTableGroup_.c_str());
544 theBackboneTableGroupKey_ ? theBackboneTableGroupKey_->toString().c_str() :
"-1");
545 fprintf(fp,
"%s\n", theIterateTableGroup_.c_str());
549 theIterateTableGroupKey_ ? theIterateTableGroupKey_->toString().c_str() :
"-1");
550 fprintf(fp,
"%s\n", theConfigurationTableGroup_.c_str());
553 theConfigurationTableGroupKey_
554 ? theConfigurationTableGroupKey_->toString().c_str()
563 TableVersion ConfigurationManagerRW::createTemporaryBackboneView(
566 __COUT_INFO__ <<
"Creating temporary backbone view from version " << sourceViewVersion
571 TableVersion::getNextTemporaryVersion();
573 auto backboneMemberNames = ConfigurationManager::getBackboneMemberNames();
574 for(
auto& name : backboneMemberNames)
577 ConfigurationManager::getTableByName(name)->getNextTemporaryVersion();
578 if(retTmpVersion < tmpVersion)
579 tmpVersion = retTmpVersion;
582 __COUT__ <<
"Common temporary backbone version found as " << tmpVersion << __E__;
585 for(
auto& name : backboneMemberNames)
588 getTableByName(name)->createTemporaryView(sourceViewVersion, tmpVersion);
589 if(retTmpVersion != tmpVersion)
591 __SS__ <<
"Failure! Temporary view requested was " << tmpVersion
592 <<
". Mismatched temporary view created: " << retTmpVersion << __E__;
593 __COUT_ERR__ << ss.str();
602 TableBase* ConfigurationManagerRW::getTableByName(
const std::string& tableName)
604 if(nameToTableMap_.find(tableName) == nameToTableMap_.end())
606 __SS__ <<
"Table not found with name: " << tableName << __E__;
608 if((f = tableName.find(
' ')) != std::string::npos)
609 ss <<
"There was a space character found in the table name needle at "
611 << f <<
" in the string (was this intended?). " << __E__;
612 __COUT_ERR__ <<
"\n" << ss.str();
615 return nameToTableMap_[tableName];
623 TableBase* ConfigurationManagerRW::getVersionedTableByName(
const std::string& tableName,
625 bool looseColumnMatching)
627 auto it = nameToTableMap_.find(tableName);
628 if(it == nameToTableMap_.end())
630 __SS__ <<
"\nCan not find table named '" << tableName
631 <<
"'\n\n\n\nYou need to load the table before it can be used."
632 <<
"It probably is missing from the member list of the Table "
633 "Group that was loaded?\n\n\n\n\n"
638 theInterface_->get(table,
645 looseColumnMatching);
652 TableVersion ConfigurationManagerRW::saveNewTable(
const std::string& tableName,
660 TableBase* table = getTableByName(tableName);
661 table->getTemporaryView(temporaryVersion)->setAuthor(username_);
665 newVersion = theInterface_->saveNewVersion(table, temporaryVersion);
667 table->setActiveView(newVersion);
670 while(!makeTemporary && !newVersion.isScratchVersion() &&
671 allTableInfo_[tableName].versions_.find(newVersion) !=
672 allTableInfo_[tableName].versions_.end())
674 __COUT_ERR__ <<
"What happenened!?? ERROR::: new persistent version v"
676 <<
" already exists!? How is it possible? Retrace your steps and "
681 temporaryVersion = table->createTemporaryView(newVersion);
683 if(newVersion.isTemporaryVersion())
684 newVersion = temporaryVersion;
686 newVersion = TableVersion::getNextVersion(newVersion);
688 __COUT_WARN__ <<
"Attempting to recover and use v" << newVersion << __E__;
692 theInterface_->saveNewVersion(table, temporaryVersion, newVersion);
694 table->setActiveView(newVersion);
697 if(newVersion.isInvalid())
699 __SS__ <<
"Something went wrong saving the new version v" << newVersion
700 <<
". What happened?! (duplicates? database error?)" << __E__;
701 __COUT_ERR__ <<
"\n" << ss.str();
706 allTableInfo_[tableName].versions_.insert(newVersion);
708 __COUT__ <<
"New version added to info " << newVersion << __E__;
718 void ConfigurationManagerRW::eraseTemporaryVersion(
const std::string& tableName,
721 TableBase* table = getTableByName(tableName);
723 table->trimTemporary(targetVersion);
726 if(allTableInfo_.find(tableName) == allTableInfo_.end())
730 if(targetVersion.isInvalid())
733 for(
auto it = allTableInfo_[tableName].versions_.begin();
734 it != allTableInfo_[tableName].versions_.end();
737 if(it->isTemporaryVersion())
739 __COUT__ <<
"Removing version info: " << *it << __E__;
740 allTableInfo_[tableName].versions_.erase(it++);
748 __COUT__ <<
"Removing version info: " << targetVersion << __E__;
749 auto it = allTableInfo_[tableName].versions_.find(targetVersion);
750 if(it == allTableInfo_[tableName].versions_.end())
752 __COUT__ <<
"Target version was not found in info versions..." << __E__;
755 allTableInfo_[tableName].versions_.erase(
756 allTableInfo_[tableName].versions_.find(targetVersion));
757 __COUT__ <<
"Target version was erased from info." << __E__;
766 void ConfigurationManagerRW::clearCachedVersions(
const std::string& tableName)
768 TableBase* table = getTableByName(tableName);
778 void ConfigurationManagerRW::clearAllCachedVersions()
780 for(
auto configInfo : allTableInfo_)
781 configInfo.second.tablePtr_->trimCache(0);
786 TableVersion ConfigurationManagerRW::copyViewToCurrentColumns(
787 const std::string& tableName,
TableVersion sourceVersion)
789 getTableByName(tableName)->reset();
794 getVersionedTableByName(tableName,
TableVersion(sourceVersion),
true);
798 table->copyView(table->getView(),
TableVersion(), username_);
801 allTableInfo_[tableName].versions_.insert(newTemporaryVersion);
803 return newTemporaryVersion;
808 void ConfigurationManagerRW::cacheGroupKey(
const std::string& groupName,
811 allGroupInfo_[groupName].keys_.emplace(key);
818 const GroupInfo& ConfigurationManagerRW::getGroupInfo(
const std::string& groupName)
826 auto it = allGroupInfo_.find(groupName);
827 if(it == allGroupInfo_.end())
829 __SS__ <<
"Group name '" << groupName
830 <<
"' not found in group info! (creating empty info)" << __E__;
831 __COUT_WARN__ << ss.str();
833 return allGroupInfo_[groupName];
850 const std::string& groupName,
851 const std::map<std::string, TableVersion>& groupMemberMap,
852 const std::map<std::string /*name*/, std::string /*alias*/>& groupAliases)
858 const GroupInfo& groupInfo = getGroupInfo(groupName);
862 std::map<std::string ,
TableVersion > compareToMemberMap;
863 std::map<std::string , std::string > compareToGroupAliases;
866 const unsigned int MAX_DEPTH_TO_CHECK = 20;
867 unsigned int keyMinToCheck = 0;
869 if(groupInfo.keys_.size())
870 keyMinToCheck = groupInfo.keys_.rbegin()->key();
871 if(keyMinToCheck > MAX_DEPTH_TO_CHECK)
873 keyMinToCheck -= MAX_DEPTH_TO_CHECK;
874 __COUT__ <<
"Checking groups back to key... " << keyMinToCheck << __E__;
879 __COUT__ <<
"Checking all groups." << __E__;
884 for(
const auto& key : groupInfo.keys_)
888 if(key.key() < keyMinToCheck)
898 loadTableGroup(groupName,
901 &compareToMemberMap ,
909 &compareToGroupAliases);
912 for(
auto& memberPair : groupMemberMap)
916 if(groupAliases.find(memberPair.first) != groupAliases.end())
919 if(compareToGroupAliases.find(memberPair.first) ==
920 compareToGroupAliases.end() ||
921 groupAliases.at(memberPair.first) !=
922 compareToGroupAliases.at(memberPair.first))
931 else if(compareToGroupAliases.find(memberPair.first) !=
932 compareToGroupAliases.end())
940 else if(compareToMemberMap.find(memberPair.first) ==
941 compareToMemberMap.end() ||
943 compareToMemberMap.at(memberPair.first))
954 if(groupMemberMap.size() != compareToMemberMap.size())
958 __COUT__ <<
"Found exact match with key: " << key << __E__;
962 __COUT__ <<
"No match found - this group is new!" << __E__;
975 const std::string& groupName,
976 std::map<std::string, TableVersion>& groupMembers,
977 const std::string& groupComment,
978 std::map<std::string /*table*/, std::string /*alias*/>* groupAliases)
986 if(groupMembers.size() == 0)
988 __SS__ <<
"Empty group member list. Can not create a group without members!"
995 TableGroupKey::getNextKey(theInterface_->findLatestGroupKey(groupName));
997 __COUT__ <<
"New Key for group: " << groupName <<
" found as " << newKey << __E__;
1001 std::map<std::string, TableInfo> allCfgInfo = getAllTableInfo();
1002 for(
auto& memberPair : groupMembers)
1005 if(allCfgInfo.find(memberPair.first) == allCfgInfo.end())
1007 __COUT_ERR__ <<
"Group member \"" << memberPair.first
1008 <<
"\" not found in database!";
1010 if(groupMetadataTable_.getTableName() == memberPair.first)
1013 <<
"Looks like this is the groupMetadataTable_ '"
1014 << ConfigurationInterface::GROUP_METADATA_TABLE_NAME
1015 <<
".' Note that this table is added to the member map when groups "
1017 <<
"It should not be part of member map when calling this function."
1019 __COUT__ <<
"Attempting to recover." << __E__;
1020 groupMembers.erase(groupMembers.find(memberPair.first));
1024 __SS__ << (
"Group member not found!") << __E__;
1029 if(allCfgInfo[memberPair.first].versions_.find(memberPair.second) ==
1030 allCfgInfo[memberPair.first].versions_.end())
1032 __SS__ <<
"Group member \"" << memberPair.first <<
"\" version \""
1033 << memberPair.second <<
"\" not found in database!";
1041 for(
auto& aliasPair : *groupAliases)
1044 if(groupMembers.find(aliasPair.first) == groupMembers.end())
1046 __COUT_ERR__ <<
"Group member \"" << aliasPair.first
1047 <<
"\" not found in group member map!";
1049 __SS__ << (
"Alias table not found in member list!") << __E__;
1059 std::string groupAliasesString =
"";
1061 groupAliasesString = StringMacros::mapToString(
1062 *groupAliases,
"," ,
":" );
1063 __COUT__ <<
"Metadata: " << username_ <<
" " << time(0) <<
" " << groupComment
1064 <<
" " << groupAliasesString << __E__;
1068 while(groupMetadataTable_.getViewP()->getNumberOfRows() > 1)
1069 groupMetadataTable_.getViewP()->deleteRow(0);
1070 if(groupMetadataTable_.getViewP()->getNumberOfRows() == 0)
1071 groupMetadataTable_.getViewP()->addRow();
1074 groupMetadataTable_.getViewP()->setValue(
1075 groupAliasesString, 0, ConfigurationManager::METADATA_COL_ALIASES);
1076 groupMetadataTable_.getViewP()->setValue(
1077 groupComment, 0, ConfigurationManager::METADATA_COL_COMMENT);
1078 groupMetadataTable_.getViewP()->setValue(
1079 username_, 0, ConfigurationManager::METADATA_COL_AUTHOR);
1080 groupMetadataTable_.getViewP()->setValue(
1081 time(0), 0, ConfigurationManager::METADATA_COL_TIMESTAMP);
1084 groupMetadataTable_.getViewP()->setVersion(TableVersion::getNextVersion(
1085 theInterface_->findLatestVersion(&groupMetadataTable_)));
1089 theInterface_->saveActiveVersion(&groupMetadataTable_);
1092 groupMembers[groupMetadataTable_.getTableName()] =
1093 groupMetadataTable_.getViewVersion();
1095 theInterface_->saveTableGroup(
1096 groupMembers, TableGroupKey::getFullGroupString(groupName, newKey));
1097 __COUT__ <<
"Created table group: " << groupName <<
":" << newKey << __E__;
1099 catch(std::runtime_error& e)
1101 __COUT_ERR__ <<
"Failed to create table group: " << groupName <<
":" << newKey
1103 __COUT_ERR__ <<
"\n\n" << e.what() << __E__;
1108 __COUT_ERR__ <<
"Failed to create table group: " << groupName <<
":" << newKey
1114 cacheGroupKey(groupName, newKey);
1126 __COUT_INFO__ <<
"Creating new backbone from temporary version " << temporaryVersion
1132 auto backboneMemberNames = ConfigurationManager::getBackboneMemberNames();
1133 for(
auto& name : backboneMemberNames)
1135 retNewVersion = ConfigurationManager::getTableByName(name)->getNextVersion();
1136 __COUT__ <<
"New version for backbone member (" << name <<
"): " << retNewVersion
1138 if(retNewVersion > newVersion)
1139 newVersion = retNewVersion;
1142 __COUT__ <<
"Common new backbone version found as " << newVersion << __E__;
1145 for(
auto& name : backboneMemberNames)
1148 retNewVersion = getConfigurationInterface()->saveNewVersion(
1149 getTableByName(name), temporaryVersion, newVersion);
1150 if(retNewVersion != newVersion)
1152 __SS__ <<
"Failure! New view requested was " << newVersion
1153 <<
". Mismatched new view created: " << retNewVersion << __E__;
1154 __COUT_ERR__ << ss.str();
1327 __COUT__ <<
"Loading table..." << __E__;
1335 __COUT__ <<
"Value: " << v << __E__;
1336 __COUT__ <<
"Value index: " << t.getValue<
int>() << __E__;
1377 __COUT__ <<
"Failed to load table..." << __E__;