/**
  * Register a __ConfigurationProperty in cache for quickly access without know the route/level where the property
  *
  * @param __ConfigurationProperty $property
  */
 protected function registerProperty(__ConfigurationProperty &$property)
 {
     $property_name = $property->getName();
     if (!key_exists($property_name, $this->_registered_properties)) {
         $this->_registered_properties[$property->getName()] =& $property;
         __ConfigurationValueResolver::addSettingValue($property->getName(), $property->getContent());
     } else {
         if (!is_array($this->_registered_properties[$property_name])) {
             $stored_property =& $this->_registered_properties[$property_name];
             unset($this->_registered_properties[$property_name]);
             $this->_registered_properties[$property_name] = array($stored_property);
         }
         $this->_registered_properties[$property_name][] =& $property;
     }
 }
 public function &doProcess(__ConfigurationSection &$section)
 {
     //initialize the return value with all the filter chains for all the available routes:
     $return_value = array();
     $filter_sections = $section->getSections();
     foreach ($filter_sections as &$filter_section) {
         $filter_name = $filter_section->getAttribute('name');
         $filter_class = $filter_section->getAttribute('class');
         $filter = new $filter_class();
         if ($filter_section->hasAttribute('order')) {
             $filter->setOrder($filter_section->getAttribute('order'));
         }
         if ($filter_section->hasAttribute('execute-before-cache')) {
             $filter->setExecuteBeforeCache(__ConfigurationValueResolver::toBool($filter_section->getAttribute('execute-before-cache')));
         }
         if ($filter instanceof __IFilter) {
             $routes_to_apply_to = $filter_section->getSection('apply-to');
             if ($routes_to_apply_to != null) {
                 $routes_to_apply_to_sections = $routes_to_apply_to->getSections();
                 foreach ($routes_to_apply_to_sections as $route_section) {
                     switch (strtoupper($route_section->getName())) {
                         case 'ALL-ROUTES':
                             if (!key_exists('*', $return_value)) {
                                 $return_value['*'] = array();
                             }
                             $return_value['*'][] =& $filter;
                             break;
                         case 'ROUTE':
                             $route_id = $route_section->getAttribute('id');
                             if (!key_exists($route_id, $return_value)) {
                                 $return_value[$route_id] = new __FilterChain();
                             }
                             $filter_chain =& $return_value[$route_id];
                             $filter_chain->addFilter($filter);
                             unset($filter_chain);
                             break;
                     }
                 }
                 unset($routes_to_apply_to_sections);
             }
             unset($routes_to_apply_to);
         } else {
             throw __ExceptionFactory::getInstance()->createException('Unexpected class ' . get_class($filter) . '. A class implementing __IFilter was expected.');
         }
         unset($filter);
     }
     return $return_value;
 }
 /**
  * create a new instance according to the instance definition
  *
  * @param __ConfigurationSection $instance_definition
  */
 private function &_createInstanceDefinition(__ConfigurationSection $instance_config_section)
 {
     if ($instance_config_section->hasAttribute('id')) {
         $instance_id = $instance_config_section->getAttribute('id');
     } else {
         $instance_id = uniqid();
     }
     $instance_class = $instance_config_section->getAttribute('class');
     $instance_definition = new __InstanceDefinition($instance_id);
     $instance_definition->setClass($instance_class);
     if ($instance_config_section->hasAttribute('singleton')) {
         $instance_definition->setSingleton($instance_config_section->getAttribute('singleton'));
     }
     if ($instance_config_section->hasAttribute('scope')) {
         $instance_definition->setScope($instance_config_section->getAttribute('scope'));
     }
     if ($instance_config_section->hasAttribute('lazy-init')) {
         $instance_definition->setLazy(__ConfigurationValueResolver::toBool($instance_config_section->getAttribute('lazy-init')));
     } else {
         if ($instance_config_section->hasAttribute('lazy')) {
             $instance_definition->setLazy(__ConfigurationValueResolver::toBool($instance_config_section->getAttribute('lazy')));
         }
     }
     if ($instance_config_section->hasAttribute('startup-method')) {
         $instance_definition->setStartupMethod($instance_config_section->getAttribute('startup-method'));
     }
     if ($instance_config_section->hasAttribute('shutdown-method')) {
         $instance_definition->setShutdownMethod($instance_config_section->getAttribute('shutdown-method'));
     }
     if ($instance_config_section->hasAttribute('factory-method')) {
         $instance_definition->setFactoryMethod($instance_config_section->getAttribute('factory-method'));
     }
     if ($instance_config_section->hasAttribute('factory-instance')) {
         $instance_definition->setFactoryInstanceId($instance_config_section->getAttribute('factory-instance'));
     }
     $properties = $instance_config_section->getSections();
     foreach ($properties as &$property) {
         switch ($property->getName()) {
             case 'property':
                 $this->_parseProperty($property, $instance_definition);
                 break;
             case 'constructor-arg':
                 $this->_parseConstructorArgument($property, $instance_definition);
                 break;
         }
     }
     return $instance_definition;
 }
 protected function &_createRoute(__ConfigurationSection &$section)
 {
     $route = new __Route();
     $route->setId($section->getAttribute('id'));
     if ($section->hasAttribute('supercache')) {
         $route->setSuperCache(__ConfigurationValueResolver::toBool($section->getAttribute('supercache')));
     } else {
         if ($section->hasAttribute('cache')) {
             $route->setCache(__ConfigurationValueResolver::toBool($section->getAttribute('cache')));
         }
     }
     if ($section->hasAttribute('order')) {
         $route->setOrder($section->getAttribute('order'));
     }
     if ($section->hasAttribute('if-parameter')) {
         $route->setIfParameter($section->getAttribute('if-parameter'));
     }
     if ($section->hasAttribute('cache-ttl')) {
         $cache_ttl = $section->getAttribute('cache-ttl');
         if (is_numeric($cache_ttl)) {
             $cache_ttl = (int) $cache_ttl;
         }
         $route->setCacheTtl($cache_ttl);
     }
     if ($section->hasAttribute('only-ssl')) {
         $only_ssl = __ConfigurationValueResolver::toBool($section->getAttribute('only-ssl'));
         $route->setOnlySSL($only_ssl);
     }
     if ($section->hasAttribute('redirect-to')) {
         $route_to_redirect_to = $section->getAttribute('redirect-to');
         if ($section->hasAttribute('redirection-code')) {
             $redirection_code = $section->getAttribute('redirection-code');
         } else {
             $redirection_code = 302;
         }
         $route->setRouteToRedirectTo($route_to_redirect_to, $redirection_code);
     }
     $url_regular_expression = $section->getAttribute('uri-pattern');
     $route->setUrlPattern($url_regular_expression);
     $var_patterns = array();
     preg_match_all('/\\$[_A-Za-z][_A-Za-z0-9]*/', $url_regular_expression, $var_order);
     foreach ($var_order[0] as $varpattern_name) {
         $varpattern_section = $section->getSection('variable', null, array('name' => $varpattern_name));
         if ($varpattern_section != null) {
             $varpattern = $varpattern_section->getAttribute('var-pattern');
             $var_patterns[$varpattern_name] = $varpattern;
         }
     }
     $route->setVariablePatterns($var_patterns);
     $sub_sections = $section->getSections();
     foreach ($sub_sections as &$sub_section) {
         switch ($sub_section->getName()) {
             case 'parameter':
                 $route->addFixedParameter($sub_section->getAttribute('name'), $sub_section->getAttribute('value'));
                 break;
             case 'if-isset':
                 $variable = $sub_section->getAttribute('variable');
                 $parameter_sections = $sub_section->getSections();
                 $parameters = array();
                 foreach ($parameter_sections as $parameter_section) {
                     $parameters[$parameter_section->getAttribute('name')] = $parameter_section->getAttribute('value');
                 }
                 $route->addIfIssetCondition($variable, $parameters);
                 break;
             case 'if-equals':
                 $variable = $sub_section->getAttribute('variable');
                 $value = $sub_section->getAttribute('value');
                 $parameter_sections = $sub_section->getSections();
                 $parameters = array();
                 foreach ($parameter_sections as $parameter_section) {
                     $parameters[$parameter_section->getAttribute('name')] = $parameter_section->getAttribute('value');
                 }
                 $route->addIfEqualsCondition($variable, $value, $parameters);
                 break;
             case 'front-controller':
                 $route->setFrontControllerClass($sub_section->getAttribute('class'));
                 break;
             case 'flow':
                 $route->setFlowId($sub_section->getAttribute('id'));
                 break;
             case 'action':
                 $action_identity = new __ActionIdentity();
                 if ($sub_section->hasAttribute('controller')) {
                     $action_identity->setControllerCode($sub_section->getAttribute('controller'));
                 }
                 if ($sub_section->hasAttribute('code')) {
                     $action_identity->setActionCode($sub_section->getAttribute('code'));
                 } else {
                     if ($sub_section->hasAttribute('action')) {
                         $action_identity->setActionCode($sub_section->getAttribute('action'));
                     }
                 }
                 $route->setActionIdentity($action_identity);
                 break;
         }
     }
     //resolves route components before caching to avoid repeating this calculation on each request
     $route->resolveRouteComponents();
     return $route;
 }
 public function &_createModelServices(__ConfigurationSection &$section, $receiver_type, array $return_value)
 {
     if ($receiver_type == self::MODEL_RECEIVER_CLASS) {
         $receiver = $section->getAttribute('name');
     } else {
         $receiver = $section->getAttribute('id');
     }
     $subsections = $section->getSections();
     foreach ($subsections as $service_section) {
         switch (strtoupper($service_section->getName())) {
             case 'SERVICE':
                 $name = $service_section->getAttribute('name');
                 $class_method = $service_section->getAttribute('class-method');
                 $model_service_definition = new __ModelServiceDefinition($name);
                 if ($receiver_type == self::MODEL_RECEIVER_CLASS) {
                     $model_service_definition->setClass($receiver);
                 } else {
                     if ($receiver_type == self::MODEL_RECEIVER_INSTANCE) {
                         $model_service_definition->setInstance($receiver);
                     }
                 }
                 $model_service_definition->setService($class_method);
                 if ($service_section->hasAttribute('cache')) {
                     $model_service_definition->setCache(__ConfigurationValueResolver::toBool($service_section->getAttribute('cache')));
                 }
                 if ($service_section->hasAttribute('cache-ttl')) {
                     $model_service_definition->setCacheTtl($service_section->getAttribute('cache-ttl'));
                 }
                 if ($service_section->hasAttribute('remote')) {
                     $model_service_definition->setRemote($service_section->getAttribute('remote'));
                 }
                 $service_subsections = $service_section->getSections();
                 foreach ($service_subsections as &$service_subsection) {
                     switch (strtoupper($service_subsection->getName())) {
                         case 'PERMISSION':
                             $model_service_definition->setRequiredPermission($service_subsection->getAttribute('id'));
                             break;
                         case 'SERVICE-ARG':
                             $model_service_argument = new __ModelServiceArgument();
                             if ($service_subsection->hasAttribute('name')) {
                                 $model_service_argument->setName($service_subsection->getAttribute('name'));
                             } else {
                                 throw __ExceptionFactory::getInstance()->createException('Missing name attribute in model service argument definition: ' . $name);
                             }
                             if ($service_subsection->hasAttribute('index')) {
                                 $model_service_argument->setIndex($service_subsection->getAttribute('index'));
                             }
                             if ($service_subsection->hasAttribute('optional')) {
                                 $model_service_argument->setOptional(__ConfigurationValueResolver::toBool($service_subsection->getAttribute('optional')));
                             }
                             $model_service_definition->addArgument($model_service_argument);
                             unset($model_service_argument);
                             break;
                     }
                 }
                 if (key_exists($model_service_definition->getAlias(), $return_value)) {
                     throw new __ConfigurationException('Duplicate definition of model service: ' . $model_service_definition->getAlias());
                 } else {
                     $return_value[$model_service_definition->getAlias()] =& $model_service_definition;
                     unset($model_service_definition);
                 }
                 break;
         }
     }
     return $return_value;
 }
 protected function _parseValue($value, __ComplexConfigurationComponent &$configuration_component)
 {
     return __ConfigurationValueResolver::resolveValue($value);
 }
 protected function _parseValue($value)
 {
     return __ConfigurationValueResolver::resolveValue($value);
 }
 public function setRemote($remote)
 {
     $this->_remote = __ConfigurationValueResolver::resolveValue($remote);
 }