joomla/registry

Joomla Registry Package

The Registry Package

, _(*1)

``` php use Joomla\Registry\Registry;, <sub>(*2)</sub>

$registry = new Registry;, <sub>(*3)</sub>

// Set a value in the registry. $registry->set('foo', 'bar');, <sub>(*4)</sub>

// Get a value from the registry; $value = $registry->get('foo');, <sub>(*5)</sub>

## Load config by Registry

``` php
use Joomla\Registry\Registry;

$registry = new Registry;

// Load by string
$registry->loadString('{"foo" : "bar"}');

$registry->loadString('<root></root>', 'xml');

// Load by object or array
$registry->loadObject($object);
$registry->loadArray($array);

// Load by file
$registry->loadFile($root . '/config/config.json', 'json');

Accessing a Registry by getter & setter

Get value

``` php $registry->get('foo');, <sub>(*6)</sub>

// Get a non-exists value and return default $registry->get('foo', 'default');, <sub>(*7)</sub>

// OR, <sub>(*8)</sub>

$registry->get('foo') ?: 'default';, <sub>(*9)</sub>

### Set value

``` php
// Set value
$registry->set('bar', $value);

// Sets a default value if not already assigned.
$registry->def('bar', $default);

Accessing children value by path

``` php $json = '{ "parent" : { "child" : "Foo" } }';, <sub>(*10)</sub>

$registry = new Registry($json);, <sub>(*11)</sub>

$registry->get('parent.child'); // return 'Foo', <sub>(*12)</sub>

$registry->set('parent.child', $value);, <sub>(*13)</sub>

## Removing values from Registry

``` php
// Set value
$registry->set('bar', $value);

// Remove the key
$registry->remove('bar');

// Works for nested keys too
$registry->set('nested.bar', $value);
$registry->remove('nested.bar');

Accessing a Registry as an Array

The Registry class implements ArrayAccess so the properties of the registry can be accessed as an array. Consider the following examples:, <sub>(*14)</sub>

``` php // Set a value in the registry. $registry['foo'] = 'bar';, <sub>(*15)</sub>

// Get a value from the registry; $value = $registry['foo'];, <sub>(*16)</sub>

// Check if a key in the registry is set. if (isset($registry['foo'])) { echo 'Say bar.'; }, <sub>(*17)</sub>

## Merge Registry

#### Using load* methods to merge two config files.

``` php
$json1 = '{
    "field" : {
        "keyA" : "valueA",
        "keyB" : "valueB"
    }
}';

$json2 = '{
    "field" : {
        "keyB" : "a new valueB"
    }
}';

$registry->loadString($json1);
$registry->loadString($json2);

Output, <sub>(*18)</sub>

Array(
    field => Array(
        keyA => valueA
        keyB => a new valueB
    )
)

Merge another Registry

``` php $object1 = '{ "foo" : "foo value", "bar" : { "bar1" : "bar value 1", "bar2" : "bar value 2" } }';, <sub>(*19)</sub>

$object2 = '{ "foo" : "foo value", "bar" : { "bar2" : "new bar value 2" } }';, <sub>(*20)</sub>

$registry1 = new Registry(json_decode($object1)); $registry2 = new Registry(json_decode($object2));, <sub>(*21)</sub>

$registry1->merge($registry2);, <sub>(*22)</sub>

If you just want to merge first level, do not hope recursive:

``` php
$registry1->merge($registry2, false); // Set param 2 to false that Registry will only merge first level

Dump to file.

``` php $registry->toString();, <sub>(*23)</sub>

$registry->toString('xml');, <sub>(*24)</sub>

$registry->toString('ini');, <sub>(*25)</sub>

## Dump to one dimension

``` php
$array = array(
    'flower' => array(
        'sunflower' => 'light',
        'sakura' => 'samurai'
    )
);

$registry = new Registry($array);

// Make data to one dimension

$flatted = $registry->flatten();

print_r($flatted);

The result:, <sub>(*26)</sub>

Array
(
    [flower.sunflower] => light
    [flower.sakura] => samurai
)

Using YAML

Add Symfony YAML component in composer.json, <sub>(*27)</sub>

``` json { "require-dev": { "symfony/yaml": "~2.0" } }, <sub>(*28)</sub>

Using `yaml` format

``` php
$registry->loadFile($yamlFile, 'yaml');

$registry->loadString('foo: bar', 'yaml');

// Convert to string
$registry->toString('yaml');

Using XML

Keep in mind that due to XML complexity, special format must be kept when loading into Registry. By default, the parent XML element should be named "registry" and all child elements should be named "node". The nodes should include a "name" attribute, for the name of the value. The nodes can be optionally filtered with a "type" attribute. Valid types are:, <sub>(*29)</sub>

• array
• boolean
• double
• integer
• object (default)
• string

Loading input, <sub>(*30)</sub>

``` xml bar 1 42 3.1415 value value , <sub>(*31)</sub>

with `Registry`

``` php
$registry = new Registry;

// Load file or string
$registry->loadFile($xmlFile, 'xml');
$registry->loadString($xmlString, 'xml');

Outputs, <sub>(*32)</sub>

Array(
    foo_1 => bar
    foo_2 => 1
    foo_3 => 42
    foo_4 => 3.1415
    foo_5 => Array(
        foo_5_a => value
    )
    foo_6 => Array(
        foo_6_a => value
    )
)

The names of the XML import nodes can be customised using options. For example:, <sub>(*33)</sub>

``` php $registry = new Registry(array( 'name' => 'data', 'nodeName' => 'value' ));, <sub>(*34)</sub>

$registry->loadString('bar, 'xml');, <sub>(*35)</sub>

## Custom Formats
To load your own custom format you must implement the `Joomla\Registry\FormatInterface`. This can then be loaded through the `Joomla\Registry\Factory` class. To load a custom format not provided by Joomla then you can load it by using

`Factory::getFormat($type, $options)`

In this scenario `$type` contains the format (and class) name. Whilst `$options` is an array with the key `format_namespace` which contains the namespace that the format is in. 

## Installation via Composer

Add `"joomla/registry": "~1.0"` to the require block in your composer.json and then run `composer install`.

```json
{
    "require": {
        "joomla/registry": "~1.0"
    }
}

Alternatively, you can simply run the following from the command line:, <sub>(*36)</sub>

composer require joomla/registry "~1.0"