TTAudioObjectBase::TTAudioObjectBase(const TTValue& arguments) : TTObjectBase(arguments), mMaxNumChannels(0), attrMute(0), inputArray(kTTSym_audiosignalarray,2), outputArray(kTTSym_audiosignalarray,2), startProcessingTime(0.0), accumulatedProcessingTime(0.0), accumulatedProcessingCalls(0.0) { // Convention: 'Public' attribute names begin with a capital letter, 'Private' attribute names begin with a lower case letter // registerAttribute("maxNumChannels", kTypeUInt8, &maxNumChannels, (TTSetterMethod)&TTAudioObjectBase::setMaxNumChannels); addAttributeWithSetter(MaxNumChannels, kTypeUInt16); addAttributeProperty(MaxNumChannels, defaultValue, 1); registerAttribute(kTTSym_sampleRate, kTypeUInt32, &sr, (TTSetterMethod)&TTAudioObjectBase::setSr); registerAttribute("bypass", kTypeBoolean, &attrBypass, (TTSetterMethod)&TTAudioObjectBase::setBypass); registerAttribute("mute", kTypeBoolean, &attrMute, (TTSetterMethod)&TTAudioObjectBase::setMute); registerMessage("test", (TTMethod)&TTAudioObjectBase::test); registerMessage("calculate", (TTMethod)&TTAudioObjectBase::calculateMessage); registerMessage("resetBenchmarking", (TTMethod)&TTAudioObjectBase::resetBenchmarking, kTTMessagePassNone); registerMessage("getProcessingBenchmark", (TTMethod)&TTAudioObjectBase::getProcessingBenchmark); // Set Defaults... setAttributeValue(kTTSym_sampleRate, ttEnvironment->mSampleRate); setProcess(&TTAudioObjectBase::bypassProcess); setCalculate(&TTAudioObjectBase::defaultCalculateMethod); setAttributeValue("bypass", NO); }
DeviceAPI::DeviceAPI(const DeviceDescriptor &device_) : device(device_) { registerAttribute("id", device.serial_number(), true); registerAttribute("vendorId", utils::hex_encode(device.vendor_id()), true); registerAttribute("productId", utils::hex_encode(device.product_id()), true); registerAttribute("path", device.path(), true); }
void ShaderVariableManager::loadStandards() { registerUniform(UniformDescription::MVP_MATRIX); registerUniform(UniformDescription::MV_MATRIX); registerUniform(UniformDescription::COLOR); registerUniform(UniformDescription::COLOR_TEXTURE); registerAttribute(AttributeDescription::POSITION); registerAttribute(AttributeDescription::COLOR); registerAttribute(AttributeDescription::NORMAL); }
StatusXMLDocumentHandler::StatusXMLDocumentHandler(StreamerParser *parser) : XMLStreamDocumentHandler(parser) { /** * Register Mandatory attributes */ registerAttribute("Led", "id"); registerAttribute("Led", "color"); registerAttribute("Led", "blink"); registerAttribute("StatusText", "name_text_id"); status.setStatusText(statusData); }
Bone::Bone() : BodyPart(BodyPartType::BONE, std::make_shared<BoneInitializationData>()) , length_(0) , width_(0) { auto initData = std::dynamic_pointer_cast<BoneInitializationData>(getInitializationData()); registerAttribute(GENE_ATTRIB_ASPECT_RATIO, initData->aspectRatio); registerAttribute(GENE_ATTRIB_DENSITY, initData->density); physBody_.userObjectType_ = ObjectTypes::BPART_BONE; physBody_.userPointer_ = this; }
UdpService::UdpService(const char *name) : IService(name) { registerInterface(static_cast<IUdp *>(this)); registerAttribute("Timeout", &timeout_); registerAttribute("BlockingMode", &blockmode_); registerAttribute("HostIP", &hostIP_); registerAttribute("BoardIP", &boardIP_); timeout_.make_int64(0); blockmode_.make_boolean(true); hostIP_.make_string("192.168.0.53"); boardIP_.make_string("192.168.0.51"); }
SocInfo::SocInfo(const char *name) : IService(name) { registerInterface(static_cast<ISocInfo *>(this)); registerAttribute("PnpBaseAddress", &pnpBase_); registerAttribute("DsuBaseAddress", &dsuBase_); registerAttribute("GpioBaseAddress", &gpioBase_); registerAttribute("ListCSR", &listCSR_); registerAttribute("ListRegs", &listRegs_); dsuBase_.make_uint64(0); listCSR_.make_list(0); listRegs_.make_list(0); }
Function::Function(Doc* doc, Type t) : QObject(doc) , m_id(Function::invalidId()) , m_type(t) , m_path(QString()) , m_visible(true) , m_runOrder(Loop) , m_direction(Forward) , m_tempoType(Time) , m_overrideTempoType(Original) , m_beatResyncNeeded(false) , m_fadeInSpeed(0) , m_fadeOutSpeed(0) , m_duration(0) , m_overrideFadeInSpeed(defaultSpeed()) , m_overrideFadeOutSpeed(defaultSpeed()) , m_overrideDuration(defaultSpeed()) , m_flashing(false) , m_elapsed(0) , m_elapsedBeats(0) , m_stop(true) , m_running(false) , m_paused(false) , m_lastOverrideAttributeId(OVERRIDE_ATTRIBUTE_START_ID) , m_preserveAttributes(false) , m_blendMode(Universe::NormalBlend) { Q_ASSERT(doc != NULL); registerAttribute(tr("Intensity"), Multiply | Single); }
void OSRunner::registerValue(const std::string& name, const std::string& displayName, const std::string& value) { Attribute attribute(name,value); attribute.setDisplayName(displayName); registerAttribute(attribute); }
UART::UART(const char *name) : IService(name) { registerInterface(static_cast<IMemoryOperation *>(this)); registerInterface(static_cast<ISerial *>(this)); registerAttribute("BaseAddress", &baseAddress_); registerAttribute("Length", &length_); registerAttribute("IrqLine", &irqLine_); registerAttribute("IrqControl", &irqctrl_); baseAddress_.make_uint64(0); length_.make_uint64(0); irqLine_.make_uint64(0); irqctrl_.make_string(""); listeners_.make_list(0); memset(®s_, 0, sizeof(regs_)); regs_.status = UART_STATUS_TX_EMPTY | UART_STATUS_RX_EMPTY; p_rx_wr_ = rxfifo_; p_rx_rd_ = rxfifo_; rx_total_ = 0; }
EFX::EFX(Doc* doc) : Function(doc, Function::EFXType) { m_isRelative = false; updateRotationCache(); m_xFrequency = 2; m_yFrequency = 3; m_xPhase = M_PI / 2.0; m_yPhase = 0; m_propagationMode = Parallel; m_algorithm = EFX::Circle; setName(tr("New EFX")); m_fader = NULL; setDuration(20000); // 20s m_legacyHoldBus = Bus::invalid(); m_legacyFadeBus = Bus::invalid(); registerAttribute(tr("Width"), Function::LastWins, 0.0, 127.0, 127.0); registerAttribute(tr("Height"), Function::LastWins, 0.0, 127.0, 127.0); registerAttribute(tr("Rotation"), Function::LastWins, 0.0, 359.0, 0.0); registerAttribute(tr("X Offset"), Function::LastWins, 0.0, 255.0, 127.0); registerAttribute(tr("Y Offset"), Function::LastWins, 0.0, 255.0, 127.0); registerAttribute(tr("Start Offset"), Function::LastWins, 0.0, 359.0, 0.0); }
AttributeRegistry::AttributeRegistry() : _guideAttribute(registerAttribute(new SharedObjectAttribute("guide", &MetavoxelGuide::staticMetaObject, new DefaultMetavoxelGuide()))), _rendererAttribute(registerAttribute(new SharedObjectAttribute("renderer", &MetavoxelRenderer::staticMetaObject, new DefaultMetavoxelRenderer()))), _spannersAttribute(registerAttribute(new SpannerSetAttribute("spanners", &Spanner::staticMetaObject))), _colorAttribute(registerAttribute(new QRgbAttribute("color"))), _normalAttribute(registerAttribute(new PackedNormalAttribute("normal"))), _spannerColorAttribute(registerAttribute(new SpannerQRgbAttribute("spannerColor"))), _spannerNormalAttribute(registerAttribute(new SpannerPackedNormalAttribute("spannerNormal"))), _spannerMaskAttribute(registerAttribute(new FloatAttribute("spannerMask"))), _heightfieldAttribute(registerAttribute(new HeightfieldAttribute("heightfield"))), _heightfieldColorAttribute(registerAttribute(new HeightfieldColorAttribute("heightfieldColor"))) { // our baseline LOD threshold is for voxels; spanners and heightfields are a different story const float SPANNER_LOD_THRESHOLD_MULTIPLIER = 8.0f; _spannersAttribute->setLODThresholdMultiplier(SPANNER_LOD_THRESHOLD_MULTIPLIER); const float HEIGHTFIELD_LOD_THRESHOLD_MULTIPLIER = 32.0f; _heightfieldAttribute->setLODThresholdMultiplier(HEIGHTFIELD_LOD_THRESHOLD_MULTIPLIER); _heightfieldColorAttribute->setLODThresholdMultiplier(HEIGHTFIELD_LOD_THRESHOLD_MULTIPLIER); }
PluginAPI::PluginAPI(const BitcoinTrezorPluginPtr &plugin, const FB::BrowserHostPtr &host) : _plugin(plugin), _host(host) { registerAttribute("version", FBSTRING_PLUGIN_VERSION, true); registerMethod("call", make_method(this, &PluginAPI::call)); registerMethod("close", make_method(this, &PluginAPI::close)); registerMethod("devices", make_method(this, &PluginAPI::devices)); registerMethod("configure", make_method(this, &PluginAPI::configure)); registerMethod("deriveChildNode", make_method(this, &PluginAPI::derive_child_node)); }
TTProtocol::TTProtocol(const TTValue& arguments) : TTObjectBase(arguments), mRunning(NO), mSelectedApplication(kTTSymEmpty) { mApplicationManager = arguments[0]; mMonitorInCallback = arguments[1]; mMonitorOutCallback = arguments[2]; registerAttribute(TTSymbol("applicationNames"), kTypeLocalValue, NULL, (TTGetterMethod)& TTProtocol::getApplicationNames); addAttribute(Name, kTypeSymbol); addAttributeProperty(Name, readOnly, YES); addAttribute(Version, kTypeSymbol); addAttributeProperty(Version, readOnly, YES); addAttribute(Author, kTypeSymbol); addAttributeProperty(Author, readOnly, YES); addAttribute(Get, kTypeBoolean); addAttributeProperty(Get, readOnly, YES); addAttribute(Set, kTypeBoolean); addAttributeProperty(Set, readOnly, YES); addAttribute(Listen, kTypeBoolean); addAttributeProperty(Listen, readOnly, YES); addAttribute(Discover, kTypeBoolean); addAttributeProperty(Discover, readOnly, YES); addAttribute(DiscoverAll, kTypeBoolean); addAttributeProperty(DiscoverAll, readOnly, YES); addAttribute(Monitor, kTypeBoolean); addMessageWithArguments(ApplicationRegister); addMessageWithArguments(ApplicationRename); addMessageWithArguments(ApplicationUnregister); addMessageWithArguments(ApplicationSelect); addMessage(ApplicationSelectLocal); addMessageWithArguments(isRegistered); addMessageWithArguments(Scan); addMessageWithArguments(Run); addMessageWithArguments(Stop); }
// Constructor TTOverdriveExtended::TTOverdriveExtended(TTValue& arguments) : TTOverdrive(arguments) { registerAttribute(TT("overdrive"), kTypeFloat64, &mDrive, (TTSetterMethod)&TTOverdrive::setDrive); registerAttribute(TT("/saturation"), kTypeFloat64, &mDrive, (TTSetterMethod)&TTOverdrive::setDrive); registerAttribute(TT("/depth"), kTypeFloat64, &mDrive, (TTSetterMethod)&TTOverdrive::setDrive); registerAttribute(TT("bypass_dcblocker"), kTypeBoolean, &mDcBlocker, (TTSetterMethod)&TTOverdrive::setDcBlocker); registerAttribute(TT("/dcblocker/bypass"), kTypeBoolean, &mDcBlocker, (TTSetterMethod)&TTOverdrive::setDcBlocker); registerAttribute(TT("/preamp"), kTypeFloat64, &mPreamp, (TTGetterMethod)&TTOverdrive::getPreamp, (TTSetterMethod)&TTOverdrive::setPreamp); registerAttribute(TT("/mode"), kTypeUInt8, &mMode, (TTSetterMethod)&TTOverdrive::setMode); registerAttribute(TT("/audio/mute"), kTypeBoolean, &attrMute, (TTSetterMethod)&TTAudioObject::setMute); registerMessageSimple(anything); }
Function::Function(Doc* doc, Type t) : QObject(doc) , m_id(Function::invalidId()) , m_type(t) , m_path(QString()) , m_runOrder(Loop) , m_direction(Forward) , m_fadeInSpeed(0) , m_fadeOutSpeed(0) , m_duration(0) , m_overrideFadeInSpeed(defaultSpeed()) , m_overrideFadeOutSpeed(defaultSpeed()) , m_overrideDuration(defaultSpeed()) , m_flashing(false) , m_elapsed(0) , m_stop(true) , m_running(false) , m_startedAsChild(false) { Q_ASSERT(doc != NULL); registerAttribute(tr("Intensity")); }
EFX::EFX(Doc* doc) : Function(doc, Function::EFXType) , m_algorithm(EFX::Circle) , m_isRelative(false) , m_xFrequency(2) , m_yFrequency(3) , m_xPhase(M_PI / 2.0) , m_yPhase(0) , m_propagationMode(Parallel) , m_legacyFadeBus(Bus::invalid()) , m_legacyHoldBus(Bus::invalid()) { updateRotationCache(); setName(tr("New EFX")); setDuration(20000); // 20s registerAttribute(tr("Width"), Function::LastWins, 0.0, 127.0, 127.0); registerAttribute(tr("Height"), Function::LastWins, 0.0, 127.0, 127.0); registerAttribute(tr("Rotation"), Function::LastWins, 0.0, 359.0, 0.0); registerAttribute(tr("X Offset"), Function::LastWins, 0.0, 255.0, 127.0); registerAttribute(tr("Y Offset"), Function::LastWins, 0.0, 255.0, 127.0); registerAttribute(tr("Start Offset"), Function::LastWins, 0.0, 359.0, 0.0); }
TTData::TTData(const TTValue& arguments) : TTCallback(arguments), mValue(TTValue(0.0)), mValueDefault(TTValue(0.0)), mValueStepsize(TTValue(0.1)), // this default value is expected in #TTData::setType method mType(kTTSym_generic), mTags(TTValue(kTTSym_none)), mPriority(0), mDescription(kTTSym_none), mRepetitionsFilter(NO), mActive(YES), mInitialized(NO), mRangeBounds(0.0, 1.0), // this default value is expected in #TTData::setType method mRangeClipmode(kTTSym_none), mDynamicInstances(NO), mInstanceBounds(0, -1), mRampDrive(kTTSym_none), mRampDriveDefault(TTSymbol("system")), #ifndef TT_NO_DSP mRampFunction(kTTSym_none), // this default value is expected in #TTData::setType method #endif mRampStatus(NO), mDataspace(kTTSym_none), mDataspaceUnit(kTTSym_none), mService(kTTSymEmpty) { if (arguments.size() == 1) mService = arguments[0]; registerAttribute(kTTSym_value, kTypeNone, NULL, (TTGetterMethod)&TTData::getValue, (TTSetterMethod)&TTData::setGenericValue); addAttributeWithGetterAndSetter(ValueDefault, kTypeNone); addAttributeWithGetterAndSetter(ValueStepsize, kTypeNone); addAttributeWithSetter(Type, kTypeSymbol); addAttributeWithSetter(Tags, kTypeLocalValue); addAttributeWithSetter(Priority, kTypeInt32); addAttributeWithSetter(Description, kTypeSymbol); addAttributeWithSetter(RepetitionsFilter, kTypeBoolean); addAttributeWithSetter(Active, kTypeBoolean); addAttribute(Initialized, kTypeBoolean); addAttributeProperty(Initialized, readOnly, YES); addAttributeProperty(Initialized, hidden, YES); addAttributeWithSetter(RangeBounds, kTypeLocalValue); addAttributeWithSetter(RangeClipmode, kTypeSymbol); // this is a temporary solution for Blue Yéti addAttribute(DynamicInstances, kTypeBoolean); addAttributeProperty(DynamicInstances, hidden, YES); addAttributeWithSetter(InstanceBounds, kTypeLocalValue); addAttributeProperty(InstanceBounds, hidden, YES); addAttributeWithSetter(RampDrive, kTypeSymbol); addAttribute(RampDriveDefault, kTypeSymbol); addAttributeProperty(RampDriveDefault, hidden, YES); #ifndef TT_NO_DSP addAttributeWithSetter(RampFunction, kTypeSymbol); #endif addAttribute(RampFunctionParameters, kTypeLocalValue); addAttributeProperty(RampFunctionParameters, readOnly, YES); addAttribute(RampStatus, kTypeBoolean); addAttributeProperty(RampStatus, readOnly, YES); addAttributeProperty(RampStatus, hidden, YES); // hidden for Max addAttributeWithSetter(Dataspace, kTypeSymbol); addAttributeWithSetter(DataspaceUnit, kTypeSymbol); addAttribute(Service, kTypeSymbol); //addAttributeProperty(Service, hidden, YES); // we don't hide this attribute to mirror it (even if we want to hide it for Max) registerMessage(kTTSym_Init, (TTMethod)&TTData::GenericInit, kTTMessagePassNone); addMessageWithArguments(Inc); addMessageWithArguments(Dec); addMessageWithArguments(Command); addMessageProperty(Command, hidden, YES); addMessageWithArguments(RampSet); addMessageProperty(RampSet, hidden, YES); addMessageWithArguments(RampTarget); addMessageProperty(RampTarget, hidden, YES); addMessageWithArguments(RampGo); addMessageProperty(RampGo, hidden, YES); addMessageWithArguments(RampSlide); addMessageProperty(RampSlide, hidden, YES); // needed to be handled by a TTTextHandler addMessageWithArguments(WriteAsText); addMessageProperty(WriteAsText, hidden, YES); mIsSending = NO; mIsOverridingDataspaceUnit = NO; commandMethod = (TTMethodValue)&TTData::GenericCommand; // cache some message and attribute for observer notification this->findAttribute(kTTSym_value, &valueAttribute); this->findAttribute(kTTSym_initialized, &initializedAttribute); // set no time for external ramp drive externalRampTime = 0; }
TTDataObject::TTDataObject(TTValue& arguments) : TTObject(arguments) { registerAttribute(kTTSym_SampleRate, kTypeUInt32, &sr, (TTSetterMethod)&TTDataObject::setSr); setAttributeValue(kTTSym_SampleRate, ttEnvironment->mSampleRate); }
AttributeRegistry::AttributeRegistry() : _guideAttribute(registerAttribute(new PolymorphicAttribute("guide", PolymorphicDataPointer(new DefaultMetavoxelGuide())))), _colorAttribute(registerAttribute(new QRgbAttribute("color"))), _normalAttribute(registerAttribute(new QRgbAttribute("normal", qRgb(0, 127, 0)))) { }
bool OSRunner::validateUserArguments(const std::vector<OSArgument>& script_arguments, const std::map<std::string, OSArgument>& user_arguments) { bool result(true); std::stringstream ss; AttributeVector argumentValueAttributes; for (const OSArgument& script_argument : script_arguments) { auto it = user_arguments.find(script_argument.name()); if (it == user_arguments.end()) { // script_argument is not in user_arguments // this is only okay for purely optional arguments if (script_argument.required() || script_argument.hasDefaultValue()) { ss << "Argument " << script_argument.name() << " is required or has a default value, "; ss << "but is not in user_arguments."; registerError(ss.str()); ss.str(""); result = false; } } else { // script_argument is in user_arguments OSArgument user_argument = it->second; // check that names still match if (user_argument.name() != script_argument.name()) { ss << "User argument name '" << user_argument.name() << "' does not match map key "; ss << script_argument.name() << "."; registerWarning(ss.str()); ss.str(""); } // check that types still match if (user_argument.type() != script_argument.type()) { ss << "User argument type " << user_argument.type().valueName() << " does not match "; ss << "script argument type " << script_argument.type().valueName() << "."; registerError(ss.str()); ss.str(""); result = false; } // check that we have values if ((script_argument.required()) && !(user_argument.hasValue() || user_argument.hasDefaultValue())) { ss << "Script argument '" << script_argument.name() << "' is required, "; ss << "but the user argument does not have a value or default value set."; registerError(ss.str()); ss.str(""); result = false; } // check for default value mismatch if (script_argument.hasDefaultValue() && !user_argument.hasDefaultValue()) { ss << "Script argument '" << script_argument.name() << "' has a default value, but the "; ss << "user-supplied version does not."; registerWarning(ss.str()); ss.str(""); } if (!script_argument.hasDefaultValue() && user_argument.hasDefaultValue()) { ss << "Script argument '" << script_argument.name() << "' does not have a default value, "; ss << "but the user-supplied version does."; registerWarning(ss.str()); ss.str(""); } if (script_argument.hasDefaultValue() && user_argument.hasDefaultValue() && (user_argument.type() == script_argument.type())) { ss << "The default value of script argument " << std::endl << script_argument << std::endl; ss << "does not match that of the corresponding user argument " << std::endl << user_argument << "."; switch (script_argument.type().value()) { case OSArgumentType::Boolean : if (user_argument.defaultValueAsBool() != script_argument.defaultValueAsBool()) { registerWarning(ss.str()); } break; case OSArgumentType::Double : if (user_argument.defaultValueAsDouble() != script_argument.defaultValueAsDouble()) { registerWarning(ss.str()); } break; case OSArgumentType::Quantity : if (user_argument.defaultValueAsQuantity() != script_argument.defaultValueAsQuantity()) { registerWarning(ss.str()); } break; case OSArgumentType::Integer : if (user_argument.defaultValueAsInteger() != script_argument.defaultValueAsInteger()) { registerWarning(ss.str()); } break; case OSArgumentType::String : case OSArgumentType::Choice : case OSArgumentType::Path : if (user_argument.defaultValueAsString() != script_argument.defaultValueAsString()) { registerWarning(ss.str()); } break; default : OS_ASSERT(false); } ss.str(""); } // check for domain mismatch if (script_argument.hasDomain() && !user_argument.hasDomain()) { ss << "Script argument '" << script_argument.name() << "' has a specified domain, but the "; ss << "user-supplied version does not."; registerWarning(ss.str()); ss.str(""); } if (!script_argument.hasDomain() && user_argument.hasDomain()) { ss << "Script argument '" << script_argument.name() << "' does not have a specified domain, "; ss << "but the user-supplied version does."; registerWarning(ss.str()); ss.str(""); } if (script_argument.hasDomain() && user_argument.hasDomain() && (user_argument.type() == script_argument.type())) { ss << "The domain of script argument " << std::endl << script_argument << std::endl; ss << "does not match that of the corresponding user argument " << std::endl << user_argument << "."; switch (script_argument.type().value()) { case OSArgumentType::Boolean: // DLM: should bool's even have domains? if (user_argument.domainAsBool() != script_argument.domainAsBool()) { registerWarning(ss.str()); } break; case OSArgumentType::Double: if (user_argument.domainAsDouble() != script_argument.domainAsDouble()) { registerWarning(ss.str()); } break; case OSArgumentType::Quantity: // DLM: deprecated forget about getting this to compile //if (user_argument.domainAsQuantity() != script_argument.domainAsQuantity()) { // registerWarning(ss.str()); //} break; case OSArgumentType::Integer: if (user_argument.domainAsInteger() != script_argument.domainAsInteger()) { registerWarning(ss.str()); } break; case OSArgumentType::String: case OSArgumentType::Choice: case OSArgumentType::Path: if (user_argument.domainAsString() != script_argument.domainAsString()) { registerWarning(ss.str()); } break; default: OS_ASSERT(false); } ss.str(""); } // success, set the values if (result) { Quantity q; switch(user_argument.type().value()) { case OSArgumentType::Boolean : if (user_argument.hasValue()) { argumentValueAttributes.push_back(Attribute(user_argument.name(),user_argument.valueAsBool())); } else if (user_argument.hasDefaultValue()) { argumentValueAttributes.push_back(Attribute(user_argument.name(),user_argument.defaultValueAsBool())); } break; case OSArgumentType::Double : if (user_argument.hasValue()) { argumentValueAttributes.push_back(Attribute(user_argument.name(),user_argument.valueAsDouble())); } else if (user_argument.hasDefaultValue()) { argumentValueAttributes.push_back(Attribute(user_argument.name(),user_argument.defaultValueAsDouble())); } break; case OSArgumentType::Quantity : if (user_argument.hasValue()) { q = user_argument.valueAsQuantity(); } else if (user_argument.hasDefaultValue()) { q = user_argument.defaultValueAsQuantity(); } argumentValueAttributes.push_back(Attribute(user_argument.name(),q.value(),q.units().print())); break; case OSArgumentType::Integer : if (user_argument.hasValue()) { argumentValueAttributes.push_back(Attribute(user_argument.name(),user_argument.valueAsInteger())); } else if (user_argument.hasDefaultValue()) { argumentValueAttributes.push_back(Attribute(user_argument.name(),user_argument.defaultValueAsInteger())); } break; case OSArgumentType::String : case OSArgumentType::Choice : case OSArgumentType::Path : if (user_argument.hasValue()) { argumentValueAttributes.push_back(Attribute(user_argument.name(),user_argument.valueAsString())); } else if (user_argument.hasDefaultValue()) { argumentValueAttributes.push_back(Attribute(user_argument.name(),user_argument.defaultValueAsString())); } break; default: OS_ASSERT(false); } } } } if (result) { for (Attribute& attribute : argumentValueAttributes) { registerAttribute(attribute); } } return result; }
void OSRunner::registerValue(const std::string& name, int value, const std::string& units) { Attribute attribute(name,value,units); registerAttribute(attribute); }
void OSRunner::registerValue(const std::string& name, const std::string& value) { Attribute attribute(name,value); registerAttribute(attribute); }