Login   Register  
PHP Classes
elePHPant
Icontem

File: multiCache.examples.php

Recommend this page to a friend!
Stumble It! Stumble It! Bookmark in del.icio.us Bookmark in del.icio.us
  Classes of Emilis Dambauskas  >  multiCache  >  multiCache.examples.php  >  Download  
File: multiCache.examples.php
Role: Example script
Content type: text/plain
Description: Examples
Class: multiCache
Easy to use general purpose runtime cache.
Author: By
Last change:
Date: 2002-08-20 18:18
Size: 5,656 bytes
 

Contents

Class file image Download
<?php
/**
 * This file contains examples on using multiCache
 */

require_once('multiCache.php');
$cache = &new multiCache();

/**
 * First the most simple example with simple variables:
 */
echo "<h2>multiCache example1:</h2>\n";

$a 1;
echo 
"new \$a value: 1<br>";
$cache->add('myType''a'$a);
echo 
"a = $a<br>";

$a 2;
echo 
"new \$a value: 2<br>";
echo 
"a = $a<br>";
echo 
"a in cache: ".$cache->find('myType''a')."<br>";

$b = &$cache->find('myType''a');
echo 
"b = $b<br>";
$b 3;
echo 
"new \$b value: 3<br>";
echo 
"a = $a<br>";
echo 
"b = $b<br>";
echo 
"a in cache: ".$cache->find('myType''a')."<br>";

echo 
"<br><i>end of multiCache example 1</i><hr>\n";

/**
 * A more complex example on how to use multiCache with objects.
 * Situation: we have two fighter spaceships (SF-1 & SF-2) in our galaxy 
 * (Milky Way) and we need to transfer one spaceship to another nearest galaxy
 * - Andromeda.
 */

echo "<h2>multiCache example2:</h2>\n";

class 
spaceShip
{
    var 
$model;
    var 
$name;
    var 
$galaxy;
    
    
/**
     * Constructor method - called only every new object.
     */
    
function spaceShip($model$name$galaxy_name)
    {
        
// first we load cache as internal parameter for convenience.
        
$this->cache = &$GLOBALS['cache']; 
        
        
// We check if our object already exists in cache:
        // · get_class($this) returns 'spaceShip' - type of entity in cache
        // · $model.':'.$name is the unique key for this object
        
if (!$mcId $this->cache->exists(get_class($this), $model.':'.$name))
        {
            
// If the object doesn't exist in cache, we create a copy of it in cache
            // the copy should call method 'mcConstruct' (which is the real 
            // constructor) on itself.
            
$mcId $this->cache->add(get_class($this), $model.':'.$name$this'mcConstruct', array($model$name$galaxy_name));
        }    
        
        
// Now we certainly have a copy of the object in cache.
        // So we have to link current object's parameters to cache object's
        // parameters:
        
$this->model = &$this->cache->data[$mcId]->model;
        
$this->name = &$this->cache->data[$mcId]->name;
        
        
// We create parameters that are objects themselves separately.
        // This is because we can't link to the cache objects parameters that are
        // objects or we'll get a reference to reference - an empty object, that
        // will not be linked to the cache objects parameter.
        
$this->galaxy = &new galaxy($galaxy_name);
        
        return (
$this);
    } 
// end of constructor
    
    /**
     * Constructor method that is only called for the object copy in cache
     */
    
function mcConstruct($model$name$galaxy_name)
    {
        
// We fill parameters with correct values:
        
$this->model $model;
        
$this->name $name;
        
$this->galaxy = &new galaxy($galaxy_name);
        
// We also place the spaceship in the galaxy.
        
$this->galaxy->ships[$this->name] = $this;
    }
    
    
/**
     * This method transfers spaceship from one galaxy to another.
     */
    
function hyperspaceJump($galaxy_name)
    {
        unset(
$this->galaxy->ships[$this->name]);
        
$this->galaxy = &new galaxy($galaxy_name);
        
$this->galaxy->ships[$this->name] = $this;
    }
    
    
/**
     * The ship reports its model, name and galaxy it's in:
     */
    
function report()
    {
        echo 
"<HR>Ship $this->name reporting:<BR>
                    Model: 
$this->model<BR>
                    Location: "
.$this->galaxy->name."<HR>";
    }
// end of class spaceShip

class galaxy
{
    var 
$name;
    var 
$ships;
    
    
/**
     * Galaxy constructor - the situation is the same as with the ship.
     */
    
function galaxy($name)
    {
        
$this->cache = &$GLOBALS['cache'];
        
// The unique key for the galaxy is it's name:
        
if (!$mcId $this->cache->exists(get_class($this), $name))
        {
            
$mcId $this->cache->add(get_class($this), $name$this'mcConstruct', array($name));
        }    
        
        
$this->name = &$this->cache->data[$mcId]->name;
        
$this->ships = &$this->cache->data[$mcId]->ships;
        return (
$this);
    }
    
    
/**
     * Constructor function used for the object copy in cache.
     */
    
function mcConstruct($name)
    {
        
$this->cache = &$GLOBALS['cache'];
        
$this->name $name;
        
$this->ships = array();
    }
        
    function 
report()
    {
        echo 
"<bR>Ships in galaxy $this->name:<bR>";
        foreach (
$this->ships as $ship)
        {
            echo 
$ship->model." model ship ".$ship->name."<BR>\n";
        }
    }
// end of class galaxy


// We create two fighters:
$fighter1 = &new spaceShip('fighter''SF-1''Milky Way');
$fighter2 = &new spaceShip('fighter''SF-2''Milky Way');

// We create two galaxies. Actually 'Milky Way' will find itself in cache so
// $galaxy1 and $fighter1->galaxy are the same.
$galaxy1 = &new galaxy('Milky Way');
$galaxy2 = &new galaxy('Andromeda');

// FIghter #1 jumps from one galaxy into another:
$fighter1->hyperspaceJump('Andromeda');

// Now let's see the results:

$fighter1->report();
$fighter2->report();

$galaxy1->report();
$galaxy2->report();

/**
 * END COMMENTS ON EXAMPLE 2:
 * The whole procedure seems rather complicated, doesn't it?
 * The point is that PHP references is a mysterious and complicated thing.
 * multiCache allows accessing the cached object from it's constructor by
 * simply creating a copy of it, but keeping the internal parameters linked.
 * I borrowed the idea from rick_php_net@roundeye.net comment in the PHP
 * manual on page:
 * "References inside the constructor"
 * http://lt.php.net/manual/en/language.oop.newref.php
 * If you'll find this class helpfull - please let me know :]
 *
 *                                                 >>> Emilis 2002-08-20
 */
echo "<br><i>end of multiCache example 2</i><hr>\n";

?>