void WriterImplBase::RegisterPackageVersion(PackageAttributeList& attributeList, const BPackageVersion& version, BHPKGAttributeID attributeID) { PackageAttribute* versionMajor = AddStringAttribute(attributeID, version.Major(), attributeList); if (!version.Minor().IsEmpty()) { AddStringAttribute(B_HPKG_ATTRIBUTE_ID_PACKAGE_VERSION_MINOR, version.Minor(), versionMajor->children); _AddStringAttributeIfNotEmpty( B_HPKG_ATTRIBUTE_ID_PACKAGE_VERSION_MICRO, version.Micro(), versionMajor->children); } _AddStringAttributeIfNotEmpty( B_HPKG_ATTRIBUTE_ID_PACKAGE_VERSION_PRE_RELEASE, version.PreRelease(), versionMajor->children); if (version.Revision() != 0) { PackageAttribute* versionRevision = new PackageAttribute( B_HPKG_ATTRIBUTE_ID_PACKAGE_VERSION_REVISION, B_HPKG_ATTRIBUTE_TYPE_UINT, B_HPKG_ATTRIBUTE_ENCODING_INT_32_BIT); versionRevision->unsignedInt = version.Revision(); versionMajor->children.Add(versionRevision); } }
void WriterImplBase::_AddStringAttributeList(BHPKGAttributeID id, const BStringList& value, DoublyLinkedList<PackageAttribute>& list) { for (int32 i = 0; i < value.CountStrings(); i++) AddStringAttribute(id, value.StringAt(i), list); }
//----------------------------------------------------------------------------- // Reads a single element //----------------------------------------------------------------------------- bool CImportActBusy::UnserializeActBusyKey( CDmAttribute *pChildren, KeyValues *pKeyValues ) { CDmElement *pActBusy = CreateDmElement( "DmElement", pKeyValues->GetName(), NULL ); if ( !pActBusy ) return false; // Each act busy needs to have an editortype associated with it so it displays nicely in editors pActBusy->SetValue( "editorType", "actBusy" ); float flZero = 0.0f; AddStringAttribute( pActBusy, pKeyValues, "busy_anim", "" ); AddStringAttribute( pActBusy, pKeyValues, "entry_anim", "" ); AddStringAttribute( pActBusy, pKeyValues, "exit_anim", "" ); AddStringAttribute( pActBusy, pKeyValues, "busy_sequence", "" ); AddStringAttribute( pActBusy, pKeyValues, "entry_sequence", "" ); AddStringAttribute( pActBusy, pKeyValues, "exit_sequence", "" ); AddFloatAttribute( pActBusy, pKeyValues, "min_time", &flZero ); AddFloatAttribute( pActBusy, pKeyValues, "max_time", &flZero ); AddStringAttribute( pActBusy, pKeyValues, "interrupts", "BA_INT_NONE" ); CDmrElementArray<> children( pChildren ); children.AddToTail( pActBusy ); return true; }
bool CImportKeyValueBase::AddStringAttributeFlags( CDmElement* pElement, KeyValues *pKeyValue, const char *pKeyName, int nFlags, const char *pDefault ) { if ( !AddStringAttribute( pElement, pKeyValue, pKeyName, pDefault ) ) return false; CDmAttribute *pAttribute = pElement->GetAttribute( pKeyName ); pAttribute->AddFlag( nFlags ); return true; }
BOOL CBZWriteAttributes(char *retStr, PVOID pData) { PLUGINSHARE *pPluginData; char tmpText[33]; pPluginData = (PLUGINSHARE *) pData; if (pPluginData == NULL) return FALSE; AddEnabledAttribute(retStr, 5); AddStringAttribute(retStr, "ImageFile", pPluginData->szImageFile); return (TRUE); };
RendererStatistics::FormattedLong::FormattedLong(RendererStatistics* rs) : Formatted(rs, "renderer_statistics_formatted") { typedef RendererStatistics::FormattedLong FL; AddStringAttribute(*this, "percentHaltTimeComplete", "Percent of halt time completed", &FL::getPercentHaltTimeComplete); AddStringAttribute(*this, "percentHaltThresholdComplete", "Percent of halt threshold completed", &FL::getPercentHaltThresholdComplete); AddStringAttribute(*this, "percentConvergence", "Percent of convergence between last consecutive updates", &FL::getPercentConvergence); AddStringAttribute(*this, "percentComplete", "Percent of render completed", &FL::getPercentComplete); AddStringAttribute(*this, "efficiency", "Efficiency of renderer", &FL::getEfficiency); AddStringAttribute(*this, "efficiencyWindow", "Efficiency of renderer", &FL::getEfficiencyWindow); AddStringAttribute(*this, "threadCount", "Number of rendering threads on local node", &FL::getThreadCount); AddStringAttribute(*this, "slaveNodeCount", "Number of network slave nodes", &FL::getSlaveNodeCount); }
RendererStatistics::Formatted::Formatted(RendererStatistics* rs, const std::string& name) : Queryable(name), rs(rs) { AddStringAttribute(*this, "_recommended_string", "Recommended statistics string", &RendererStatistics::Formatted::getRecommendedString); AddStringAttribute(*this, "_recommended_string_template", "Recommended statistics string template", &RendererStatistics::Formatted::getRecommendedStringTemplate); AddStringAttribute(*this, "progress", "Progress", &RendererStatistics::Formatted::getProgress); AddStringAttribute(*this, "elapsedTime", "Elapsed rendering time", &RendererStatistics::Formatted::getElapsedTime); AddStringAttribute(*this, "remainingTime", "Remaining rendering time", &RendererStatistics::Formatted::getRemainingTime); AddStringAttribute(*this, "haltTime", "Halt rendering after time", &RendererStatistics::Formatted::getHaltTime); AddStringAttribute(*this, "haltThreshold", "Halt rendering when convergence drops below threshold", &RendererStatistics::Formatted::getHaltThreshold); }
RendererStatistics::FormattedShort::FormattedShort(RendererStatistics* rs) : Formatted(rs, "renderer_statistics_formatted_short") { FormattedLong* fl = static_cast<RendererStatistics::FormattedLong*>(rs->formattedLong); typedef RendererStatistics::FormattedLong FL; typedef RendererStatistics::FormattedShort FS; AddStringAttribute(*this, "percentHaltTimeComplete", "Percent of halt time completed", &FS::getPercentHaltTimeComplete); AddStringAttribute(*this, "percentHaltThresholdComplete", "Percent of halt threshold completed", &FS::getPercentHaltThresholdComplete); AddStringAttribute(*this, "percentConvergence", "Percent of convergence between last consecutive updates", &FS::getPercentConvergence); AddStringAttribute(*this, "percentComplete", "Percent of render completed", boost::bind(boost::mem_fn(&FL::getPercentComplete), fl)); AddStringAttribute(*this, "efficiency", "Efficiency of renderer", &FS::getEfficiency); AddStringAttribute(*this, "efficiencyWindow", "Efficiency of renderer", &FS::getEfficiencyWindow); AddStringAttribute(*this, "threadCount", "Number of rendering threads on local node", &FS::getThreadCount); AddStringAttribute(*this, "slaveNodeCount", "Number of network slave nodes", &FS::getSlaveNodeCount); }
BOOL CBZWriteAttributes(char *retStr, PVOID pData) { PLUGINSHARE *pPluginData; char tmpText[33]; pPluginData = (PLUGINSHARE *) pData; if (pPluginData == NULL) return FALSE; if (pPluginData->bActiveEnabled) { if (pPluginData->bInactiveEnabled) AddEnabledAttribute(retStr, 2); else AddEnabledAttribute(retStr, 0); } else if (pPluginData->bInactiveEnabled) AddEnabledAttribute(retStr, 1); else return FALSE; if (pPluginData->bActiveEnabled) { AddStringAttribute(retStr, "ActiveImageFile", pPluginData->szActiveFile); AddStringAttribute(retStr, "ActiveImageFileMask", pPluginData->szActiveFileMask); AddStringAttribute(retStr, "SelectedActiveImageFile", pPluginData->szSelectedActiveFile); AddStringAttribute(retStr, "SelectedActiveImageFileMask", pPluginData->szSelectedActiveFileMask); } if (pPluginData->bInactiveEnabled) { AddStringAttribute(retStr, "InactiveImageFile", pPluginData->szInactiveFile); AddStringAttribute(retStr, "InactiveImageFileMask", pPluginData->szInactiveFileMask); AddStringAttribute(retStr, "SelectedInactiveImageFile", pPluginData->szSelectedInactiveFile); AddStringAttribute(retStr, "SelectedInactiveImageFileMask", pPluginData->szSelectedInactiveFileMask); } return (TRUE); };
void WriterImplBase::RegisterPackageResolvableExpressionList( PackageAttributeList& attributeList, const BObjectList<BPackageResolvableExpression>& expressionList, uint8 id) { for (int i = 0; i < expressionList.CountItems(); ++i) { BPackageResolvableExpression* resolvableExpr = expressionList.ItemAt(i); PackageAttribute* name = AddStringAttribute((BHPKGAttributeID)id, resolvableExpr->Name(), attributeList); if (resolvableExpr->Version().InitCheck() == B_OK) { PackageAttribute* op = new PackageAttribute( B_HPKG_ATTRIBUTE_ID_PACKAGE_RESOLVABLE_OPERATOR, B_HPKG_ATTRIBUTE_TYPE_UINT, B_HPKG_ATTRIBUTE_ENCODING_INT_8_BIT); op->unsignedInt = resolvableExpr->Operator(); name->children.Add(op); RegisterPackageVersion(name->children, resolvableExpr->Version()); } } }
void WriterImplBase::RegisterPackageInfo(PackageAttributeList& attributeList, const BPackageInfo& packageInfo) { // name AddStringAttribute(B_HPKG_ATTRIBUTE_ID_PACKAGE_NAME, packageInfo.Name(), attributeList); // summary AddStringAttribute(B_HPKG_ATTRIBUTE_ID_PACKAGE_SUMMARY, packageInfo.Summary(), attributeList); // description AddStringAttribute(B_HPKG_ATTRIBUTE_ID_PACKAGE_DESCRIPTION, packageInfo.Description(), attributeList); // vendor AddStringAttribute(B_HPKG_ATTRIBUTE_ID_PACKAGE_VENDOR, packageInfo.Vendor(), attributeList); // packager AddStringAttribute(B_HPKG_ATTRIBUTE_ID_PACKAGE_PACKAGER, packageInfo.Packager(), attributeList); // base package (optional) _AddStringAttributeIfNotEmpty(B_HPKG_ATTRIBUTE_ID_PACKAGE_BASE_PACKAGE, packageInfo.BasePackage(), attributeList); // flags PackageAttribute* flags = new PackageAttribute( B_HPKG_ATTRIBUTE_ID_PACKAGE_FLAGS, B_HPKG_ATTRIBUTE_TYPE_UINT, B_HPKG_ATTRIBUTE_ENCODING_INT_32_BIT); flags->unsignedInt = packageInfo.Flags(); attributeList.Add(flags); // architecture PackageAttribute* architecture = new PackageAttribute( B_HPKG_ATTRIBUTE_ID_PACKAGE_ARCHITECTURE, B_HPKG_ATTRIBUTE_TYPE_UINT, B_HPKG_ATTRIBUTE_ENCODING_INT_8_BIT); architecture->unsignedInt = packageInfo.Architecture(); attributeList.Add(architecture); // version RegisterPackageVersion(attributeList, packageInfo.Version()); // copyright list _AddStringAttributeList(B_HPKG_ATTRIBUTE_ID_PACKAGE_COPYRIGHT, packageInfo.CopyrightList(), attributeList); // license list _AddStringAttributeList(B_HPKG_ATTRIBUTE_ID_PACKAGE_LICENSE, packageInfo.LicenseList(), attributeList); // URL list _AddStringAttributeList(B_HPKG_ATTRIBUTE_ID_PACKAGE_URL, packageInfo.URLList(), attributeList); // source URL list _AddStringAttributeList(B_HPKG_ATTRIBUTE_ID_PACKAGE_SOURCE_URL, packageInfo.SourceURLList(), attributeList); // provides list const BObjectList<BPackageResolvable>& providesList = packageInfo.ProvidesList(); for (int i = 0; i < providesList.CountItems(); ++i) { BPackageResolvable* resolvable = providesList.ItemAt(i); bool hasVersion = resolvable->Version().InitCheck() == B_OK; bool hasCompatibleVersion = resolvable->CompatibleVersion().InitCheck() == B_OK; PackageAttribute* provides = AddStringAttribute( B_HPKG_ATTRIBUTE_ID_PACKAGE_PROVIDES, resolvable->Name(), attributeList); if (hasVersion) RegisterPackageVersion(provides->children, resolvable->Version()); if (hasCompatibleVersion) { RegisterPackageVersion(provides->children, resolvable->CompatibleVersion(), B_HPKG_ATTRIBUTE_ID_PACKAGE_PROVIDES_COMPATIBLE); } } // requires list RegisterPackageResolvableExpressionList(attributeList, packageInfo.RequiresList(), B_HPKG_ATTRIBUTE_ID_PACKAGE_REQUIRES); // supplements list RegisterPackageResolvableExpressionList(attributeList, packageInfo.SupplementsList(), B_HPKG_ATTRIBUTE_ID_PACKAGE_SUPPLEMENTS); // conflicts list RegisterPackageResolvableExpressionList(attributeList, packageInfo.ConflictsList(), B_HPKG_ATTRIBUTE_ID_PACKAGE_CONFLICTS); // freshens list RegisterPackageResolvableExpressionList(attributeList, packageInfo.FreshensList(), B_HPKG_ATTRIBUTE_ID_PACKAGE_FRESHENS); // replaces list _AddStringAttributeList(B_HPKG_ATTRIBUTE_ID_PACKAGE_REPLACES, packageInfo.ReplacesList(), attributeList); // global writable file info list const BObjectList<BGlobalWritableFileInfo>& globalWritableFileInfos = packageInfo.GlobalWritableFileInfos(); for (int32 i = 0; i < globalWritableFileInfos.CountItems(); ++i) { BGlobalWritableFileInfo* info = globalWritableFileInfos.ItemAt(i); PackageAttribute* attribute = AddStringAttribute( B_HPKG_ATTRIBUTE_ID_PACKAGE_GLOBAL_WRITABLE_FILE, info->Path(), attributeList); if (info->IsDirectory()) { PackageAttribute* isDirectoryAttribute = new PackageAttribute( B_HPKG_ATTRIBUTE_ID_PACKAGE_IS_WRITABLE_DIRECTORY, B_HPKG_ATTRIBUTE_TYPE_UINT, B_HPKG_ATTRIBUTE_ENCODING_INT_8_BIT); isDirectoryAttribute->unsignedInt = 1; attribute->children.Add(isDirectoryAttribute); } if (info->IsIncluded()) { PackageAttribute* updateTypeAttribute = new PackageAttribute( B_HPKG_ATTRIBUTE_ID_PACKAGE_WRITABLE_FILE_UPDATE_TYPE, B_HPKG_ATTRIBUTE_TYPE_UINT, B_HPKG_ATTRIBUTE_ENCODING_INT_8_BIT); updateTypeAttribute->unsignedInt = info->UpdateType(); attribute->children.Add(updateTypeAttribute); } } // user settings file info list const BObjectList<BUserSettingsFileInfo>& userSettingsFileInfos = packageInfo.UserSettingsFileInfos(); for (int32 i = 0; i < userSettingsFileInfos.CountItems(); ++i) { BUserSettingsFileInfo* info = userSettingsFileInfos.ItemAt(i); PackageAttribute* attribute = AddStringAttribute( B_HPKG_ATTRIBUTE_ID_PACKAGE_USER_SETTINGS_FILE, info->Path(), attributeList); if (info->IsDirectory()) { PackageAttribute* isDirectoryAttribute = new PackageAttribute( B_HPKG_ATTRIBUTE_ID_PACKAGE_IS_WRITABLE_DIRECTORY, B_HPKG_ATTRIBUTE_TYPE_UINT, B_HPKG_ATTRIBUTE_ENCODING_INT_8_BIT); isDirectoryAttribute->unsignedInt = 1; attribute->children.Add(isDirectoryAttribute); } else { _AddStringAttributeIfNotEmpty( B_HPKG_ATTRIBUTE_ID_PACKAGE_SETTINGS_FILE_TEMPLATE, info->TemplatePath(), attribute->children); } } // user list const BObjectList<BUser>& users = packageInfo.Users(); for (int32 i = 0; i < users.CountItems(); ++i) { const BUser* user = users.ItemAt(i); PackageAttribute* attribute = AddStringAttribute( B_HPKG_ATTRIBUTE_ID_PACKAGE_USER, user->Name(), attributeList); _AddStringAttributeIfNotEmpty( B_HPKG_ATTRIBUTE_ID_PACKAGE_USER_REAL_NAME, user->RealName(), attribute->children); _AddStringAttributeIfNotEmpty( B_HPKG_ATTRIBUTE_ID_PACKAGE_USER_HOME, user->Home(), attribute->children); _AddStringAttributeIfNotEmpty( B_HPKG_ATTRIBUTE_ID_PACKAGE_USER_SHELL, user->Shell(), attribute->children); for (int32 k = 0; k < user->Groups().CountStrings(); k++) { AddStringAttribute(B_HPKG_ATTRIBUTE_ID_PACKAGE_USER_GROUP, user->Groups().StringAt(k), attribute->children); } } // group list _AddStringAttributeList(B_HPKG_ATTRIBUTE_ID_PACKAGE_GROUP, packageInfo.Groups(), attributeList); // post install script list _AddStringAttributeList(B_HPKG_ATTRIBUTE_ID_PACKAGE_POST_INSTALL_SCRIPT, packageInfo.PostInstallScripts(), attributeList); // checksum (optional, only exists in repositories) _AddStringAttributeIfNotEmpty(B_HPKG_ATTRIBUTE_ID_PACKAGE_CHECKSUM, packageInfo.Checksum(), attributeList); // install path (optional) _AddStringAttributeIfNotEmpty(B_HPKG_ATTRIBUTE_ID_PACKAGE_INSTALL_PATH, packageInfo.InstallPath(), attributeList); }
HRESULT CStunMessageBuilder::AddRealm(const char* pszRealm) { return AddStringAttribute(STUN_ATTRIBUTE_REALM, pszRealm); }
HRESULT CStunMessageBuilder::AddNonce(const char* pszNonce) { return AddStringAttribute(STUN_ATTRIBUTE_NONCE, pszNonce); }
HRESULT CStunMessageBuilder::AddUserName(const char* pszUserName) { return AddStringAttribute(STUN_ATTRIBUTE_USERNAME, pszUserName); }