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);
}
