Contains interfaces and implementations of flexible parameter concept. More...

Classes
class	CComposedParamsSetComp
	Implementation of interface IParamsSet as component. More...

class	CDelegatedEnableableParamComp

class	CEnableableParam
	Basic implementation of IEnableableParam interface. More...

class	CEnableableParamComp

class	CFilteredOptionsListComp
	Implementation of an option list filter. More...

class	CIdParam
	Implementation of a named object over iprm::INameParam interface. More...

class	CIdParamComp
	Component for automatic creation of the Universally Unique Identifier (UUID) More...

class	CManagerParamsSetShadowerComp
	Keep parameter set with selected one synchronized. More...

class	CMultiParamsManagerComp
	Implementation of parameter manager. More...

class	CNameParam
	Implementation of a named object over iprm::INameParam interface. More...

class	CNameParamComp
	Component for automatic creation of the Universally Unique Identifier (UUID) More...

class	COptionsManager
	Implementation of a simple options manager. More...

class	COptionsManagerComp
	Implementation of selection constraints. More...

class	CParameterStateProviderComp
	Component implementation of iprm::IParameterStateProvider interface. More...

class	CParamsManagerComp
	Implementation of parameter manager. More...

class	CParamsManagerCompBase
	Implementation of parameter manager. More...

class	CParamsManagerCompBaseAttr

class	CParamsSet
	Basic implementation of interface IParamsSet. More...

class	CParamsSetDelegatorComp
	Delegator of the parameter set interface. More...

class	CSelectableParamsSetComp
	Interface allowing to select single option from list of options. More...

class	CSelectionBasedParameterStateProviderComp
	Component implementation of iprm::IParameterStateProvider interface. More...

class	CSelectionConstraintsComp
	Implementation of selection constraints. More...

class	CSelectionParam
	Basic implementation of selection parameter. More...

class	CSelectionParamComp
	Component level implementation of selection parameter. More...

class	CTextParam
	Implementation of the text value over iprm::ITextParam interface. More...

class	CTextParamComp
	Component for automatic creation of the Universally Unique Identifier (UUID) More...

class	CVariableParamComp

class	IEnableableParam
	Interface for objects which can be enabled/disabled. More...

class	IIdParam
	Interface for an ID parameter. More...

class	INameParam
	Interface for an object containing a name. More...

class	IOptionsList
	Constraints of selection from set of possibilities. More...

class	IOptionsManager
	Common interface for the management of dynamic selection constraints. More...

class	IParameterStateProvider
	Provider of state information for a parameter inside a parameter set. More...

class	IParamsInfoProvider
	Provider of parameter information (name and description). More...

class	IParamsManager
	Manager of parameter sets. More...

class	IParamsSet
	Set of general parameters. More...

class	IParamsSetValidator
	Interface for consistency checking of a parameter set. More...

class	ISelectionParam
	Interface allowing to select single option from list of options. More...

class	ITextParam
	Interface for an object containing simple text. More...

class	IVariableParam
	Represents a parameter which can change its type. More...

class	TEditableParamsPtr

class	TParamsPtr

class	TParamsPtrBase
	Help pointer wrapper for management of a parameter from the parameter set. More...

Typedefs
typedef istd::TUniqueInterfacePtr< IParamsManager >	IParamsManagerUniquePtr

typedef istd::TSharedInterfacePtr< IParamsManager >	IParamsManagerSharedPtr

typedef istd::TUniqueInterfacePtr< iprm::IParamsSet >	IParamsSetUniquePtr

typedef istd::TSharedInterfacePtr< iprm::IParamsSet >	IParamsSetSharedPtr

Functions
int	FindOptionIndexById (const QByteArray &id, const iprm::IOptionsList &list)
	Find the option index by the given ID.

Detailed Description

Contains interfaces and implementations of flexible parameter concept.

The iprm namespace provides a comprehensive parameter management framework that enables applications to create, manage, and manipulate structured parameter collections with support for various parameter types, validation, serialization, and change notification.

Overview

The iprm library is designed to handle complex parameter management scenarios in applications that require:

Multiple parameter types (text, numeric, selection, etc.)
Dynamic parameter sets that can be created, modified, and deleted at runtime
Parameter validation and consistency checking
Serialization and deserialization of parameter data
Change notification for parameter modifications
Hierarchical parameter organization

Core Concepts

Parameters

Individual parameter types in the iprm library:

ITextParam: Stores simple text strings
IIdParam: Stores unique identifiers (QByteArray)
INameParam: Stores names with fixed/editable state
ISelectionParam: Allows selection from a list of options
IEnableableParam: Can be enabled or disabled
IVariableParam: Can change its underlying type dynamically

All parameters implement iser::ISerializable for persistence.

Parameter Sets

IParamsSet** is a container that groups related parameters together. Each parameter in a set is identified by a unique QByteArray ID. Parameter sets distinguish between:

Read-only parameters (for display or calculated values)
Editable parameters (that users can modify)

Parameter Manager

IParamsManager** manages multiple parameter sets and provides:

CRUD operations (Create, Read, Update, Delete) for parameter sets
Naming and describing parameter sets
Operation flags to control what operations are allowed
Type constraints for creating new parameter sets
Selection of active parameter set

Options and Constraints

Selection parameters are constrained by option lists:

IOptionsList: Read-only list of available options with names, IDs, and descriptions
IOptionsManager: Extends IOptionsList with dynamic add/remove/modify capabilities

Options can be:

Enabled or disabled (affecting selectability)
Given unique IDs for stable references
Organized hierarchically with sub-selections

Usage Patterns

Simple Parameter Usage

// Create a text parameter
iprm::CTextParam param;
param.SetText("Hello");
QString value = param.GetText();

Selection Parameter Usage

// Create options and selection
iprm::COptionsManager options;
options.InsertOption("Option A", "opt_a", "First option");
options.InsertOption("Option B", "opt_b", "Second option");
 
iprm::CSelectionParam selection;
selection.SetSelectionConstraints(&options);
selection.SetSelectedOptionIndex(0);

Parameter Manager Usage

// Work with parameter manager
iprm::IParamsManager* manager ;
 
// Check capabilities
int flags = manager->GetIndexOperationFlags(-1);
if (flags & iprm::IParamsManager::MF_SUPPORT_INSERT)
{
       // Insert new parameter set
       int index = manager->InsertParamsSet();
       manager->SetParamsSetName(index, "My Parameters");
}

Serialization

All parameter types support serialization through the iser framework:

iser::CMemoryWriteArchive writeArchive(nullptr);
param.Serialize(writeArchive);  // Save
 
iser::CMemoryReadArchive readArchive(writeArchive);
param.Serialize(readArchive);   // Load

Change Notification

Parameters support the observer pattern through the istd::IChangeable interface. Each parameter type defines ChangeFlags to identify specific changes:

// ISelectionParam::CF_SELECTION_CHANGED
// INameParam::CF_RENAME
// IEnableableParam::CF_ENABLED
// IParamsManager::CF_SET_INSERTED, CF_SET_REMOVED, etc.

Validation

Parameter sets can be validated using IParamsSetValidator:

iprm::IParamsSetValidator* validator;
bool isValid = validator->IsParamsSetConsistent(
       "contextId",
       paramSet,
       &messageConsumer);

Best Practices

Always check operation flags before attempting operations
Use smart pointers (TUniqueInterfacePtr, TSharedInterfacePtr) for memory management
Validate parameter sets before persisting or processing
Use option IDs rather than indices for stable selection references
Implement observers for reactive parameter updates
Clone parameters when you need independent copies

Main Classes

Interfaces:**

iprm::IParamsSet - Parameter set container
iprm::IParamsManager - Multiple parameter set manager
iprm::ITextParam - Text parameter
iprm::IIdParam - ID parameter
iprm::INameParam - Name parameter
iprm::ISelectionParam - Selection parameter
iprm::IEnableableParam - Enableable parameter
iprm::IVariableParam - Variable type parameter
iprm::IOptionsList - Options list
iprm::IOptionsManager - Dynamic options manager
iprm::IParameterStateProvider - Parameter state provider
iprm::IParamsSetValidator - Parameter set validator

Implementations:**
iprm::CTextParam - Text parameter implementation
iprm::CIdParam - ID parameter implementation
iprm::CNameParam - Name parameter implementation
iprm::CSelectionParam - Selection parameter implementation
iprm::CEnableableParam - Enableable parameter implementation
iprm::COptionsManager - Options manager implementation
iprm::CParamsSet - Parameter set implementation
iprm::CParamsManagerComp - Component-based parameter manager

Typedef Documentation

◆ IParamsManagerSharedPtr

typedef istd::TSharedInterfacePtr<IParamsManager> iprm::IParamsManagerSharedPtr

Definition at line 523 of file IParamsManager.h.

◆ IParamsManagerUniquePtr

typedef istd::TUniqueInterfacePtr<IParamsManager> iprm::IParamsManagerUniquePtr

Definition at line 522 of file IParamsManager.h.

◆ IParamsSetSharedPtr

typedef istd::TSharedInterfacePtr<iprm::IParamsSet> iprm::IParamsSetSharedPtr

Definition at line 207 of file IParamsSet.h.

◆ IParamsSetUniquePtr

typedef istd::TUniqueInterfacePtr<iprm::IParamsSet> iprm::IParamsSetUniquePtr

Definition at line 206 of file IParamsSet.h.

Function Documentation

◆ FindOptionIndexById()

int iprm::FindOptionIndexById	(	const QByteArray &	id,
		const iprm::IOptionsList &	list
	)

Find the option index by the given ID.

Searches through the options list to find an option with a matching ID. This is useful for converting stable option IDs to current indices.

Parameters

id	ID to search for.
list	Options list to search in.

Returns: Found index (0-based), or -1 if no option with the given ID was found.

// Save option ID for later reference
QByteArray savedId = options->GetOptionId(selectedIndex);
 
// ... later, after options might have been reordered ...
 
// Find the option again by its stable ID
int currentIndex = iprm::FindOptionIndexById(savedId, *options);
if (currentIndex >= 0)
{
    qDebug() << "Option found at index:" << currentIndex;
    selectionParam.SetSelectedOptionIndex(currentIndex);
}
else
{
    qDebug() << "Option no longer exists";
}

See also: IOptionsList::GetOptionId

Classes

Typedefs

Functions