Memory Component handles runtime configuration either using "in memory" Runtime or database using Cache, Fluent Query Builder or Eloquent ORM. Instead of just allowing static configuration to be used, Memory Component allow those configuration to be persistent in between request by utilizing multiple data storage option either through cache or database.

1. Version Compatibility
2. Installation
3. Configuration
4. Usage
   • Creating Instance
   • Storing Items
   • Retrieving Items
   • Removing Items
   • Extending Memory
5. Change Log

Version Compatibility

Laravel	Memory
4.0.x	2.0.x
4.1.x	2.1.x
4.2.x	2.2.x
5.0.x	3.0.x
5.1.x	3.1.x
5.2.x	[email protected]

Installation

To install through composer, simply put the following in your composer.json file:

{
    "require": {
        "orchestra/memory": "~3.0"
    }
}

And then run composer install from the terminal.

Quick Installation

Above installation can also be simplify by using the following command:

composer require "orchestra/memory=~3.0"

Configuration

Next add the service provider in config/app.php.

'providers' => [

    // ...

    Orchestra\Memory\MemoryServiceProvider::class,

    Orchestra\Memory\CommandServiceProvider::class,
],

Aliases

You might want to add Orchestra\Support\Facades\Memory to class aliases in config/app.php:

'aliases' => [

    // ...

    'Memory' => Orchestra\Support\Facades\Memory::class,
],

Migrations

Before we can start using Memory Component, please run the following:

php artisan memory:migrate

The command utility is enabled via Orchestra\Memory\CommandServiceProvider.

Publish Configuration

Optionally, you can also publish the configuration file if there any requirement to change the default:

php artisan publish:config orchestra/memory

Usage

1. Creating Instance
2. Storing Items
3. Retrieving Items
4. Removing Items
5. Extending Memory

Creating Instance

Below are list of possible ways to use Memory:

$runtime  = Memory::make('runtime');
$fluent   = Memory::make('fluent');
$eloquent = Memory::make('eloquent');
$cache    = Memory::make('cache');

However, most of the time you wouldn't need to have additional memory instance other than the default which is using orchestra_options table.

$memory = Memory::make();

When using with Orchestra Platform, Memory::make() would be used throughout the application.

Storing Items

Storing items in the Memory is simple. Simply call the put method:

$memory->put('site.author', 'Taylor');

// or you can also use
Memory::put('site.author', 'Taylor');

The first parameter is the key to the config item. You will use this key to retrieve the item from the config. The second parameter is the value of the item.

Retrieving Items

Retrieving items from Memory is even more simple than storing them. It is done using the get method. Just mention the key of the item you wish to retrieve:

$name = $memory->get('site.author');

// or you can also use
$name = Memory::get('site.author');

By default, NULL will be returned if the item does not exist. However, you may pass a different default value as a second parameter to the method:

$name = $memory->get('site.author', 'Fred');

Now, "Fred" will be returned if the "site.author" item does not exist.

Removing Items

Need to get rid of an item? No problem. Just mention the name of the item to the forget method:

$memory->forget('site.author');

// or you can also use
Memory::forget('site.author');

Extending Memory

There might be requirement that a different type of storage engine would be use for memory instance, you can extending it by adding your own handler.

use Orchestra\Memory\Provider;
use Orchestra\Contracts\Memory\Handler as HandlerContract;

class AcmeMemoryHandler implements HandlerContract
{
    // Add your implementation
}

Memory::extend('acme', function ($app, $name) {
    $handler = new AcmeMemoryHandler($name);

    return new Provider($handler);
});

// Now you can use it as
$acme = Memory::make('acme.default');

You can also extends Orchestra\Memory\Abstractable\Handler which add some boilerplate code on your custom handler.