Zend FR

foreach($roles['role'] as $role) {
    // ...
}

Array
        (
            [name] => guide
            [label] => Guide
            [permissions] => 2,0,1,5:5,0:6,0,1,2
        )

<?php

class MZ_Config_Tools {

    public static function resetLevels(array $config) {
        
        $root = current($config);
        $rootKey = key($config);
        $key = key($root);
        
        if (!is_int($key)) {
            $config = array();
            $config[$rootKey][0] = $root;
        }
        
        return $config;
    }
}

$roles = MZ_Config_Tools::resetLevels($params->acl->roles->toArray());

Array
(
    [role] => Array
        (
            [0] => Array
                (
                    [name] => guide
                    [label] => Guide
                    [permissions] => 2,0,1,5:5,0:6,0,1,2
                )

        )

)

Array
(
    [role] => Array
        (
            [name] => guide
            [label] => Guide
            [permissions] => 2,0,1,5:5,0:6,0,1,2
        )

)

<?php
/**
 * Configuration de Fast
 * 
 * La classe Fast_Config sert à charger les fichiers de configuration de l'application.
 * 
 * Il en existe au moins trois :
 * 
 *  1 - environement.ini qui donne le nom des deux autres. Il est obligatoirement nommé ainsi 
 *      ou doit être fourni lors du chargement de l'application. Cela permet d'avoir plusieurs 
 *         configurations en fonction de l'environnement dans lequel s'exécute l'application 
 *         (en développement ou en recette par exemple).
 *     2 - le fichier désigné par la clef d'environement contient tous les éléments dépendants des 
 *         configurations évoquées ci-dessus.
 *  3 - Le fichier désigné par la clef parameters défini les paramètres qui ne changent pas 
 *         lorsqu'on porte l'application sur une autre plateforme.
 * 
 * Les formats de fichier acceptés sont ini et xml (voir la doc Zend_Config).
 * 
 * @author Jean-Yves Terrien
 */

Zend_Loader::loadClass('Fast_Registry');

class Fast_Config
{
   /**
    *  @function load() charge toute la config en fonction du fichier environnement.
    * 
    * @param $environment String|null Nom du fichier d'environnement
    * @return Fast_Config le contenu du fichier désigné par la clef d'environnement.
    */
   public static function load($environment = null)
   {

      // Initialise une base de registre
      Zend_Registry::setClassName('Fast_Registry');
      
      if ($environment == null) {
         Zend_Loader::loadClass('Fast_Exception_Config');
         throw new Fast_Exception_Config(Fast_Exception_Config::UNDEFINED_ENVIRONMENT_FILE);
      }

      Fast_Registry::setConfigPath(str_replace(chr(92), '/', dirname($environment).'/'));
      // recherche un fichier de config déterminant l'environnement de travail.
      $config = Fast_Config::getFile('setEnvironment', $environment);

      if(!isset($config->main->environment)) {
         Zend_Loader::loadClass('Fast_Exception_Config');
         throw new Fast_Exception_Config(Fast_Exception_Config::UNDEFINED_ENVIRONMENT);
      } else {
        //Chemin et nom du fichier de config
          $environnementFile = Fast_Registry::getConfigPath().$config->main->environment;
      }

      if(!isset($config->main->parameters)) {
         Zend_Loader::loadClass('Fast_Exception_Config');
         throw new Fast_Exception_Config(Fast_Exception_Config::UNDEFINED_PARAMETERS);
      } else {
          //Chemin et nom du fichier de paramètres
         $parametersFile = Fast_Registry::getConfigPath().$config->main->parameters;
      }
      // Recherche un fichier de configuration générale de l'application.
      $config = Fast_Config::getFile('setConfiguration', $environnementFile);
      #Fast_Debug::show('$config', $config);
      
      // Recherche un fichier de paramètres généraux de l'application.
      $params = Fast_Config::getFile('setParameters', $parametersFile);

      // Mode de débuggage
      if (isset($params->fast->debug)) {
         // charge la classe de débugage
         Zend_Loader::loadClass('Fast_Debug');
         Fast_Debug::displayDebug($params->fast->debug);
      }
      // Affichage des erreurs
      $display_errors = $config->debug->get('display_errors', false);
      if (ini_get('display_errors') != $display_errors) {
         // pas d'ini_set inutile, c'est gourmand !
         ini_set('display_errors', $display_errors);
      }
      // Niveau d'erreur (ne pas les afficher n'empêche pas de les loguer)
      // avec un niveau raisonnable d'alarme par défaut en prod
      // Le niveau peut être indiqué avec des opérateurs (ex. E_ALL ^ E_STRICT)
      $error_reporting = $config->debug->get('error_reporting', E_WARNING);
      if (!is_numeric($error_reporting)) {
         eval("error_reporting($error_reporting);");
      } else {
         error_reporting($error_reporting);
      }
      return $config;
   } // end function load
   
   /**
   * @function _getConfigFileType() détermine le type du fichier en fonction de son extension.
   * @param $file String Nom du fichier
   * @return String type du fichier (ini ou xml)
   */
   private static function _getConfigFileType($file) {
      preg_match('/.*\.(.*)$/',$file, $maches);
      // le fichier de config généralerale peut être de type 'ini' ou 'xml'.
      if ((!isset($maches[1]))||(isset($maches[1])&&strtolower($maches[1]) != 'ini' && strtolower($maches[1]) != 'xml')) {
         Zend_Loader::loadClass('Fast_Exception_Config');
         throw new Fast_Exception_Config(Fast_Exception_Config::UNKNOW_FILE_TYPE. $file);
      }
      return ucfirst(strtolower($maches[1]));
   }

   /**
   * @function loadFile() charge un fichier de configuration
   * @param $filename String nom du fichier
   * @return Fast_Config contenu du fichier.
   */
   public static function loadFile($filename) {
      $type = Fast_Config::_getConfigFileType($filename);
      if (is_readable($filename)) {
         // lecture de toutes les sections du fichier de config à l'aide
         // de la classe de lecture appropriée.
         $configClass = "Zend_Config_" . $type;
         Zend_Loader::loadClass($configClass);
         $config = new $configClass($filename, null);
         return $config;
      } else {
         Zend_Loader::loadClass('Fast_Exception_Config');
         throw new Fast_Exception_Config(Fast_Exception_Config::UNAVAILABLE_FILE.$filename);
      }
   }

   /**
   * @function getFile() place le contenu du fichier dans la base de registre
   * @param $method String nom de la méthode d'enregistrement dans la base.
   * @param $filename String nom du fichier
   * @return Fast_Config contenu du fichier.
   */
   public static function getFile($method, $file) {
      $filename = realpath($file);
      $config = Fast_Config::loadFile($filename);
      Fast_Registry::$method($config);
      return $config;
   } 
}

<?php
Zend_Loader::loadClass('Fast_Exception');
/**
 * Exception levée par la librairie Fast
 * Définit les exception de configuration de la library Fast
 * @see  Fast_Exception
 * @author Jean-Yves Terrien
 */
class Fast_Exception_Config extends Fast_Exception {
   const UNDEFINED_ENVIRONMENT = 'Undefined environment namespace';
   const UNDEFINED_PARAMETERS = 'Undefined parameters namespace';
   const UNKNOW_FILE_TYPE = 'Unknow file type: ';
   const UNAVAILABLE_FILE = 'Unanable to find file: ';
}

<?php
/**
 * Fast_Registry est une base de registre amméliorée pour travailler confointement avec
 * Fast_Config ainsi les éléments de configuration des fichier environment config et parameters
 * se retrouve dans des espaces séparé dans la base de registre avec des methode d'accès spécifiques.
 *     
 */
Zend_Loader::loadClass('Zend_Registry');
class Fast_Registry extends Zend_Registry
{
   /* nom interne des section */
   const ENVIRONMENT_VARNAME = '_environment';
   const CONFIG_VARNAME      = '_configuration';
   const PARAMS_VARNAME      = '_parameters';
   const CONFIGPATH_VARNAME  = '_configpath';

   /**
      @function getEnvironment()  retourne la définition de l'environment
      @return Fast_Registry
   */
   public static function getEnvironment()
   {
      return parent::get(self::ENVIRONMENT_VARNAME);
   }

   /**
      @function setEnvironment()  définit de l'environment
      @param Misc $env config data
      @return Fast_Registry
   */
   public static function setEnvironment($env)
   {
      return parent::set(self::ENVIRONMENT_VARNAME, $env);
   }

   /**
      @function getConfiguration()  retourne la définition de la configuration
      @return Fast_Registry
   */
   public static function getConfiguration()
   {
      return parent::get(self::CONFIG_VARNAME);
   }

   /**
      @function setConfiguration()  définit la configuration
      @param Misc $config Misc config data
      @return Fast_Registry
   */
   public static function setConfiguration($config)
   {
      return parent::set(self::CONFIG_VARNAME, $config);
   }

   /**
      @function getParameters()  retourne la définition des parametres
      @return Fast_Registry
   */
   public static function getParameters()
   {
      return parent::get(self::PARAMS_VARNAME);
   }

   /**
      @function setParameters()  définit les parametres
      @param Misc $config config data
      @return Fast_Registry
   */
   public static function setParameters($config)
   {
      return parent::set(self::PARAMS_VARNAME, $config);
   }

   public static function getConfigPath()
   {
      return parent::get(self::CONFIGPATH_VARNAME);
   }

   public static function setConfigPath($path)
   {
      return parent::set(self::CONFIGPATH_VARNAME, $path);
   }

   /**
    * Assigne une valeur à une entrée (une clé) du registre.
    *
    * Cette méthode surcharge la méthode de base et vérifie la syntaxe
    * de la clé de registre.
    *
    * @param string $key L'entrée ne doit pas être préfixée de '_', ces
    *    entrées étant réservées aux traitements internes de la librairie Fast.
    * @param mixed $value
    */
   public static function set($key, $value)
   {
      if ('_' == substr($key, 0, 1)) {
         Zend_Loader::loadClass('Fast_Exception_Registry');
         throw new Fast_Exception_Registry(Fast_Exception_Registry::UNAUTHORIZED_PRIVATE_KEY . $key);
      }
      parent::set($key, $value);
   }

}

<?php
Zend_Loader::loadClass('Fast_Exception');
/**
 * Exception levée par la librairie Fast
 * Définit les exception de base de registre de la library Fast
 * @see  Fast_Exception
 * @author Jean-Yves Terrien
 */
class Fast_Exception_Registry extends Fast_Exception {
   const UNAUTHORIZED_PRIVATE_KEY = 'Unauthorized private key: ';
}