chillerlan/php-traits

Some useful traits for PHP 7+

chillerlan/php-traits

A collection of (more or less) useful traits for PHP7.2+, _(*1)

![license][license-badge] ![Travis][travis-badge] ![Coverage][coverage-badge] ![Scrunitizer][scrutinizer-badge] ![Packagist downloads][downloads-badge] ![PayPal donate][donate-badge], _(*2)

Features

• ClassLoader - invokes objects of a given class and interface/type with an arbitrary count of constructor arguments
• Magic - turns methods into magic properties
• Enumerable - provides some of prototype's enumerable methods, implements EnumerableInterface
• ArrayHelpers
  • ByteArray - useful for byte/bit-flipping purposes, extends SplFixedArray
  • ByteArrayDispenser - creates ByteArray from several data types (hex, base64, binary, json etc.)
  • DotArray - adds dot key notation functionality
  • SearchableArray - deep search arrays using RecursiveIteratorIterator
• Interfaces
  • ArrayAccessTrait - implements ArrayAccess
  • IteratorTrait - implements Iterator
• SPL
  • CountableTrait - implements Countable
  • SeekableIteratorTrait - implements SeekableIterator

Documentation

Installation

requires composer, _(*3)

composer.json (note: replace dev-master with a version boundary), _(*4)

{
    "require": {
        "php": "^7.2",
        "chillerlan/php-traits": "dev-master"
    }
}

Manual installation

Download the desired version of the package from master or release and extract the contents to your project folder. After that: - run composer install to install the required dependencies and generate /vendor/autoload.php. - if you use a custom autoloader, point the namespace chillerlan\Traits to the folder src of the package, _(*5)

Profit!, _(*6)

Usage

ClassLoader

Simple usage:, _(*7)

class MyClass{
    use ClassLoader;

    protected function doStuff(string $class){
        $obj = $this->loadClass(__NAMESPACE__.'\\Whatever\\'.$class);

        // do stuff
    }
}

Let's assume we have several classes that implement the same interface, but their constructors have different parameter counts, like so:, _(*8)

class SomeClass implements MyInterface{
    public funtion __construct($param_foo){}
}

class OtherClass implements MyInterface{
    public funtion __construct($param_foo, $param_bar){}
}

Initialize an object based on a selction, _(*9)

class MyClass{
    use ClassLoader;

    protected $classes = [
        'foo' => SomeClass::class, 
        'bar' => OtherClass::class
    ];

    protected funtion initInterface(string $whatever, $foo, $bar = null):MyInterface{

        foreach($this->classes as $what => $class){
            if($whatever === $what){
                return $this->loadClass($class, MyInterface::class, $foo, $bar);
            }
        }

    }
}

Magic

Magic allows to access internal methods like as properties., _(*10)

class MyMagicContainer{
    use Magic;

    protected $foo;

    protected function magic_get_foo(){
        // do whatever...

        return 'foo: '.$this->foo;
    }

    protected function magic_set_foo($value){
        // do stuff with $value
        // ...

        $this->foo = $value.'bar';
    }
}

$magic = new MyMagicContainer;

$magic->foo = 'foo';

var_dump($magic->foo); // -> foo: foobar

Enumerable

class MyEnumerableContainer implements EnumerableInterface{
    use Enumerable;

    public function __construct(array $data){
        $this->array = $data;
    }
}

$enum = new MyEnumerableContainer($data);

$enum
    ->__each(function($value, $index){
        // do stuff

        $this->array[$index] = $stuff;
    })
    ->__reverse()
    ->__to_array()
;

$arr = $enum->__map(function($value, $index){
    // do stuff

    return $stuff;
});

$enum;