Login   Register  
PHP Classes
elePHPant
Icontem

File: session/class.oSession.php

Recommend this page to a friend!
Stumble It! Stumble It! Bookmark in del.icio.us Bookmark in del.icio.us
  Classes of Johan Barbier  >  SPL and Iterators  >  session/class.oSession.php  >  Download  
File: session/class.oSession.php
Role: Class source
Content type: text/plain
Description: oSession package
Class: SPL and Iterators
Implements several iterators using SPL
Author: By
Last change: Modifications
Date: 7 years ago
Size: 8,930 bytes
 

Contents

Class file image Download
<?php
/**
 * oSessionException extends Exception
 * @author johan <johan.barbier@gmail.com>
 * @version 20061205
 *
 */
class oSessionException extends Exception {

    
/**
     * Exception messages
     *
     */
    
const NAME_NOT_ALPHANUMERIC '{__NAME__} is not a valid session name: session name must be alphanumeric';
    const 
XML_FILE_NOT_EXISTS '{__FILE__} has not been found';
    const 
XML_LOADING_FAILED 'Failed to load {__FILE__}';
    const 
XML_EMPTY 'XML configuration is empty';
    const 
KEY_NOT_EXISTS '{__KEY__} is not a valid key';
    const 
TYPE_NOT_VALID '{__TYPE__} is not a valid type for {__KEY__}, must be {__VALIDTYPE__}';

    
/**
     * Constructor
     * Calls Exception constructor
     *
     * @param string $sMsg
     * @param integer $iCode
     */
    
public function __construct ($sMsg$iCode 0) {
        
parent::__construct ($sMsg$iCode);
    }
}

/**
 * oConf
 * @author johan <johan.barbier@gmail.com>
 * @version 20061205
 *
 */
class oConf {

    
/**
     * Array of configuration
     *
     * @var array
     */
    
protected $aConf;

    
/**
     * Read the xml configuration file and fills the aConf property with its contents
     *
     * @param string $sConfFileName (xml configuration filename)
     */
    
protected function setConf ($sConfFileName) {
        if (!
file_exists ($sConfFileName)) {
            throw new 
oUserException (str_replace ('{__FILE__}'$sConfFileNameoSessionException::XML_FILE_NOT_EXISTS));
        }
        if (!(
$oXml = @simplexml_load_file ($sConfFileName)) instanceof SimpleXMLElement) {
            throw new 
oUserException (str_replace ('{__FILE__}'$sConfFileNameoSessionException::XML_LOADING_FAILED));
        }
        foreach (
$oXml -> children () as $oNode) {
            if (empty (
$oNode)) {
                throw new 
oUserException (self::XML_EMPTY);
            }
            
$this -> aConf[(string)dom_import_simplexml($oNode) -> tagName] = (string)$oNode['type'];
        }
        
$this -> bHasConf true;
    }

    
/**
     * Gets the configuration
     *
     * @return array
     */
    
public function getConf () {
        if (
true === $this -> bHasConf) {
            return 
$this -> aConf;
        }
        return 
null;
    }
}

/**
 * oSessionIterator implements Iterator
 * @author johan <johan.barbier@gmail.com>
 * @version 20061205
 *
 */
class oSessionIterator implements Iterator {

    
/**
     * Array of session keys
     *
     * @var array
     */
    
private $aKeys;

    
/**
     * current key
     *
     * @var mixed
     */
    
private $mKey;

    
/**
     * oSession Iterator
     *
     * @var oSession object
     */
    
private $it;

    
/**
     * Constructor
     * Sets some parameters
     *
     * @param oSession $it
     */
    
public function __construct (oSession $it) {
        
$this -> it $it;
        
$this -> aKeys $this -> it -> getKeys ();
    }

    
/**
     * Reset the array of keys and sets current key
     *
     */
    
public function rewind () {
        
$this -> mKey reset ($this -> aKeys);
    }

    
/**
     * Returns current key
     *
     * @return mixed
     */
    
public function key () {
        return 
$this -> mKey;
    }

    
/**
     * Returns current value
     *
     * @return mixed
     */
    
public function current () {
        if (isset (
$this -> it[$this -> mKey])) {
            return 
$this -> it[$this -> mKey];
        }
        return 
null;
    }

    
/**
     * Gets next key
     *
     */
    
public function next () {
        
$this -> mKey next ($this -> aKeys);
    }

    
/**
     * Checks if current key is valid
     *
     * @return boolean
     */
    
public function valid () {
        if (isset (
$this -> it[$this -> mKey])) {
            return 
true;
        }
        return 
false;
    }
}

/**
 * oSession extends oConf implements IteratorAggregate, ArrayAccess, Countable
 * greatly inspired by PRADO framework <http://www.pradosoft.com/>
 * @author johan <johan.barbier@gmail.com>
 * @version 20061205
 *
 */
class oSession extends oConf implements IteratorAggregateArrayAccessCountable {

    
/**
     * Is the oSession initialized or not
     *
     * @var boolean
     */
    
private $bIsStarted false;

    
/**
     * oSession has a configuration file or not
     *
     * @var boolean
     */
    
protected $bHasConf false;

    
/**
     * Constructor
     * Checks configuration if any
     *
     * @param string $sConf Configuration filename
     */
    
public function __construct ($sConf null) {
        if (!
is_null ($sConf)) {
            
$this -> setConf ($sConf);
        }
    }

    
/**
     * Sets a new configuration file
     *
     * @param string $sConfFileName Configuration filename
     */
    
public function setNewConf ($sConfFileName) {
        
$this -> setConf ($sConfFileName);
    }

    
/**
     * Returns if oSession has a configuration or not
     *
     * @return boolean
     */
    
public function hasConf () {
        return 
$this -> bHasConf;
    }

    
/**
     * Starts a session
     *
     */
    
public function open () {
        if (
false === $this -> bIsStarted) {
            
$this -> bIsStarted true;
            
session_start ();
        }
    }

    
/**
     * Checks if an offset exists
     * ArrayAccess method
     *
     * @param mixed $mKey
     * @return boolean
     */
    
public function offsetExists ($mKey) {
        if (
true === $this -> bIsStarted && isset ($_SESSION[$mKey])) {
            return 
true;
        }
        return 
false;
    }

    
/**
     * Gets an offset
     * ArrayAccess method
     *
     * @param mixed $mKey
     * @return mixed
     */
    
public function offsetGet ($mKey) {
        if (
true === $this -> bIsStarted && isset ($_SESSION[$mKey])) {
            return 
$_SESSION[$mKey];
        }
        return 
null;
    }

    
/**
     * Sets an offset if valid (if there is a configuration)
     * ArrayAccess method
     *
     * @param mixed $mKey
     * @param mixed $mVal
     */
    
public function offsetSet ($mKey$mVal) {
        if (
true === $this -> bHasConf) {
            if (!isset (
$this -> aConf[$mKey])) {
                throw new 
oSessionException (str_replace ('{__KEY__}'$mKeyoSessionException::KEY_NOT_EXISTS));
            }
            if ((
$sType gettype ($mVal)) !== $this -> aConf[$mKey]) {
                throw new 
oSessionException (str_replace (array ('{__TYPE__}''{__KEY__}''{__VALIDTYPE__}'), array ($sType$mKey$this -> aConf[$mKey]), oSessionException::TYPE_NOT_VALID));
            }
        }
        
$_SESSION[$mKey] = $mVal;
    }

    
/**
     * Unset an offset
     * ArrayAccess method
     *
     * @param mixed $mKey
     */
    
public function offsetUnset ($mKey) {
        unset (
$_SESSION[$mKey]);
    }

    
/**
     * Returns the size of the current session
     * Countable method
     *
     * @return integer
     */
    
public function count () {
        if (
true === $this -> bIsStarted) {
            return 
count ($_SESSION);
        }
        return 
null;
    }

    
/**
     * Get the iterator of IteratorAggregation
     * IteratorAggregate method
     *
     * @return Iterator
     */
    
public function getIterator () {
        if (
true === $this -> bIsStarted) {
            return new 
oSessionIterator ($this);
        }
        return new 
ArrayIterator (array ());
    }

    
/**
     * Destroy current session
     *
     */
    
public function destroy () {
        if (
true === $this -> bIsStarted) {
            
session_destroy ();
            
$this -> bIsStarted false;
        }
    }

    
/**
     * Destroy totally current session (session, globals, cookie)
     *
     */
    
public function destroyAll () {
        
$this -> clear ();
        if (isset(
$_COOKIE[session_name()])) {
           
setcookie(session_name(), ''time()-42000'/');
        }
        
session_destroy ();
        
$this -> bIsStarted false;
    }

    
/**
     * Get session name
     *
     * @return string
     */
    
public function getName () {
        if (
true === $this -> bIsStarted) {
            return 
session_name ();
        }
        return 
null;
    }

    
/**
     * Set session name
     *
     * @param string $sName
     * @return string
     */
    
public function setName ($sName) {
        if (
true === $this -> bIsStarted) {
            if (!
ctype_alnum ($sName)) {
                throw new 
oSessionException (str_replace ('{__NAME__}'$sNameoSessionException::NAME_NOT_ALPHANUMERIC));
            }
            return 
session_name ($sName);
        }
        return 
null;
    }

    
/**
     * Returns an array with the session
     *
     * @return array
     */
    
public function asArray () {
        if (
true === $this -> bIsStarted) {
            return 
$_SESSION;
        } else {
            return 
null;
        }
    }

    
/**
     * Gets the session keys
     *
     * @return array
     */
    
public function getKeys () {
        if (
true === $this -> bIsStarted) {
            return 
array_keys ($_SESSION);
        } else {
            return 
null;
        }
    }

    
/**
     * Clear the current session keys and values
     *
     */
    
public function clear () {
        foreach (
array_keys ($_SESSION) as $mKey) {
            unset (
$_SESSION[$mKey]);
        }
    }

    
/**
     * Get session ID
     *
     * @return string
     */
    
public function getId () {
        if (
true === $this -> bIsStarted) {
            return 
session_id ();
        }
        return 
null;
    }

    
/**
     * Close a session
     *
     */
    
public function close () {
        if (
true === $this -> bIsStarted) {
            
session_write_close ();
        }
    }
}

/**
 * Testing
 */
ob_start ();
try {
    
$oSession = new oSession ('config.xml');
    
$oSession -> open ();
    
$oSession['ID'] = 666;
    echo 
$oSession['ID'];
    echo 
'<br />';
    echo 
$oSession -> getId ();
    echo 
'<br />';
    
$oSession -> destroy ();
    echo 
count ($oSession);
    foreach (
$oSession as $sKey => $mVal) {
        echo 
$sKey' => '$mVal'<br />';
    }
    
$oSession -> open ();
    
$oSession['NAME'] = 'test';
    echo 
'<br />';
    echo 
count ($oSession);
    echo 
'<br />';
    foreach (
$oSession as $sKey => $mVal) {
        echo 
$sKey' => '$mVal'<br />';
    }
    echo 
$oSession -> getName ();
    echo 
'<br />';
    echo 
$oSession -> getId ();
    echo 
'<br />';
    
$oSession -> setName (1245.5);
} catch (
Exception $e) {
    echo 
$e -> getMessage ();
}

ob_end_flush ();
?>