Element type

  element => [
               foo => { ... }
             ]

This most important information from this hash ref is the mandatory type parameter. The type type can be:

"node"

The element is a node of a tree instantiated from a configuration class (declared with "create_config_class( ... )" in Config::Model). See "Node element".

"warped_node"

The element is a node whose properties (mostly "config_class_name") can be changed (warped) according to the values of one or more leaf elements in the configuration tree. See Config::Model::WarpedNode for details.

"leaf"

The element is a scalar value. See "Leaf element"

"hash"

The element is a collection of nodes or values (default). Each element of this collection is identified by a string (Just like a regular hash, except that you can set up constraint of the keys). See "Hash element"

"list"

The element is a collection of nodes or values (default). Each element of this collection is identified by an integer (Just like a regular perl array, except that you can set up constraint of the keys). See "List element"

"check_list"

The element is a collection of values which are unique in the check_list. See CheckList.

"class"

Override the default class for leaf, list and hash elements. The override class be inherit Config::Model::Value for leaf element, Config::Model::HashId for hash element and Config::Model::ListId for list element.

Node element

 $model ->create_config_class
   (
   name => "ClassWithOneNode",
   element => [
                the_node => {
                              type => 'node',
                              config_class_name => 'AnotherClass',
                            },
              ]
   ) ;

Leaf element

Hash element

You can also provide a "cargo_type" parameter set to "node" or "leaf" (default).

See Config::Model::HashId and Config::Model::AnyId for more details.

List element

See Config::Model::ListId and Config::Model::AnyId for more details.

name

get_type

config_model

model

config_class_name

instance

has_element

Returns 1 if the class model has the element declared.

Returns 1 as well if "autoadd" is 1 (i.e. by default) and the element name is matched by the optional "accept" model parameter.

If "type" is specified, the element name must also match the type.

find_element

Returns $name if the class model has the element declared or if the element name is matched by the optional "accept" parameter.

If "case" is set to any, "has_element" returns the element name who match the passed name in a case-insensitive manner.

Returns empty if no matching element is found.

model_searcher

This method returns a Config::Model::SearchElement object. See Config::Model::SearchElement for details on how to handle a search.

This method is inherited from Config::Model::AnyThing.

element_model

Returns model of the element.

element_type

Returns the type (e.g. leaf, hash, list, checklist or node) of the element. Also returns the type of a potentially accepted element. Dies if the element is not known or cannot be accepted.

element_name

index_value

parent

root

location

backend_support_annotation

get_element_names

Optional parameters are:

• all: Boolean. When set return all element names, even the hidden ones and does not trigger warp mechanism. Defaults to 0. This option should be set to 1 when this method is needed to read configuration data from a backend.
• type: Returns only element of requested type (e.g. "list", "hash", "leaf",...). By default return elements of any type.
• cargo_type: Returns only hash or list elements that contain the requested cargo type. E.g. if "get_element_names" is called with "cargo_type => 'leaf'", then "get_element_names" returns hash or list elements that contain a leaf object.
• check: "yes", "no" or "skip"

"type" and "cargo_type" parameters can be specified together. In this case, this method returns parameters that satisfy both conditions. I.e. with "type =>'hash', cargo_type => 'leaf'", this method returns only hash elements that contain leaf objects.

Returns a list in array context, and a string (e.g. "join(' ',@array)") in scalar context.

children

next_element

Returns the next element name for status (default "normal"). Returns undef if no next element is available.

previous_element

This method provides a way to iterate through the elements of a node.

Returns the previous element name. Returns undef if no previous element is available.

get_element_property

Retrieve a property of an element.

I.e. for a model :

  status     => [ X => 'deprecated' ]
  element    => [ X => { ... } ]

This call returns "deprecated":

  $node->get_element_property ( element => 'X', property => 'status' )

set_element_property

Set a property of an element.

reset_element_property

Reset a property of an element according to the original model.

fetch_element

Fetch and returns an element from a node if the class model has the element declared.

Also fetch and returns an element from a node if "autoadd" is 1 (i.e. by default) and the element name is matched by the optional "accept" model parameter.

"check" can be set to "yes", "no" or "skip". When "check" is "no" or "skip", this method returns "undef" when the element is unknown, or 0 if the element is not available (hidden).

By default, "accepted" elements are automatically created. Set "autoadd" to 0 when this behavior is not wanted.

fetch_element_value

Fetch and returns the value of a leaf element from a node.

fetch_gist

store_element_value

Store a value in a leaf element from a node.

Can be invoked with named parameters (name, value, check). E.g.

 ( name => 'foo', value => 'bar', check => 'skip' )

is_element_available

Returns 1 if the element "name" is available and if the element is not "hidden". Returns 0 otherwise.

As a syntactic sugar, this method can be called with only one parameter:

   is_element_available( 'element_name' ) ;

accept_element

Checks and returns the appropriate model of an acceptable element (i.e. declared as a model "element" or part of an "accept" declaration). Returns undef if the element cannot be accepted.

accept_regexp

Returns the list of regular expressions used to check for acceptable parameters. Useful for diagnostics.

element_exists

Returns 1 if the element is known in the model.

is_element_defined

Returns 1 if the element is defined.

grab

grab_value

grab_root

get

Get a value from a directory like path. If "get_obj" is 1, "get" returns a leaf object instead of returning its value.

set

Set a value from a directory like path.

deep_check

migrate

apply_fixes

load

Load configuration data from the string into the node and its siblings.

This string follows the syntax defined in Config::Model::Loader. See "load" in Config::Model::Loader for details on parameters.

This method can also be called with a single parameter:

  $node->load("some data:to be=loaded");

load_data

Load configuration data with a hash ref. The hash ref key must match the available elements of the node (or accepted element). The hash ref structure must match the structure of the configuration model.

Use "check => skip" to make data loading more tolerant: bad data are discarded.

"load_data" can be called with a single hash ref parameter.

Returns 1 if some data were saved (instead of skipped).

needs_save

dump_tree

This string follows the syntax defined in Config::Model::Loader. The string produced by "dump_tree" can be passed to "load".

dump_annotations_as_pod

describe

Provides a description of the node elements or of one element.

report

audit

copy_from

Copy configuration data from another node into this node and its siblings. The copy can be made in a tolerant mode where invalid data is discarded with "check => skip". This method can be called with a single argument: "copy_from($another_node)"

get_help

If called without element, returns the description of the class (Stored in "class_description" attribute of a node declaration).

If called with an element name, returns the description of the element (Stored in "description" attribute of a node declaration).

If called with 2 argument, either return the "summary" or the "description" of the element.

Returns an empty string if no description was found.

get_info

tree_searcher

Returns an object able to search the configuration tree. Parameters are :

type

Where to perform the search. It can be "element", "value", "key", "summary", "description", "help" or "all".

Then, "search" method must then be called on the object returned by "tree_searcher".

Returns a Config::Model::TreeSearcher object.

Lazy load of node data