root/trunk/XJConf/XJConfFacade.php

<?php
/**
 * Facade for XJConf.
 *
 * @author      Frank Kleine <mikey@stubbles.net>
 * @package     XJConf
 */
namespace net::xjconf;
use net::xjconf::definitions::NamespaceDefinitions;
use net::xjconf::ext::Extension;
/**
 * Facade for XJConf.
 *
 * @package     XJConf
 */
class XJConfFacade
{
    /**
     * list of class loaders to use
     *
     * @var  array<string,XJConfClassLoader>
     */
    protected $classLoaders         = array();
    /**
     * list of extensions to use
     *
     * @var  array<string,Extension>
     */
    protected $extensions           = array();
    /**
     * list of namespace definitions to merge with default one
     *
     * @var  array<NamespaceDefinition>
     */
    protected $namespaceDefinitions = array();
    /**
     * the definition parser
     *
     * @var  DefinitionParser
     */
    protected $definitionParser;
    /**
     * the xml parser
     *
     * @var  XmlParser
     */
    protected $xmlParser;
    
    /**
     * construct the facade
     *
     * @param  array  $classLoaders<string,XJConfClassLoader>  optional  list of class loaders for given namespaces
     */
    public function __construct(array $classLoaders = array())
    {
        $this->classLoaders = $classLoaders;
    }

    /**
     * add an extension that handles all tags in given namespace
     *
     * @param  Extension  $ext        use this extension to handle all tags in given namespace
     * @param  string     $namespace  optional  handle all tags in this namespace with given extension
     */
    public function addExtension(Extension $ext, $namespace = null)
    {
        if (null == $namespace) {
            $namespace = $ext->getNamespace();
        }
        
        $this->extensions[$namespace] = $ext;
    }
    
    /**
     * enables xinclude
     */
    public function enableXIncludes()
    {
        $xincludeExtension = new net::xjeconf::ext::xinc::XInclude();
        $this->addExtension($xincludeExtension);
    }
    
    /**
     * add a namespace definition
     *
     * @param  NamespaceDefinition  $namespaceDefinition
     */
    public function addNamespaceDefinition(NamespaceDefinition $namespaceDefinition)
    {
        $this->namespaceDefinitions[$namespaceDefinition->getNamespaceURI()] = $namespaceDefinition;
    }
    
    /**
     * add a namespace definition
     *
     * @param  NamespaceDefinitions  $namespaceDefinitions
     */
    public function addNamespaceDefinitions(NamespaceDefinitions $namespaceDefinitions)
    {
        $this->namespaceDefinitions = array_merge($this->namespaceDefinitions, $namespaceDefinitions->getDefinedNamespaces());
    }
    
    /**
     * parses a definition and returns the namespace definitions
     *
     * @param   string                $definitionFile
     * @return  NamespaceDefinitions
     */
    public function parseDefinition($definitionFile)
    {
        if (null === $this->definitionParser) {
            $this->definitionParser = new DefinitionParser($this->classLoaders);
        }
        
        return $this->definitionParser->parse($definitionFile);
    }
    
    /**
     * parses a definition file and adds its definitions
     *
     * @param  string  $definitionFile
     */
    public function addDefinition($definitionFile)
    {
        $this->addNamespaceDefinitions($this->parseDefinition($definitionFile));
    }
    
    /**
     * parses a definition file and adds its definitions
     *
     * @param  array  $definitions
     */
    public function addDefinitions(array $definitions)
    {
        foreach ($definitions as $definition) {
            $this->addNamespaceDefinitions($this->parseDefinition($definition));
        }
    }
    
    /**
     * parses a given file and creates the data structure described in this file
     *
     * @param   string               $filename
     * @throws  stubXJConfException
     */
    public function parse($filename)
    {
        if (null === $this->xmlParser) {
            $this->xmlParser = new XmlParser();
        }
        
        $namespaceDefinitions = new NamespaceDefinitions();
        foreach ($this->namespaceDefinitions as $namespaceURI => $namespaceDefintion) {
            $namespaceDefinitions->addNamespaceDefinition($namespaceURI, $namespaceDefintion);
        }
        
        $this->xmlParser->setTagDefinitions($namespaceDefinitions);
        foreach ($this->extensions as $namespace => $extension) {
            $this->xmlParser->addExtension($extension, $namespace);
        }
        
        $this->xmlParser->parse($filename);
    }
    
    /**
     * checks whether a data structure associated with this name exists
     *
     * @param   string               $name
     * @return  bool
     * @throws  XJConfException
     */
    public function hasConfigValue($name)
    {
        if (null === $this->xmlParser) {
            throw new XJConfException('Invalid state: needs to parse first.');
        }
        
        return $this->xmlParser->hasConfigValue($name);
    }
    
    /**
     * returns the data structure associated with this name
     *
     * @param   string               $name
     * @return  mixed
     * @throws  XJConfException
     */
    public function getConfigValue($name)
    {
        if (null === $this->xmlParser) {
            throw new XJConfException('Invalid state: needs to parse first.');
        }
        
        return $this->xmlParser->getConfigValue($name);
    }
    
    /**
     * returns a list of all data structures
     *
     * @return  mixed
     * @throws  XJConfException
     */
    public function getConfigValues()
    {
        if (null === $this->xmlParser) {
            throw new XJConfException('Invalid state: needs to parse first.');
        }
        
        return $this->xmlParser->getConfigValues();
    }

    /**
     * clears parsed config values
     */
    public function clearConfigValues()
    {
        if (null == $this->xmlParser) {
            throw new XJConfException('Invalid state: needs to parse first.');
        }
        
        $this->xmlParser->clearConfigValues();
    }
}
?>