PHP code example of redcatphp / strategy

1. Go to this page and download the library: Download redcatphp/strategy library. Choose the download type require.

2. Extract the ZIP file and open the index.php.

3. Add this code to the index.php.

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

redcatphp / strategy example snippets


$a = new A(new B, new C, new D(new E, new F));


$a = $di->get('A');


class A {  
    private $a;  
    private $b;  
    private $c;  
    function \_\_construct(A $a, B $b, C $c, D $d){  
        $this->a = $a;  
        $this->b = $b;  
        $this->c = $c;  
        $this->d = $d;  
    }  
}  
class D {  
    private $e;  
    private $f;  
    function \_\_construct(E $e, F $f){  
        $this->e = $e;  
        $this->f = $f;  
    }  
}


$a = new A(new B, new C, new D(new E, new F));


$a = $di->get('A');


class C {  
    private $x;  
    function \_\_construct(X $x){  
        $this->x = $x;  
    }  
}


class A {  
    private $b;  
    private $c;  
    private $d;  
    function \_\_construct(){  
        $this->b = new B;  
        $this->c = new C;  
        $this->d = new D(new E, new F);  
    }  
  
}


class A {  
    private $b;  
    private $c;  
    private $d;  
    function \_\_construct(B $b, C $c, D $d){  
        $this->b = $b;  
        $this->c = $c;  
        $this->d = $d;  
    }  
  
}


class B {  
    function \_\_construct(PDO $pdo, C $c){  
  
    }  
}


class ExistingA {  
    function \_\_construct(B $b){  
          
    }  
}


$di = \\Strategy\\Di::getInstance(); //global shared instance  
  
$di = new \\Strategy\\Di; //classical new instance


$di->get('My\\Class');  
  
\\Strategy\\Di::getInstance()->get('My\\Class'); //global shared instance used via object  
  
\\Strategy\\Di::make('My\\Class'); //global shared instance used via static call


class A {  
    private $b;  
  
    function \_\_construct(B $b) {  
        $this->b = $b;  
    }  
}  
  
class B {  
    private $c,$d;  
  
    function \_\_construct(C $c, D $d) {  
        $this->c = $c;  
        $this->d = $d;  
    }  
}  
  
class C {  
  
}  
  
class D {  
    private $e;  
      
    function \_\_construct(E $e) {  
        $this->e = $e;  
    }  
}  
  
class E {  
      
}  
  
$a = $di->get('A');  
print\_r($a);


A Object  
(  
    [b:A:private] => B Object  
        (  
            [c:B:private] => C Object  
                (  
                )  
  
            [d:B:private] => D Object  
                (  
                    [e:D:private] => E Object  
                        (  
                        )  
  
                )  
  
        )  
  
)


class A {  
    public $name;  
    public $b;  
      
    function \_\_construct(B $b, $name) {  
        $this->name = $name;  
        $this->b = $b;  
    }  
}


$a1 = $di->get('A', ['FirstA']);  
$a2 = $di->get('A', ['SecondA']);  
  
echo $a1->name; // "FirstA"  
echo $a2->name; // "SecondA"


class A {  
    public $name;  
    public $lastname;  
    public $pseudo;  
    public $b;     
  
    function \_\_construct(B $b, $name, $lastname, $pseudo){  
        $this->name = $name;  
        $this->lastname = $lastname;  
        $this->pseudo = $pseudo;  
        $this->b = $b;  
    }  
}  
  
$a1 = $di->get('A', [ //order of associative keys doesn't matter  
    'lastname'=>'RedCat'  
    'name'=>'Jo',  
    'pseudo'=>'Surikat',  
]);  
$a2 = $di->get('A', [  
    'RedCat',  
    'Surikat'  
    'name'=>'Jo', //order of associative key doesn't matter  
]);  
$a3 = $di->get('A', [  
    'Jo',  
    'lastname'=>'RedCat' //order of associative key doesn't matter  
    'Surikat',  
]);  
  
echo $a1->name; // "Jo"  
echo $a1->lastname; // "RedCat"  
echo $a1->pseudo; // "Surikat"  
  
echo $a2->name; // "Jo"  
echo $a2->lastname; // "RedCat"  
echo $a2->pseudo; // "Surikat"  
  
echo $a3->name; // "Jo"  
echo $a3->lastname; // "RedCat"  
echo $a3->pseudo; // "Surikat"


//create a rule to apply to shared object  
$rule = ['shared' => true];  
  
//Apply the rule to instances of PDO  
$di->addRule('PDO', $rule);  
  
//Now any time PDO is requested from Strategy, the same instance will be returned  
$pdo = $di->get('PDO');  
$pdo2 = $di->get('PDO');  
var\_dump($pdo === $pdo2); //TRUE  
  
//And any class which asks for an instance of PDO will be given the same instance:  
class MyClass {  
    public $pdo;  
    function \_\_construct(PDO $pdo) {  
        $this->pdo = $pdo;  
    }  
}  
  
$myobj = $di->get('MyClass');  
var\_dump($pdo === $myobj->pdo); //TRUE


$rule = [  
    //Mark the class as shared so the same instance is returned each time  
    'shared' => true,   
    //The constructor arguments that will be supplied when the instance is created  
    'construct' => ['mysql:host=127.0.0.1;dbname=mydb', 'username', 'password']   
];  
  
//Apply the rule to the PDO class  
$di->addRule('PDO', $rule);  
  
//Now any time PDO is requested from Strategy, the same instance will be returned  
//And will havebeen constructed with the arugments supplied in 'construct'  
$pdo = $di->get('PDO');  
$pdo2 = $di->get('PDO');  
var\_dump($pdo === $pdo2); //TRUE  
  
  
//And any class which asks for an instance of PDO will be given the same instance:  
class MyClass {  
    public $pdo;  
    function \_\_construct(PDO $pdo) {  
        $this->pdo = $pdo;  
    }  
}  
  
class MyOtherClass {  
    public $pdo;  
    function \_\_construct(PDO $pdo) {  
        $this->pdo = $pdo;  
    }  
}  
  
  
//Note, Strategy is never told about the 'MyClass' or 'MyOtherClass' classes, it can  
//just automatically create them and inject the


$rule = ['name' => 'value'];  
$di->addRule('rulename', $rule);


$di->addRule('A', $rule);  
$a = $di->get('A');


class A {  
    function \_\_construct(Iterator $iterator) {  
      
    }  
}


class B implements Iterator {  
    //...  
}


//When a constructor asks for an instance of Iterator pass it an instance of B instead  
$rule = ['substitutions' => ['Iterator' => new Expander('B')]];  
  
$di->addRule('A', $rule);  
$a = $di->get('A');


$a = new A(new DirectoryIterator('/tmp'));


$rule = ['substitutions' => ['Iterator' => new DirectoryIterator('/tmp')]];  
  
$di->addRule('A', $rule);  
$a = $di->get('A');


$rule = ['substitutions' =>   
            ['Iterator' => new Expander(function() {  
                            return new DirectoryIterator('/tmp');  
                        })]  
            ]  
        ];  
  
$di->addRule('A', $rule);  
$a = $di->get('A');


$namedDirectoryIteratorRule = [  
                    //An instance of the DirectoryIterator class will be created  
                    'instanceOf' => 'DirectoryIterator',  
                    //When the DirectoryIterator is created, it will be passed the string '/tmp' as the constructor argument  
                    'construct' => ['/tmp']  
];  
  
  
//Create a rule under the name "$MyDirectoryIterator" which can be referenced as a substitution for any other rule  
$di->addRule('$MyDirectoryIterator', $namedDirectoryIteratorRule);  
  
  
//This tells the DI Container to use the configuration for $MyDirectoryIterator when an Iterator is asked for in the constructor argument  
$aRule = ['substitutions' =>   
            [  
                'Iterator' => new Expander('$MyDirectoryIterator')  
            ]  
        ];  
  
//Apply the rule to the A class  
$di->addRule('A', $aRule);  
  
//Now, when $a is created, it will be passed the Iterator configured as $MyDirectoryIterator  
$a = $di->get('A');


class A {  
}  
  
class B extends A {  
}  
  
  
//Mark instances of A as shared  
$aRule = ['shared' => true];  
$di->addRule('A', $aRule);  
  
//Get the rule currently applied to 'B' objects  
$bRule = $di->getRule('B');  
  
//And B instances will also be shared  
var\_dump($bRule['shared']); //TRUE  
  
//And to test it:  
$b1 = $di->get('B');  
$b2 = $di->get('B');  
  
var\_dump($b1 === $b2); //TRUE (they are the same instance)


class A {  
}  
  
class B extends A {  
}  
  
  
//This time mark A as shared, but turn off rule inheritance  
$aRule = ['shared' => true, 'inherit' => false];  
  
$di->addRule('A', $rule);  
$bRule = $di->getRule('B');  
  
//Now, B won't be marked as shared as the rule applied to A is not inherited  
var\_dump($bRule['shared']); //FALSE  
  
//And to test it:  
$b1 = $di->get('B');  
$b2 = $di->get('B');  
  
var\_dump($b1 === $b2); //FALSE (they are not the same instance)


class A {  
    function \_\_construct(B $b, $foo, $bar) {  
    }  
}


$rule = ['construct' => ['Foo', 'Bar']];  
  
$di->addRule('A', $rule);  
  
$a = $di->get('A');


new A(new B, 'Foo', 'Bar');


class A {  
    function \_\_construct($foo, $bar, B $b) {  
    }  
}  
  
$rule = ['construct' => ['Foo', 'Bar']];  
  
$di->addRule('A', $rule);  
  
$a = $di->get('A')


new A('Foo', 'Bar', new B);


class A {  
    function \_\_construct(B $b) {  
      
      
    }  
      
    function method1($foo, $bar) {  
        echo 'Method1 called with ' . $foo . ' and ' . $bar . "\\n";  
    }  
      
    function method2() {  
        echo "Method2 called\\n";  
    }  
}  
  
  
$rule = [  
            'call' => [  
                ['method1', ['Foo1' ,'Bar1']],  
                ['method1', ['Foo2' ,'Bar2']],  
                ['method2', []]  
            ]  
        ];  
  
  
$di->addRule('A', $rule);  
$a = $di->get('A');


Method1 called with Foo1 and Bar1   
Method1 called with Foo2 and Bar2  
Method2 called


$rule = [  
    'construct' => ['mysql:host=127.0.0.1;dbname=mydb', 'username', 'password'],  
    'shared' = true,  
    'call' => [  
        ['setAttribute', [PDO::ATTR\_DEFAULT\_FETCH\_MODE, PDO::FETCH\_OBJ]]  
    ]  
];  
  
$di->addRule('PDO', $rule);  
  
class MyClass {  
    function \_\_construct(PDO $pdo) {  
      
    }  
}  
  
//MyObj will be constructed with a fully initialisd PDO object  
$myobj = $di->get('MyClass');


    $rule = [  
        'call' => [  
            'methodName'=>[$arg1, $arg2],  
            ['methodName',[$arg3, $arg4]],  
            'otherMethodName'=>$singleArgThatIsNotAnArray,  
              
            'methodName'=>[  
                'varname2'=>$arg2  
                'varname'=>$arg1,  
            ],  
            ['methodName',[  
                'varname2'=>$arg2  
                'varname'=>$arg1,  
            ]],  
        ]  
    ];


class MyPDO extends PDO {  
    //...  
}


class Foo {  
    public $pdo;  
    function \_\_construct(PDO $pdo) {  
        $this->pdo = $pdo;  
    }  
}  
  
//When PDO is type hinted, supply an instance of MyPDO instead  
$rule = ['substitutions' => ['PDO' => new Expander('MyPDO')]];  
  
//Apply the rule to every class  
$di->addRule('\*', $rule);  
  
$foo = $di->get('Foo');  
echo get\_class($foo->pdo); // "MyPDO"


class DataCopier {  
    function \_\_construct(PDO $database1, PDO $database2) {  
          
    }  
}  
  
//A rule for the default PDO object  
$rule = [  
    'shared' => true,  
    'construct' = ['mysql:host=127.0.0.1;dbname=mydb', 'username', 'password']  
];  
  
$di->addRule('PDO', $rule);  
  
  
//And a rule for the second database  
$secondDBRule = [  
    'shared' => true,  
    'construct' = ['mysql:host=externaldatabase.com;dbname=foo', 'theusername', 'thepassword'],  
      
    //This rule will create an instance of the PDO class  
    'instanceOf' => 'PDO'  
];  
  
  
//Add named instance called $Database2  
//Notice that the name being applied to is not the name of class  
//but a chosen named instance  
$di->addRule('$Database2', $secondDBRule);  
  
//Now set DataCopier to use the two different databases:  
$dataCopierRule = [  
    'construct' => [  //Set the constructor parameters to the two database instances.  
            new Expander('PDO'),  
            new Expander('$Database2')  
    ]  
];  
  
  
$di->addRule('DataCopier', $dataCopierRule);  
  
$dataCopier = $di->get('DataCopier');


class A {  
  
    public $b, $c;  
      
    function \_\_construct(B $b, C $c) {  
      
      
    }  
  
}  
  
  
class B {  
    public $d;  
      
    function \_\_construct(D $d) {  
        $this->d = $d;  
    }  
}  
  
class C {  
    public $d;  
      
    function \_\_construct(D $d) {  
        $this->d = $d;  
    }  
}  
  
  
class D {}


$rule = [  
    'shareInstances' = ['D']  
];  
  
$di->addRule('A', $rule);  
  
  
//Create an A object  
$a = $di->get('A');  
  
//Anywhere that asks for an instance D within the tree that existis within A will be given the same instance:  
//Both the B and C objects within the tree will share an instance of D  
var\_dumb($a->b->d === $a->c->d); //TRUE  
  
//However, create another instance of A and everything in this tree will get its own instance of D:  
  
$a2 = $di->get('A');  
var\_dumb($a2->b->d === $a2->c->d); //TRUE  
  
var\_dumb($a->b->d === $a2->b->d); //FALSE  
var\_dumb($a->c->d === $a2->c->d); //FALSE


$di->addRule('B', ['shared' => true]);  
$di->addRule('B', ['construct' => ['foo']]);


class A {  
  
}  
  
class B extends A {  
  
}


$di->addRule('A', ['shared' => true]);  
$di->addRule('B', ['construct' => ['foo']]);


$di->addRule('A', ['shared' => true]);  
$di->addRule('B', [  
    'construct' => 'foo'],  
    'shared' => false  
]);


$di['foo'] = 'bar';  
echo $di['foo'];


$container['session\_storage'] = function ($c) {  
    return new SessionStorage('SESSION\_ID');  
};  
  
$container['session'] = function ($c) {  
    return new Session($c['session\_storage']);  
};  
  
$session = $container['session']; //get the session object  
$session2 = $container['session']; //get the same session object  
var\_dump($session===$session2); //will show true


$container['session'] = $container->factory(function ($c) {  
    return new Session($c['session\_storage']);  
});  
$session = $container['session']; //get a session object  
$session2 = $container['session']; //get a new session object  
var\_dump($session===$session2); //will show false


$container['random\_func'] = $container->protect(function () {  
    return rand();  
});


$container['session\_storage'] = function ($c) {  
    return new $c['session\_storage\_class']($c['cookie\_name']);  
};  
  
$container->extend('session\_storage', function ($storage, $c) {  
    $storage->...();  
  
    return $storage;  
});


$di['zero'] = 'foo';  
$di['varname'] = 'bar';  
$di['dotted']['sub'] = 'Sub data accessible by dot';  
$di->defineClass('A', [  
    'construct' =>[  
        '$0'=>'zero',  
        '$assoc'=>'varname',  
        '$other'=>'dotted.sub',  
        'assoc2'=>'realvar',  
    ],  
    'call' =>[  
        'method'=>[  
            '$assoc'=>'varname',  
            '$other'=>'dotted.sub',  
        ]  
    ],  
]);


$di->addRule('A', [  
    'construct' =>[  
        'foo',  
        'assoc'=>'bar',  
        'assoc2'=>'realvar',  
        'other'=>'Sub data accessible by dot',  
    ],  
    'call' =>[  
        'method'=>[  
            'assoc'=>'bar'  
            'other'=>'Sub data accessible by dot',  
        ]  
    ],  
]);


  
return [  
    '$'=>  
        'db\_name'=>'mydb',  
        'db\_user'=>'me',  
        'db\_password'=>'@FuçK1ngP@ssW0rd',  
    ],  
    'rules'=>[  
        'MyPDO'=>[  
            '$name'=>'db\_name',  
            '$user'=>'db\_user',  
            '$pass'=>'db\_password',  
        ],  
    ],  
];


$di->loadPhp('/my/path/to/config.php');


$di->loadPhpMap([  
    '/path/to/default\_config.php',  
    '/path/to/config.php',  
]);


RedCat\\Strategy\\Di::load([  
    '/path/to/default\_config.php',  
    '/path/to/config.php',  
],true,'temp-path/to/myApplyConfig.svar');