Struct Schema

pub struct Schema { /* private fields */ }

Represents a set of attributes that are stored with an item.

These schemas are used for interoperability between various services storing the same types of items.

Each schema has a name like org.gnome.keyring.NetworkPassword, and defines a set of attributes, and types (string, integer, boolean) for those attributes.

Attributes are stored as strings in the Secret Service, and the attribute types simply define standard ways to store integer and boolean values as strings. Attributes are represented in libsecret via a [glib::HashTable][crate::glib::HashTable] with string keys and values. Even for values that defined as an integer or boolean in the schema, the attribute values in the [glib::HashTable][crate::glib::HashTable] are strings. Boolean values are stored as the strings ‘true’ and ‘false’. Integer values are stored in decimal, with a preceding negative sign for negative integers.

Schemas are handled entirely on the client side by this library. The name of the schema is automatically stored as an attribute on the item.

Normally when looking up passwords only those with matching schema names are returned. If the schema @flags contain the SECRET_SCHEMA_DONT_MATCH_NAME flag, then lookups will not check that the schema name matches that on the item, only the schema’s attributes are matched. This is useful when you are looking up items that are not stored by the libsecret library. Other libraries such as libgnome-keyring don’t store the schema name.

Additional schemas can be defined via the Schema structure like this:

⚠️ The following code is in c ⚠️

// in a header:

const SecretSchema * example_get_schema (void) G_GNUC_CONST;

#define EXAMPLE_SCHEMA  example_get_schema ()


// in a .c file

const SecretSchema *
example_get_schema (void)
{
    static const SecretSchema the_schema = {
        "org.example.Password", SECRET_SCHEMA_NONE,
        {
            {  "number", SECRET_SCHEMA_ATTRIBUTE_INTEGER },
            {  "string", SECRET_SCHEMA_ATTRIBUTE_STRING },
            {  "even", SECRET_SCHEMA_ATTRIBUTE_BOOLEAN },
            {  NULL, 0 },
        }
    };
    return &the_schema;
}

GLib type: Shared boxed type with reference counted clone semantics.

Implementations

impl Schema

pub fn as_ptr(&self) -> *mut SecretSchema

Return the inner pointer to the underlying C value.

pub unsafe fn from_glib_ptr_borrow(ptr: &*mut SecretSchema) -> &Self

Borrows the underlying C value.

impl Schema

pub fn new( name: &str, flags: SchemaFlags, attribute_names_and_types: HashMap<&str, SchemaAttributeType>, ) -> Self

Using this function is not normally necessary from C code. This is useful for constructing #SecretSchema structures in bindings.

A schema represents a set of attributes that are stored with an item. These schemas are used for interoperability between various services storing the same types of items.

Each schema has an @name like org.gnome.keyring.NetworkPassword, and defines a set of attributes names, and types (string, integer, boolean) for those attributes.

Each key in the @attributes table should be a attribute name strings, and the values in the table should be integers from the SchemaAttributeType enumeration, representing the attribute type for each attribute name.

Normally when looking up passwords only those with matching schema names are returned. If the schema @flags contain the SchemaFlags::DONT_MATCH_NAME flag, then lookups will not check that the schema name matches that on the item, only the schema’s attributes are matched. This is useful when you are looking up items that are not stored by the libsecret library. Other libraries such as libgnome-keyring don’t store the schema name.

name

the dotted name of the schema

flags

the flags for the schema

attribute_names_and_types

the attribute names and types of those attributes

Returns

the new schema, which should be unreferenced with Schema::unref() when done

Trait Implementations

impl Clone for Schema

fn clone(&self) -> Self

Makes a clone of this shared reference.

This increments the strong reference count of the reference. Dropping the reference will decrement it again.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Schema

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

Formats the value using the given formatter.

impl From<Schema> for Value

fn from(s: Schema) -> Self

Converts to this type from the input type.

impl HasParamSpec for Schema

type ParamSpec = ParamSpecBoxed

type SetValue = Schema

Preferred value to be used as setter for the associated ParamSpec.

type BuilderFn = fn(_: &str) -> ParamSpecBoxedBuilder<'_, Schema>

fn param_spec_builder() -> Self::BuilderFn

impl Hash for Schema

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Schema

fn cmp(&self, other: &Schema) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Schema

fn eq(&self, other: &Schema) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Schema

fn partial_cmp(&self, other: &Schema) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for Schema

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for Schema

impl StructuralPartialEq for Schema