DDACEAlgorithm DDACEAlgorithm_Impl::fromVariant(const QVariant& variant, const VersionString& version) {
QVariantMap map = variant.toMap();
DDACEAlgorithmOptions options = DDACEAlgorithmOptions_Impl::fromVariant(map["options"],version);
return DDACEAlgorithm(toUUID(map["uuid"].toString().toStdString()),
toUUID(map["version_uuid"].toString().toStdString()),
map.contains("display_name") ? map["display_name"].toString().toStdString() : std::string(),
map.contains("description") ? map["description"].toString().toStdString() : std::string(),
map["complete"].toBool(),
map["failed"].toBool(),
map["iter"].toInt(),
options,
map.contains("restart_file_reference") ? openstudio::detail::toFileReference(map["restart_file_reference"],version) : OptionalFileReference(),
map.contains("out_file_reference") ? openstudio::detail::toFileReference(map["out_file_reference"],version) : OptionalFileReference(),
map.contains("job") ? runmanager::detail::JSON::toJob(map["job"],version, true) : boost::optional<runmanager::Job>());
}
MeasureGroup MeasureGroup_Impl::fromVariant(const QVariant& variant, const VersionString& version) {
QVariantMap map = variant.toMap();
MeasureVector measures = deserializeOrderedVector(
map["measures"].toList(),
"measure_group_index",
std::function<Measure (const QVariant&)>(std::bind(Measure_Impl::factoryFromVariant,std::placeholders::_1,version)));
return MeasureGroup(toUUID(map["uuid"].toString().toStdString()),
toUUID(map["version_uuid"].toString().toStdString()),
map.contains("name") ? map["name"].toString().toStdString() : std::string(),
map.contains("display_name") ? map["display_name"].toString().toStdString() : std::string(),
map.contains("description") ? map["description"].toString().toStdString() : std::string(),
map.contains("uncertainty_description") ? analysis::detail::toUncertaintyDescription(map["uncertainty_description"],version) : OptionalUncertaintyDescription(),
measures);
}
ObjectRecord_Impl::ObjectRecord_Impl(const ProjectDatabase& projectDatabase, const QSqlQuery& query)
: Record_Impl(projectDatabase, query)
{
OS_ASSERT(query.isValid());
OS_ASSERT(query.isActive());
OS_ASSERT(query.isSelect());
QVariant value;
value = query.value(ObjectRecordColumns::name);
OS_ASSERT(value.isValid() && !value.isNull());
m_name = value.toString().toStdString();
value = query.value(ObjectRecordColumns::displayName);
OS_ASSERT(value.isValid() && !value.isNull());
m_displayName = value.toString().toStdString();
value = query.value(ObjectRecordColumns::description);
OS_ASSERT(value.isValid() && !value.isNull());
m_description = value.toString().toStdString();
value = query.value(ObjectRecordColumns::timestampCreate);
OS_ASSERT(value.isValid() && !value.isNull());
m_timestampCreate = DateTime(value.toString().toStdString());
value = query.value(ObjectRecordColumns::timestampLast);
OS_ASSERT(value.isValid() && !value.isNull());
m_timestampLast = DateTime(value.toString().toStdString());
value = query.value(ObjectRecordColumns::uuidLast);
OS_ASSERT(value.isValid() && !value.isNull());
m_uuidLast = toUUID(value.toString().toStdString());
}
void ObjectRecord_Impl::setLastValues(const QSqlQuery& query, ProjectDatabase& projectDatabase)
{
OS_ASSERT(query.isValid());
OS_ASSERT(query.isActive());
OS_ASSERT(query.isSelect());
Record_Impl::setLastValues(query, projectDatabase);
QVariant value;
value = query.value(ObjectRecordColumns::name);
OS_ASSERT(value.isValid() && !value.isNull());
m_lastName = value.toString().toStdString();
value = query.value(ObjectRecordColumns::displayName);
OS_ASSERT(value.isValid() && !value.isNull());
m_lastDisplayName = value.toString().toStdString();
value = query.value(ObjectRecordColumns::description);
OS_ASSERT(value.isValid() && !value.isNull());
m_lastDescription = value.toString().toStdString();
value = query.value(ObjectRecordColumns::timestampCreate);
OS_ASSERT(value.isValid() && !value.isNull());
m_lastTimestampCreate = DateTime(value.toString().toStdString());
value = query.value(ObjectRecordColumns::timestampLast);
OS_ASSERT(value.isValid() && !value.isNull());
m_lastTimestampLast = DateTime(value.toString().toStdString());
value = query.value(ObjectRecordColumns::uuidLast);
OS_ASSERT(value.isValid() && !value.isNull());
m_lastUUIDLast = toUUID(value.toString().toStdString());
}
boost::optional<IdfObject> ForwardTranslator::translateEnergyManagementSystemSensor(EnergyManagementSystemSensor & modelObject)
{
boost::optional<OutputVariable> d;
boost::optional<OutputMeter> m;
boost::optional<std::string> s;
IdfObject idfObject(openstudio::IddObjectType::EnergyManagementSystem_Sensor);
m_idfObjects.push_back(idfObject);
//Name
s = modelObject.name();
if (s) {
idfObject.setName(*s);
}
s = modelObject.keyName();
if (s) {
//find uids
const int subs[] = {1};
std::string newline = s.get();
std::string possible_uid;
size_t pos;
const Model m = modelObject.model();
boost::optional<ModelObject> mObject;
boost::sregex_token_iterator j(s.get().begin(), s.get().end(), uuidInString(), subs);
while (j != boost::sregex_token_iterator()) {
possible_uid = *j++;
//look to see if uid is in the model and return the object
UUID uid = toUUID(possible_uid);
mObject = m.getModelObject<model::ModelObject>(uid);
if (mObject) {
//replace uid with namestring
pos = newline.find(possible_uid);
if (pos + 38 <= newline.length()) {
newline.replace(pos, 38, mObject.get().nameString());
}
}
}
idfObject.setString(EnergyManagementSystem_SensorFields::Output_VariableorOutput_MeterIndexKeyName, newline);
}
d = modelObject.outputVariable();
if (d.is_initialized()) {
idfObject.setString(EnergyManagementSystem_SensorFields::Output_VariableorOutput_MeterName, d.get().variableName());
return idfObject;
}
m = modelObject.outputMeter();
if (m.is_initialized()) {
idfObject.setString(EnergyManagementSystem_SensorFields::Output_VariableorOutput_MeterName, m.get().name());
return idfObject;
}
s = modelObject.outputVariableOrMeterName();
if (s.is_initialized()) {
idfObject.setString(EnergyManagementSystem_SensorFields::Output_VariableorOutput_MeterName, s.get());
return idfObject;
}
return idfObject;
}
FileReference toFileReference(const QVariant& variant, const VersionString& version) {
QVariantMap map = variant.toMap();
OptionalDateTime timestampLast;
if (version < VersionString("1.0.4")) {
timestampLast = DateTime(map["timestamp_last"].toString().toStdString());
}
else {
timestampLast = DateTime::fromISO8601(map["timestamp_last"].toString().toStdString());
}
OS_ASSERT(timestampLast);
return FileReference(toUUID(map["uuid"].toString().toStdString()),
toUUID(map["version_uuid"].toString().toStdString()),
map.contains("name") ? map["name"].toString().toStdString() : std::string(),
map.contains("display_name") ? map["display_name"].toString().toStdString() : std::string(),
map.contains("description") ? map["description"].toString().toStdString() : std::string(),
toPath(map["path"].toString()),
FileReferenceType(map["file_type"].toString().toStdString()),
timestampLast.get(),
map["checksum_create"].toString().toStdString(),
map["checksum_last"].toString().toStdString());
}
RubyContinuousVariable RubyContinuousVariable_Impl::fromVariant(const QVariant& variant,
const Measure& measure,
const VersionString& version)
{
QVariantMap map = variant.toMap();
OS_ASSERT(measure.optionalCast<RubyMeasure>());
return RubyContinuousVariable(
toUUID(map["uuid"].toString().toStdString()),
toUUID(map["version_uuid"].toString().toStdString()),
map.contains("name") ? map["name"].toString().toStdString() : std::string(),
map.contains("display_name") ? map["display_name"].toString().toStdString() : std::string(),
map.contains("description") ? map["description"].toString().toStdString() : std::string(),
map.contains("uncertainty_description") ? analysis::detail::toUncertaintyDescription(map["uncertainty_description"],version) : OptionalUncertaintyDescription(),
map.contains("minimum") ? map["minimum"].toDouble() : OptionalDouble(),
map.contains("maximum") ? map["maximum"].toDouble() : OptionalDouble(),
map.contains("increment") ? map["increment"].toDouble() : OptionalDouble(),
map.contains("n_steps") ? map["n_steps"].toInt() : OptionalInt(),
ruleset::detail::toOSArgument(map["argument"],version),
measure.cast<RubyMeasure>());
}
boost::optional<BCLMeasure> WorkflowJSON_Impl::addMeasure(const BCLMeasure& bclMeasure)
{
boost::optional<BCLMeasure> existingMeasure = getBCLMeasureByUUID(bclMeasure.uuid());
boost::optional<openstudio::path> existingMeasureDirName;
if (existingMeasure){
// TODO: check that measure type has not changed?
existingMeasureDirName = existingMeasure->directory();
boost::filesystem::remove_all(*existingMeasureDirName);
}
std::vector<openstudio::path> paths = absoluteMeasurePaths();
OS_ASSERT(!paths.empty());
// Get the name of the directory (=last level directory name), eg: /path/to/measure_folder => measure_folder
openstudio::path lastLevelDirectoryName = getLastLevelDirectoryName( bclMeasure.directory() );
if (!toUUID(toString(lastLevelDirectoryName)).isNull()){
// directory name is convertible to uuid, use the class name
lastLevelDirectoryName = toPath(bclMeasure.className());
}
int i = 1;
while (boost::filesystem::exists(paths[0] / lastLevelDirectoryName)){
std::stringstream ss;
ss << toString(lastLevelDirectoryName) << " " << i;
lastLevelDirectoryName = toPath(ss.str());
}
openstudio::path newMeasureDirName = paths[0] / lastLevelDirectoryName;
// If we have an existing measure
if( existingMeasureDirName) {
openstudio::path lastLevelExistingDirectoryName = getLastLevelDirectoryName(*existingMeasureDirName);
// And the previous directory name isn't the same as the new one
if( lastLevelExistingDirectoryName != lastLevelDirectoryName ) {
// update steps
for (auto& step : m_steps){
if (auto measureStep = step.optionalCast<MeasureStep>()){
if (measureStep->measureDirName() == toString(lastLevelExistingDirectoryName) ) {
measureStep->setMeasureDirName(toString(lastLevelDirectoryName));
}
}
}
}
}
onUpdate();
return bclMeasure.clone(newMeasureDirName);
}
bool ObjectRecord_Impl::compareValues(const QSqlQuery& query) const
{
OS_ASSERT(query.isValid());
OS_ASSERT(query.isActive());
OS_ASSERT(query.isSelect());
bool result = true;
result = result && Record_Impl::compareValues(query);
if (!result) return result;
QVariant value;
value = query.value(ObjectRecordColumns::name);
OS_ASSERT(value.isValid() && !value.isNull());
result = result && (m_name == value.toString().toStdString());
if (!result) return result;
value = query.value(ObjectRecordColumns::displayName);
OS_ASSERT(value.isValid() && !value.isNull());
result = result && (m_displayName == value.toString().toStdString());
if (!result) return result;
value = query.value(ObjectRecordColumns::description);
OS_ASSERT(value.isValid() && !value.isNull());
result = result && (m_description == value.toString().toStdString());
if (!result) return result;
value = query.value(ObjectRecordColumns::timestampCreate);
OS_ASSERT(value.isValid() && !value.isNull());
result = result && (m_timestampCreate == DateTime(value.toString().toStdString()));
if (!result) return result;
value = query.value(ObjectRecordColumns::timestampLast);
OS_ASSERT(value.isValid() && !value.isNull());
result = result && (m_timestampLast == DateTime(value.toString().toStdString()));
if (!result) return result;
value = query.value(ObjectRecordColumns::uuidLast);
OS_ASSERT(value.isValid() && !value.isNull());
result = result && (m_uuidLast == toUUID(value.toString().toStdString()));
return result;
}
T getFromQuery(const QSqlQuery& query)
{
OS_ASSERT(query.isValid());
OS_ASSERT(query.isActive());
OS_ASSERT(query.isSelect());
QVariant value = query.value(T::ColumnsType::handle);
OS_ASSERT(value.isValid() && !value.isNull());
UUID handle = toUUID(value.toString().toStdString());
boost::optional<Record> record = this->findLoadedRecord(handle);
if (record){
boost::optional<T> result = record->optionalCast<T>();
OS_ASSERT(result);
return *result;
}
boost::optional<T> result = T::factoryFromQuery(query, *this);
OS_ASSERT(result);
return *result;
}
boost::optional<openstudio::WorkspaceObject> OSRunner::getOptionalWorkspaceObjectChoiceValue(
const std::string& argument_name,
const std::map<std::string,OSArgument>& user_arguments,
const openstudio::Workspace& workspace)
{
auto it = user_arguments.find(argument_name);
std::string handleString;
if (it != user_arguments.end()) {
if (it->second.hasValue()) {
handleString = it->second.valueAsString();
}
else if (it->second.hasDefaultValue()) {
handleString = it->second.defaultValueAsString();
}
}
Handle handle = toUUID(handleString);
boost::optional<WorkspaceObject> result = workspace.getObject(handle);
return result;
}
OSArgument toOSArgument(const QVariant& variant, const VersionString& version) {
QVariantMap map = variant.toMap();
OSArgumentType type(map["type"].toString().toStdString());
QVariant value, defaultValue;
OS_ASSERT(value.isNull() && defaultValue.isNull());
if (map.contains("value")) {
if (type == OSArgumentType::Quantity) {
value = toQuantityQVariant(map,"value","value_units");
}
else {
value = map["value"];
}
}
if (map.contains("default_value")) {
if (type == OSArgumentType::Quantity) {
defaultValue = toQuantityQVariant(map,"default_value","default_value_units");
}
else {
defaultValue = map["default_value"];
}
}
std::vector<QVariant> domain;
if (map.contains("domain")) {
if (type == OSArgumentType::Quantity) {
domain = deserializeOrderedVector(
map["domain"].toList(),
"domain_value_index",
std::function<QVariant (QVariant*)>(std::bind(
toQuantityQVariant,
std::bind(&QVariant::toMap,std::placeholders::_1),
"value",
"units")));
}
else {
domain = deserializeOrderedVector(
map["domain"].toList(),
"value",
"domain_value_index",
std::function<QVariant (const QVariant&)>(std::bind(boost::value_factory<QVariant>(),std::placeholders::_1)));
}
}
StringVector choices, choiceDisplayNames;
if (map.contains("choices")) {
QVariantList choicesList = map["choices"].toList();
choices = deserializeOrderedVector(
choicesList,
"value",
"choice_index",
std::function<std::string (QVariant*)>(std::bind(&QString::toStdString,
std::bind(&QVariant::toString,std::placeholders::_1))));
if (!choicesList.empty() && choicesList[0].toMap().contains("display_name")) {
try {
choiceDisplayNames = deserializeOrderedVector(
choicesList,
"display_name",
"choice_index",
std::function<std::string (QVariant*)>(std::bind(&QString::toStdString,
std::bind(&QVariant::toString,std::placeholders::_1))));
}
catch (...) {
LOG_FREE(Warn,"openstudio.ruleset.OSArgument","Unable to deserialize partial list of choice display names.");
}
}
}
return OSArgument(toUUID(map["uuid"].toString().toStdString()),
toUUID(map["version_uuid"].toString().toStdString()),
map["name"].toString().toStdString(),
map.contains("display_name") ? map["display_name"].toString().toStdString() : std::string(),
map.contains("description") ? map["description"].toString().toStdString() : boost::optional<std::string>(),
type,
map.contains("units") ? map["units"].toString().toStdString() : boost::optional<std::string>(),
map["required"].toBool(),
map["modelDependent"].toBool(),
value,
defaultValue,
OSDomainType(map["domain_type"].toString().toStdString()),
domain,
choices,
choiceDisplayNames,
map.contains("is_read") ? map["is_read"].toBool() : false,
map.contains("extension") ? map["extension"].toString().toStdString() : std::string());
}
UUID ComponentData_Impl::versionUUID() const {
OptionalString os = getString(OS_ComponentDataFields::VersionUUID);
OS_ASSERT(os);
return toUUID(*os);
}
Tag toTag(const QVariant& variant, const VersionString& version) {
QVariantMap map = variant.toMap();
return Tag(toUUID(map["uuid"].toString().toStdString()),
map["name"].toString().toStdString());
}
static void initialize()
{
createUUID();
toUUID(std::string("00000000-0000-0000-0000-000000000000"));
}
UUID toUUID(const QString &str)
{
return toUUID(toString(str));
}
