Struct StringParameter

pub struct StringParameter {
    pub(crate) name: CapeStringImpl,
    description: CapeStringImpl,
    is_input: bool,
    shared_unit_data: Rc<RefCell<SharedUnitData>>,
    pub(crate) value: CapeStringImpl,
    default_value: CapeStringImpl,
    possible_values: Option<CapeArrayStringVec>,
    exclusive: bool,
    validation_status: CapeValidationStatus,
    cobia_object_data: StringParameterCobiaObjectData,
}

The StringParameter class implements a CAPE-OPEN 1.2 string parameter.

Parameters must implement the ICapeIdentification and ICapeParameter interfaces. In addition, string parameters must implement the ICapeStringParameter interface.

This implementation can be used for both input and output parameters. Input parameters can be set by the user, while output parameters are set by the unit operation.

Fields

name: CapeStringImpl

The name of the parameter

description: CapeStringImpl

The description of the parameter

is_input: bool

Indicates whether this parameter is an input (true) or an output (false)

shared_unit_data: Rc<RefCell<SharedUnitData>>

Shared data for the unit, containing unit-specific information

value: CapeStringImpl

The current value of the parameter

default_value: CapeStringImpl

Default value of the parameter

possible_values: Option<CapeArrayStringVec>

List of allowed values for the parameter

exclusive: bool

Exclusive implies only values in the list are allowed.

validation_status: CapeValidationStatus

Validation status of the parameter

cobia_object_data: StringParameterCobiaObjectData

Cobia object data for this object, which contains generated code to provide the native COBIA interfaces

Implementations

impl StringParameter

fn create_instance( _string_parameter_boxed_ptr: *mut *mut ICapeInterface, name: CapeStringImpl, description: CapeStringImpl, is_input: bool, shared_unit_data: Rc<RefCell<SharedUnitData>>, default_value: CapeStringImpl, possible_values: Option<CapeArrayStringVec>, exclusive: bool, ) -> CapeResult

pub(crate) fn create<T: CapeSmartPointer>( name: CapeStringImpl, description: CapeStringImpl, is_input: bool, shared_unit_data: Rc<RefCell<SharedUnitData>>, default_value: CapeStringImpl, possible_values: Option<CapeArrayStringVec>, exclusive: bool, ) -> T

Create a new instance of the object and return a smart pointer to it

This function panics if the created object does not implement the interface corresponding to the smart pointer to be returned. For a non-panic version, use the try_create() function.

pub(crate) fn try_create<T: CapeSmartPointer>( name: CapeStringImpl, description: CapeStringImpl, is_input: bool, shared_unit_data: Rc<RefCell<SharedUnitData>>, default_value: CapeStringImpl, possible_values: Option<CapeArrayStringVec>, exclusive: bool, ) -> Result<T, COBIAError>

Create a new instance of the object and return a smart pointer to it

This function returns an error if the created object does not implement the interface corresponding to the smart pointer to be returned.

pub(crate) unsafe fn borrow<T: CapeSmartPointer>(smart_pointer: &T) -> &Self

Get a reference to the object

Note that as the reference is created from a smart pointer, the reference is valid only as long as the smart pointer is valid. The reference is not checked for multiple borrows

Safety

The user must ensure that the smart pointer contains a valid object, and that the object is of the type that is being borrowed. It is not possible for the compiler to check this, as the borrow is done through the native object pointer in the interface.

pub(crate) unsafe fn borrow_mut<T: CapeSmartPointer>( smart_pointer: &mut T, ) -> &mut Self

Get a mutable reference to the object

Note that as the reference is created from a smart pointer, the reference is valid only as long as the smart pointer is valid. The reference is not checked for multiple borrows

Safety

This function is unsafe because it allows mutable access to the object. Also the user must ensure that the smart pointer contains a valid object, and that the object is of the type that is being borrowed. It is not possible for the compiler to check this, as the borrow is done through the native object pointer in the interface.

impl StringParameter

pub fn new( name: CapeStringImpl, description: CapeStringImpl, is_input: bool, shared_unit_data: Rc<RefCell<SharedUnitData>>, default_value: CapeStringImpl, possible_values: Option<CapeArrayStringVec>, exclusive: bool, ) -> Self

pub fn set_possible_values( &mut self, possible_values: Option<&CapeArrayStringVec>, )

Replace the list of possible values with a new list.

Arguments:

• possible_values - An Option<CapeArrayStringVec> containing the new list of possible values. If None, the parameter will not have any possible values.

pub fn value(&self) -> &CapeStringImpl

Get value by reference

Returns:

• A reference to the current value of the parameter as a CapeStringImpl.

Trait Implementations

impl Display for StringParameter

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Format the StringParameter as a string for display purposes.

The std::fmt::Display interface is used when generating the source name of the object that raises an error.

Arguments:

• f - A mutable reference to a std::fmt::Formatter where the formatted string will be written.

Returns:

• A std::fmt::Result indicating the success or failure of the formatting operation.

impl ICapeIdentification for StringParameter

fn get_component_name( &mut self, name: &mut CapeStringOut<'_>, ) -> Result<(), COBIAError>

Get the name of the component.

Arguments:

• name - A mutable reference to a CapeStringOut where the name will be set.

Returns:

• A Result indicating success or failure. If successful, the name is set in name.

fn get_component_description( &mut self, description: &mut CapeStringOut<'_>, ) -> Result<(), COBIAError>

Get the description of the component.

Arguments:

• description - A mutable reference to a CapeStringOut where the description will be set.

Returns:

• A Result indicating success or failure. If successful, the description is set in description.

fn set_component_name( &mut self, _name: &CapeStringIn<'_>, ) -> Result<(), COBIAError>

Set the name of the component.

This method is not allowed for this parameter implementation and will return an error.

fn set_component_description( &mut self, _desc: &CapeStringIn<'_>, ) -> Result<(), COBIAError>

Set the description of the component.

This method is not allowed for this parameter implementation and will return an error.

impl ICapeIdentificationImpl for StringParameter

type T = StringParameter

fn as_interface_pointer(&mut self) -> *mut ICapeInterface

fn init_interface() -> _ICapeInterface

prepare CAPEOPEN_1_2_ICapeIdentification interface and return as generic ICapeInterface pointer

fn init<Timpl>(u: &mut Timpl)

where Timpl: ICapeIdentificationImpl + ICapeInterfaceImpl,

extern "C" fn raw_get_component_name( me: *mut c_void, name: *mut _ICapeString, ) -> u32

extern "C" fn raw_set_component_name( me: *mut c_void, name: *mut _ICapeString, ) -> u32

extern "C" fn raw_get_component_description( me: *mut c_void, desc: *mut _ICapeString, ) -> u32

extern "C" fn raw_set_component_description( me: *mut c_void, desc: *mut _ICapeString, ) -> u32

const VTABLE: CAPEOPEN_1_2_ICapeIdentification_VTable = _

impl ICapeInterfaceImpl for StringParameter

type T = StringParameter

fn get_object_data(&mut self) -> &mut CapeObjectData

Returns a mutable reference to the internal CapeObjectData structure.

fn get_self(&mut self) -> *mut StringParameter

Returns a pointer to the implementing object.

const CAPEINTERFACE_VTABLE: ICapeInterface_VTable = _

the V-table for the ICapeInterface implementation.

fn init(&mut self) -> *mut _ICapeInterface

Initializes the object, setting up the interface pointer and adding it to the interface map.

fn create_object_data<Timpl>() -> CapeObjectData

where Timpl: ICapeInterfaceImpl,

Utility function for internal object setup

extern "C" fn raw_add_reference(me: *mut c_void)

extern "C" fn raw_release(me: *mut c_void)

extern "C" fn raw_query_interface( me: *mut c_void, uuid: *const _CapeUUID, interface: *mut *mut _ICapeInterface, ) -> u32

extern "C" fn raw_get_last_error( me: *mut c_void, error: *mut *mut _ICapeError, ) -> u32

fn add_interface( &mut self, uuid: *const _CapeUUID, interface: *mut _ICapeInterface, )

Utility function to add an interface to the interface map.

fn set_last_error(&mut self, error: COBIAError, scope: &str) -> u32

Utility function to set the last error and scope.

fn clear_last_error(&mut self)

Utility function to clear the last error and scope.

fn as_icapeinterface(&mut self) -> *mut _ICapeInterface

Returns a unique pointer to the ICapeInterface implementation of the object.

impl ICapeParameter for StringParameter

fn get_val_status(&mut self) -> Result<CapeValidationStatus, COBIAError>

Get the validation status of the parameter.

Returns:

• A Result containing the validation status, which is always CapeValid for this implementation.

fn get_mode(&mut self) -> Result<CapeParamMode, COBIAError>

Get the mode of the parameter.

Returns:

• A Result containing the mode of the parameter, which is either CapeInput or CapeOutput based on the is_input field.

fn get_type(&mut self) -> Result<CapeParamType, COBIAError>

Get the type of the parameter.

Returns:

• A Result containing the type of the parameter, which is always CapeParameterString for this implementation.

fn validate( &mut self, message: &mut CapeStringOut<'_>, ) -> Result<CapeBoolean, COBIAError>

Validate the parameter.

Call the value validation method to check if the parameter value is valid.

Arguments:

• message - A mutable reference to a CapeStringOut where any validation error messages will be set.

Returns:

• A Result containing a CapeBoolean indicating whether the parameter is valid or not. If the input value is not specified, it returns false and sets an error message.

fn reset(&mut self) -> Result<(), COBIAError>

Reset the parameter to its default value.

This method sets the value of the parameter back to its default value and marks the unit as dirty. It also resets the validation status to CapeNotValidated.

Returns:

• A Result indicating success or failure. If successful, the value is reset to the default value.

impl ICapeParameterImpl for StringParameter

type T = StringParameter

fn as_interface_pointer(&mut self) -> *mut ICapeInterface

fn init_interface() -> _ICapeInterface

prepare CAPEOPEN_1_2_ICapeParameter interface and return as generic ICapeInterface pointer

fn init<Timpl>(u: &mut Timpl)

where Timpl: ICapeParameterImpl + ICapeInterfaceImpl,

extern "C" fn raw_get_val_status( me: *mut c_void, val_status: *mut i32, ) -> u32

extern "C" fn raw_get_mode(me: *mut c_void, mode: *mut i32) -> u32

extern "C" fn raw_get_type( me: *mut c_void, parameter_type: *mut i32, ) -> u32

extern "C" fn raw_validate( me: *mut c_void, message: *mut _ICapeString, is_ok: *mut u32, ) -> u32

extern "C" fn raw_reset(me: *mut c_void) -> u32

const VTABLE: CAPEOPEN_1_2_ICapeParameter_VTable = _

impl ICapeStringParameter for StringParameter

fn get_value(&mut self, value: &mut CapeStringOut<'_>) -> Result<(), COBIAError>

Get the current value of the string parameter.

Arguments:

• value - A mutable reference to a CapeStringOut where the current value will be set.

Returns:

• A Result indicating success or failure. If successful, the current value is set in value.

fn set_value(&mut self, value: &CapeStringIn<'_>) -> Result<(), COBIAError>

Set the value of the string parameter.

The current value cannot be set for an output parameter.

Arguments:

• value - A reference to a CapeStringIn containing the new value to be set.

Returns:

• A Result indicating success or failure. If successful, the value is set and the unit is marked as dirty.

fn get_default_value( &mut self, default_value: &mut CapeStringOut<'_>, ) -> Result<(), COBIAError>

Get the default value of the string parameter.

Arguments:

• default_value - A mutable reference to a CapeStringOut where the default value will be set.

Returns:

• A Result indicating success or failure. If successful, the default value is set in default_value.

fn get_option_list( &mut self, option_names: &mut CapeArrayStringOut<'_>, ) -> Result<(), COBIAError>

Get the list of possible values for the string parameter.

Arguments:

• option_names - A mutable reference to a CapeArrayStringOut where the list of possible values will be set.

Returns:

• A Result indicating success or failure. If successful, the list of possible values is set in option_names.

fn get_restricted_to_list(&mut self) -> Result<CapeBoolean, COBIAError>

Check whether the value is restricted to the list of possible values.

Returns:

• A Result containing a CapeBoolean indicating whether the value is restricted to the list of possible values.

fn validate( &mut self, value: &CapeStringIn<'_>, message: &mut CapeStringOut<'_>, ) -> Result<CapeBoolean, COBIAError>

Validate the value of the string parameter.

This method checks whether the specified value is suitable for the parameter.

Arguments:

• value - A reference to a CapeStringIn containing the value to be validated.
• message - A mutable reference to a CapeStringOut where any validation error messages will be set.

Returns:

• A Result containing a CapeBoolean indicating whether the value is valid or not. If the input value is not specified, it returns false and sets an error message.

impl ICapeStringParameterImpl for StringParameter

type T = StringParameter

fn as_interface_pointer(&mut self) -> *mut ICapeInterface

fn init_interface() -> _ICapeInterface

prepare CAPEOPEN_1_2_ICapeStringParameter interface and return as generic ICapeInterface pointer

fn init<Timpl>(u: &mut Timpl)

where Timpl: ICapeStringParameterImpl + ICapeInterfaceImpl,

extern "C" fn raw_get_value( me: *mut c_void, value: *mut _ICapeString, ) -> u32

extern "C" fn raw_set_value( me: *mut c_void, value: *mut _ICapeString, ) -> u32

extern "C" fn raw_get_default_value( me: *mut c_void, default_value: *mut _ICapeString, ) -> u32

extern "C" fn raw_get_option_list( me: *mut c_void, option_names: *mut ICapeArrayString, ) -> u32

extern "C" fn raw_get_restricted_to_list( me: *mut c_void, restricted: *mut u32, ) -> u32

extern "C" fn raw_validate( me: *mut c_void, value: *mut _ICapeString, message: *mut _ICapeString, is_ok: *mut u32, ) -> u32

const VTABLE: CAPEOPEN_1_2_ICapeStringParameter_VTable = _