void InputVariableRecord::constructRelatedRecords(const analysis::InputVariable& inputVariable) {
AttributeVector attributes, dbAttributes;
InputVariableRecord copyOfThis(getImpl<detail::InputVariableRecord_Impl>());
if (analysis::OptionalUncertaintyDescription dbUDesc = uncertaintyDescription()) {
dbAttributes = dbUDesc->cast<analysis::GenericUncertaintyDescription>().attributes();
}
if (analysis::OptionalUncertaintyDescription udesc = inputVariable.uncertaintyDescription()) {
attributes = udesc->cast<analysis::GenericUncertaintyDescription>().attributes();
}
for (const Attribute& attribute : attributes) {
// find in dbOptions
auto dbIt = std::find_if(dbAttributes.begin(),dbAttributes.end(),
std::bind(uuidsEqual<Attribute,Attribute>,std::placeholders::_1,attribute));
// if not there, or if different versionUUID, save it
if ((dbIt == dbAttributes.end()) || (attribute.versionUUID() != dbIt->versionUUID())) {
AttributeRecord udescAttributeRecord(attribute,copyOfThis);
}
// if there, erase from dbOptions
if (dbIt != dbAttributes.end()) {
dbAttributes.erase(dbIt);
}
}
// any attributes left in dbAttributes should be removed from the database
ProjectDatabase database = projectDatabase();
for (const Attribute& toRemove : dbAttributes) {
AttributeRecord dbUDescAttributeRecord = database.getObjectRecordByHandle<AttributeRecord>(toRemove.uuid()).get();
database.removeRecord(dbUDescAttributeRecord);
}
}
MeasureGroup::MeasureGroup(const std::string& name,
const std::vector<Measure>& measures)
: DiscreteVariable(std::shared_ptr<detail::MeasureGroup_Impl>(
new detail::MeasureGroup_Impl(name,measures)))
{
MeasureGroup copyOfThis(getImpl<detail::MeasureGroup_Impl>());
for (const Measure& measure : measures) {
measure.setParent(copyOfThis);
}
}
void DakotaAlgorithmRecord::constructRelatedRecords(const analysis::DakotaAlgorithm& algorithm) {
DakotaAlgorithmRecord copyOfThis(getImpl<detail::DakotaAlgorithmRecord_Impl>());
if (OptionalFileReference restartFile = algorithm.restartFileReference()) {
FileReferenceRecord restartFileRecord(*restartFile,copyOfThis);
setRestartFileReferenceRecordId(restartFileRecord.id());
}
if (OptionalFileReference outFile = algorithm.outFileReference()) {
FileReferenceRecord outFileRecord(*outFile,copyOfThis);
setOutFileReferenceRecordId(outFileRecord.id());
}
}
void MeasureGroupRecord::constructMeasureRecords(const analysis::MeasureGroup& measureGroup) {
MeasureGroupRecord copyOfThis(getImpl<detail::MeasureGroupRecord_Impl>());
ProjectDatabase database = copyOfThis.projectDatabase();
bool isNew = database.isNewRecord(copyOfThis);
int i = 0;
std::vector<UUID> measureUUIDs;
for (const Measure& measure : measureGroup.measures(false)) {
measureUUIDs.push_back(measure.uuid());
if (measure.isDirty() || isNew) {
MeasureRecord newMeasureRecord =
MeasureRecord::factoryFromMeasure(measure,copyOfThis,i);
}
++i;
}
if (!isNew) {
removeMeasureRecords(measureUUIDs,database);
}
}
MeasureGroup::MeasureGroup(const UUID& uuid,
const UUID& versionUUID,
const std::string& name,
const std::string& displayName,
const std::string& description,
const boost::optional<UncertaintyDescription>& udesc,
const std::vector<Measure>& measures)
: DiscreteVariable(std::shared_ptr<detail::MeasureGroup_Impl>(
new detail::MeasureGroup_Impl(uuid,
versionUUID,
name,
displayName,
description,
udesc,
measures)))
{
MeasureGroup copyOfThis(getImpl<detail::MeasureGroup_Impl>());
for (const Measure& measure : measures) {
measure.setParent(copyOfThis);
}
}
void LEVEL_PARTITION::split(bool hSplit, int splitPos, LEVEL_PARTITION& a, LEVEL_PARTITION& b)
{
LEVEL_PARTITION copyOfThis(*this);
if(hSplit)
{
int oldH = copyOfThis.h;
copyOfThis.h = splitPos - copyOfThis.y;
a = copyOfThis;
b = LEVEL_PARTITION(copyOfThis.x, splitPos, copyOfThis.w, oldH-copyOfThis.h);
}
else
{
int oldW = copyOfThis.w;
copyOfThis.w = splitPos - copyOfThis.x;
a = copyOfThis;
b = LEVEL_PARTITION(splitPos, copyOfThis.y, oldW-copyOfThis.w, copyOfThis.h);
}
}
void CloudSessionRecord::constructRelatedRecords(const CloudSession& cloudSession,
ProjectDatabase& database)
{
CloudSessionRecord copyOfThis(getImpl<detail::CloudSessionRecord_Impl>());
bool isNew = database.isNewRecord(copyOfThis);
if (!isNew) {
getImpl<detail::CloudSessionRecord_Impl>()->revertToLastRecordIds();
}
if (isNew || (getImpl<detail::CloudSessionRecord_Impl>()->lastUuidLast() != cloudSession.versionUUID())) {
// remove any existing UrlRecords that have this object as its parent
ObjectRecordVector childUrls = children();
for (ObjectRecord& childUrl : childUrls) {
database.removeRecord(childUrl);
}
// create new UrlRecords
OptionalAWSSession awsSession = cloudSession.optionalCast<AWSSession>();
if (OptionalUrl serverUrl = cloudSession.serverUrl()) {
UrlRecord serverRecord(*serverUrl,copyOfThis);
if (awsSession) {
serverRecord.setName(awsSession->serverId());
}
getImpl<detail::CloudSessionRecord_Impl>()->setServerUrlRecordId(serverRecord.id());
}
StringVector workerIds;
if (awsSession) {
workerIds = awsSession->workerIds();
}
unsigned index(0);
for (const Url& workerUrl : cloudSession.workerUrls()) {
UrlRecord workerRecord(workerUrl,copyOfThis);
if (index < workerIds.size()) {
workerRecord.setName(workerIds[index]);
}
++index;
}
}
}
bool LEVEL_PARTITION::testSplit(bool hSplit, int splitPos, int minRoomSize)
{
LEVEL_PARTITION copyOfThis(*this);
if(!hSplit &&
(copyOfThis.x + copyOfThis.w <= splitPos ||
splitPos <= copyOfThis.x ||
splitPos - x < minRoomSize
))
return false;
if(hSplit &&
(copyOfThis.y + copyOfThis.h <= splitPos ||
splitPos <= copyOfThis.y ||
splitPos - y < minRoomSize))
return false;
LEVEL_PARTITION tempA, tempB;
copyOfThis.split(hSplit, splitPos, tempA, tempB);
return tempA.isValid(minRoomSize) && tempB.isValid(minRoomSize) &&
tempA.area() >= minRoomSize*minRoomSize &&
tempB.area() >= minRoomSize*minRoomSize;
}
void RubyContinuousVariableRecord::constructRelatedRecords(const analysis::Variable& variable)
{
analysis::RubyContinuousVariable rubyContinuousVariable = variable.cast<analysis::RubyContinuousVariable>();
RubyContinuousVariableRecord copyOfThis(getImpl<detail::RubyContinuousVariableRecord_Impl>());
ProjectDatabase database = projectDatabase();
bool isNew = database.isNewRecord(copyOfThis);
if (!isNew) {
getImpl<detail::RubyContinuousVariableRecord_Impl>()->revertToLastRecordIds();
}
// Save resource RubyMeasure
if (isNew || rubyContinuousVariable.perturbation().isDirty()) {
RubyMeasureRecord rubyMeasureRecord(rubyContinuousVariable.measure(),database);
getImpl<detail::RubyContinuousVariableRecord_Impl>()->setRubyMeasureRecordId(rubyMeasureRecord.id());
}
// Save child OSArgument
OSArgument argument = rubyContinuousVariable.argument();
bool saveArgument = false;
if (!isNew) {
{
// see if old argument record should be removed
OSArgumentRecord oldArgumentRecord = osArgumentRecord();
if (oldArgumentRecord.handle() != argument.uuid()) {
database.removeRecord(oldArgumentRecord);
saveArgument = true;
}
else if (oldArgumentRecord.uuidLast() != argument.versionUUID()) {
saveArgument = true;
}
}
database.unloadUnusedCleanRecords();
}
if (saveArgument || isNew) {
OSArgumentRecord osArgumentRecord(argument,copyOfThis);
}
}
void Algorithm::createCallbackForOptions() const {
Algorithm copyOfThis(getImpl<detail::Algorithm_Impl>());
options().setAlgorithm(copyOfThis);
}
