1 #include "otsdaq-core/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(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)
473 loadTableGroup(configGroupName,
478 accumulatedTreeErrors);
480 if(accumulatedTreeErrors && *accumulatedTreeErrors !=
"")
482 __COUT_ERR__ <<
"Errors were accumulated so de-activating group: "
483 << configGroupName <<
" (" << tableGroupKey <<
")" << __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__;
719 void ConfigurationManagerRW::eraseTemporaryVersion(
const std::string& tableName,
722 TableBase* table = getTableByName(tableName);
724 table->trimTemporary(targetVersion);
727 if(allTableInfo_.find(tableName) == allTableInfo_.end())
731 if(targetVersion.isInvalid())
734 for(
auto it = allTableInfo_[tableName].versions_.begin();
735 it != allTableInfo_[tableName].versions_.end();
738 if(it->isTemporaryVersion())
740 __COUT__ <<
"Removing version info: " << *it << __E__;
741 allTableInfo_[tableName].versions_.erase(it++);
749 __COUT__ <<
"Removing version info: " << targetVersion << __E__;
750 auto it = allTableInfo_[tableName].versions_.find(targetVersion);
751 if(it == allTableInfo_[tableName].versions_.end())
753 __COUT__ <<
"Target version was not found in info versions..." << __E__;
756 allTableInfo_[tableName].versions_.erase(
757 allTableInfo_[tableName].versions_.find(targetVersion));
758 __COUT__ <<
"Target version was erased from info." << __E__;
767 void ConfigurationManagerRW::clearCachedVersions(
const std::string& tableName)
769 TableBase* table = getTableByName(tableName);
779 void ConfigurationManagerRW::clearAllCachedVersions()
781 for(
auto configInfo : allTableInfo_)
782 configInfo.second.tablePtr_->trimCache(0);
787 TableVersion ConfigurationManagerRW::copyViewToCurrentColumns(
788 const std::string& tableName,
TableVersion sourceVersion)
790 getTableByName(tableName)->reset();
795 getVersionedTableByName(tableName,
TableVersion(sourceVersion),
true);
799 table->copyView(table->getView(),
TableVersion(), username_);
802 allTableInfo_[tableName].versions_.insert(newTemporaryVersion);
804 return newTemporaryVersion;
809 void ConfigurationManagerRW::cacheGroupKey(
const std::string& groupName,
812 allGroupInfo_[groupName].keys_.emplace(key);
819 const GroupInfo& ConfigurationManagerRW::getGroupInfo(
const std::string& groupName)
827 auto it = allGroupInfo_.find(groupName);
828 if(it == allGroupInfo_.end())
830 __SS__ <<
"Group name '" << groupName
831 <<
"' not found in group info! (creating empty info)" << __E__;
832 __COUT_WARN__ << ss.str();
834 return allGroupInfo_[groupName];
851 const std::string& groupName,
852 const std::map<std::string, TableVersion>& groupMemberMap,
853 const std::map<std::string /*name*/, std::string /*alias*/>& groupAliases)
859 const GroupInfo& groupInfo = getGroupInfo(groupName);
863 std::map<std::string ,
TableVersion > compareToMemberMap;
864 std::map<std::string , std::string > compareToGroupAliases;
867 const unsigned int MAX_DEPTH_TO_CHECK = 20;
868 unsigned int keyMinToCheck = 0;
870 if(groupInfo.keys_.size())
871 keyMinToCheck = groupInfo.keys_.rbegin()->key();
872 if(keyMinToCheck > MAX_DEPTH_TO_CHECK)
874 keyMinToCheck -= MAX_DEPTH_TO_CHECK;
875 __COUT__ <<
"Checking groups back to key... " << keyMinToCheck << __E__;
880 __COUT__ <<
"Checking all groups." << __E__;
885 for(
const auto& key : groupInfo.keys_)
889 if(key.key() < keyMinToCheck)
899 loadTableGroup(groupName,
902 &compareToMemberMap ,
910 &compareToGroupAliases);
913 for(
auto& memberPair : groupMemberMap)
917 if(groupAliases.find(memberPair.first) != groupAliases.end())
920 if(compareToGroupAliases.find(memberPair.first) ==
921 compareToGroupAliases.end() ||
922 groupAliases.at(memberPair.first) !=
923 compareToGroupAliases.at(memberPair.first))
932 else if(compareToGroupAliases.find(memberPair.first) !=
933 compareToGroupAliases.end())
941 else if(compareToMemberMap.find(memberPair.first) ==
942 compareToMemberMap.end() ||
944 compareToMemberMap.at(memberPair.first))
955 if(groupMemberMap.size() != compareToMemberMap.size())
959 __COUT__ <<
"Found exact match with key: " << key << __E__;
963 __COUT__ <<
"No match found - this group is new!" << __E__;
976 const std::string& groupName,
977 std::map<std::string, TableVersion>& groupMembers,
978 const std::string& groupComment,
979 std::map<std::string /*table*/, std::string /*alias*/>* groupAliases)
987 if(groupMembers.size() == 0)
989 __SS__ <<
"Empty group member list. Can not create a group without members!"
996 TableGroupKey::getNextKey(theInterface_->findLatestGroupKey(groupName));
998 __COUT__ <<
"New Key for group: " << groupName <<
" found as " << newKey << __E__;
1002 std::map<std::string, TableInfo> allCfgInfo = getAllTableInfo();
1003 for(
auto& memberPair : groupMembers)
1006 if(allCfgInfo.find(memberPair.first) == allCfgInfo.end())
1008 __COUT_ERR__ <<
"Group member \"" << memberPair.first
1009 <<
"\" not found in database!";
1011 if(groupMetadataTable_.getTableName() == memberPair.first)
1014 <<
"Looks like this is the groupMetadataTable_ '"
1015 << ConfigurationInterface::GROUP_METADATA_TABLE_NAME
1016 <<
".' Note that this table is added to the member map when groups "
1018 <<
"It should not be part of member map when calling this function."
1020 __COUT__ <<
"Attempting to recover." << __E__;
1021 groupMembers.erase(groupMembers.find(memberPair.first));
1025 __SS__ << (
"Group member not found!") << __E__;
1030 if(allCfgInfo[memberPair.first].versions_.find(memberPair.second) ==
1031 allCfgInfo[memberPair.first].versions_.end())
1033 __SS__ <<
"Group member \"" << memberPair.first <<
"\" version \""
1034 << memberPair.second <<
"\" not found in database!";
1042 for(
auto& aliasPair : *groupAliases)
1045 if(groupMembers.find(aliasPair.first) == groupMembers.end())
1047 __COUT_ERR__ <<
"Group member \"" << aliasPair.first
1048 <<
"\" not found in group member map!";
1050 __SS__ << (
"Alias table not found in member list!") << __E__;
1060 std::string groupAliasesString =
"";
1062 groupAliasesString = StringMacros::mapToString(
1063 *groupAliases,
"," ,
":" );
1064 __COUT__ <<
"Metadata: " << username_ <<
" " << time(0) <<
" " << groupComment
1065 <<
" " << groupAliasesString << __E__;
1069 while(groupMetadataTable_.getViewP()->getNumberOfRows() > 1)
1070 groupMetadataTable_.getViewP()->deleteRow(0);
1071 if(groupMetadataTable_.getViewP()->getNumberOfRows() == 0)
1072 groupMetadataTable_.getViewP()->addRow();
1075 groupMetadataTable_.getViewP()->setValue(
1076 groupAliasesString, 0, ConfigurationManager::METADATA_COL_ALIASES);
1077 groupMetadataTable_.getViewP()->setValue(
1078 groupComment, 0, ConfigurationManager::METADATA_COL_COMMENT);
1079 groupMetadataTable_.getViewP()->setValue(
1080 username_, 0, ConfigurationManager::METADATA_COL_AUTHOR);
1081 groupMetadataTable_.getViewP()->setValue(
1082 time(0), 0, ConfigurationManager::METADATA_COL_TIMESTAMP);
1085 groupMetadataTable_.getViewP()->setVersion(TableVersion::getNextVersion(
1086 theInterface_->findLatestVersion(&groupMetadataTable_)));
1090 theInterface_->saveActiveVersion(&groupMetadataTable_);
1093 groupMembers[groupMetadataTable_.getTableName()] =
1094 groupMetadataTable_.getViewVersion();
1096 theInterface_->saveTableGroup(
1097 groupMembers, TableGroupKey::getFullGroupString(groupName, newKey));
1098 __COUT__ <<
"Created table group: " << groupName <<
":" << newKey << __E__;
1100 catch(std::runtime_error& e)
1102 __COUT_ERR__ <<
"Failed to create table group: " << groupName <<
":" << newKey
1104 __COUT_ERR__ <<
"\n\n" << e.what() << __E__;
1109 __COUT_ERR__ <<
"Failed to create table group: " << groupName <<
":" << newKey
1115 cacheGroupKey(groupName, newKey);
1127 __COUT_INFO__ <<
"Creating new backbone from temporary version " << temporaryVersion
1133 auto backboneMemberNames = ConfigurationManager::getBackboneMemberNames();
1134 for(
auto& name : backboneMemberNames)
1136 retNewVersion = ConfigurationManager::getTableByName(name)->getNextVersion();
1137 __COUT__ <<
"New version for backbone member (" << name <<
"): " << retNewVersion
1139 if(retNewVersion > newVersion)
1140 newVersion = retNewVersion;
1143 __COUT__ <<
"Common new backbone version found as " << newVersion << __E__;
1146 for(
auto& name : backboneMemberNames)
1149 retNewVersion = getConfigurationInterface()->saveNewVersion(
1150 getTableByName(name), temporaryVersion, newVersion);
1151 if(retNewVersion != newVersion)
1153 __SS__ <<
"Failure! New view requested was " << newVersion
1154 <<
". Mismatched new view created: " << retNewVersion << __E__;
1155 __COUT_ERR__ << ss.str();
1328 __COUT__ <<
"Loading table..." << __E__;
1336 __COUT__ <<
"Value: " << v << __E__;
1337 __COUT__ <<
"Value index: " << t.getValue<
int>() << __E__;
1378 __COUT__ <<
"Failed to load table..." << __E__;