Part of Slepp's ProjectsPastebinTURLImagebinFilebin
Feedback -- English French German Japanese
Create Upload Newest Tools Donate
Sign In | Create Account

Mine
Wednesday, August 8th, 2007 at 6:03:05pm MDT 

  1. Stack Trace
  2.  
  3.                
  4.  
  5.  
  6.    1.       at exception origin
  7.       in core.agavi_dir\controller\AgaviController.class.php line 109
  8.        106.     $maxExecutions = $this->getParameter('max_executions');
  9.  
  10.        107.     
  11.  
  12.        108.     if(++$this->numExecutions > $maxExecutions && $maxExecutions > 0) {
  13.  
  14.        109.
  15.                   throw new AgaviControllerException('Too many execution runs have been detected for this Context.');
  16.  
  17.        110.     }
  18.  
  19.        111.   }
  20.  
  21.        112.   
  22.  
  23.  
  24.    2.       at AgaviController->countExecution()
  25.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 196
  26.        193.     
  27.  
  28.        194.     $request = $this->context->getRequest();
  29.  
  30.        195.     
  31.  
  32.        196.
  33.                 $controller->countExecution();
  34.  
  35.        197.     
  36.  
  37.        198.     $moduleName = $this->getModuleName();
  38.  
  39.        199.     $actionName = $this->getActionName();
  40.  
  41.  
  42.    3.       at AgaviExecutionContainer->execute()
  43.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  44.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  45.  
  46.        418.             } else {
  47.  
  48.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  49.  
  50.        420.
  51.                           $slotResponse = $slotContainer->execute();
  52.  
  53.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  54.  
  55.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  56.  
  57.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  58.  
  59.  
  60.    4.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  61.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  62.         80.    */
  63.  
  64.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  65.  
  66.         82.   {
  67.  
  68.         83.
  69.                 $this->execute($filterChain, $container);
  70.  
  71.         84.   }
  72.  
  73.         85.   
  74.  
  75.         86.   /**
  76.  
  77.  
  78.    5.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  79.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  80.         91.       $filter = $this->chain[$this->index];
  81.  
  82.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  83.  
  84.         93.       if($count == 1) {
  85.  
  86.         94.
  87.                     $filter->executeOnce($this, $container);
  88.  
  89.         95.       } else {
  90.  
  91.         96.         $filter->execute($this, $container);
  92.  
  93.         97.       }
  94.  
  95.  
  96.    6.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  97.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  98.         61.     $replace = $this->getParameter('replace', false);
  99.  
  100.         62.     
  101.  
  102.         63.     $start = microtime(true);
  103.  
  104.         64.
  105.                 $filterChain->execute($container);
  106.  
  107.         65.     
  108.  
  109.         66.     $outputTypes = (array) $this->getParameter('output_types');
  110.  
  111.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  112.  
  113.  
  114.    7.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  115.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  116.         91.       $filter = $this->chain[$this->index];
  117.  
  118.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  119.  
  120.         93.       if($count == 1) {
  121.  
  122.         94.
  123.                     $filter->executeOnce($this, $container);
  124.  
  125.         95.       } else {
  126.  
  127.         96.         $filter->execute($this, $container);
  128.  
  129.         97.       }
  130.  
  131.  
  132.    8.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  133.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  134.        321.         $filterChain->register($controller->getFilter('execution'));
  135.  
  136.        322
  137.  
  138.        323.         // process the filter chain
  139.  
  140.        324.
  141.                     $filterChain->execute($this);
  142.  
  143.        325.       }
  144.  
  145.        326.       
  146.  
  147.        327.       // restore autoloads
  148.  
  149.  
  150.    9.       at AgaviExecutionContainer->execute()
  151.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  152.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  153.  
  154.        418.             } else {
  155.  
  156.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  157.  
  158.        420.
  159.                           $slotResponse = $slotContainer->execute();
  160.  
  161.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  162.  
  163.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  164.  
  165.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  166.  
  167.  
  168.   10.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  169.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  170.         80.    */
  171.  
  172.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  173.  
  174.         82.   {
  175.  
  176.         83.
  177.                 $this->execute($filterChain, $container);
  178.  
  179.         84.   }
  180.  
  181.         85.   
  182.  
  183.         86.   /**
  184.  
  185.  
  186.   11.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  187.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  188.         91.       $filter = $this->chain[$this->index];
  189.  
  190.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  191.  
  192.         93.       if($count == 1) {
  193.  
  194.         94.
  195.                     $filter->executeOnce($this, $container);
  196.  
  197.         95.       } else {
  198.  
  199.         96.         $filter->execute($this, $container);
  200.  
  201.         97.       }
  202.  
  203.  
  204.   12.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  205.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  206.         61.     $replace = $this->getParameter('replace', false);
  207.  
  208.         62.     
  209.  
  210.         63.     $start = microtime(true);
  211.  
  212.         64.
  213.                 $filterChain->execute($container);
  214.  
  215.         65.     
  216.  
  217.         66.     $outputTypes = (array) $this->getParameter('output_types');
  218.  
  219.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  220.  
  221.  
  222.   13.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  223.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  224.         91.       $filter = $this->chain[$this->index];
  225.  
  226.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  227.  
  228.         93.       if($count == 1) {
  229.  
  230.         94.
  231.                     $filter->executeOnce($this, $container);
  232.  
  233.         95.       } else {
  234.  
  235.         96.         $filter->execute($this, $container);
  236.  
  237.         97.       }
  238.  
  239.  
  240.   14.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  241.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  242.        321.         $filterChain->register($controller->getFilter('execution'));
  243.  
  244.        322
  245.  
  246.        323.         // process the filter chain
  247.  
  248.        324.
  249.                     $filterChain->execute($this);
  250.  
  251.        325.       }
  252.  
  253.        326.       
  254.  
  255.        327.       // restore autoloads
  256.  
  257.  
  258.   15.       at AgaviExecutionContainer->execute()
  259.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  260.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  261.  
  262.        418.             } else {
  263.  
  264.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  265.  
  266.        420.
  267.                           $slotResponse = $slotContainer->execute();
  268.  
  269.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  270.  
  271.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  272.  
  273.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  274.  
  275.  
  276.   16.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  277.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  278.         80.    */
  279.  
  280.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  281.  
  282.         82.   {
  283.  
  284.         83.
  285.                 $this->execute($filterChain, $container);
  286.  
  287.         84.   }
  288.  
  289.         85.   
  290.  
  291.         86.   /**
  292.  
  293.  
  294.   17.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  295.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  296.         91.       $filter = $this->chain[$this->index];
  297.  
  298.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  299.  
  300.         93.       if($count == 1) {
  301.  
  302.         94.
  303.                     $filter->executeOnce($this, $container);
  304.  
  305.         95.       } else {
  306.  
  307.         96.         $filter->execute($this, $container);
  308.  
  309.         97.       }
  310.  
  311.  
  312.   18.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  313.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  314.         61.     $replace = $this->getParameter('replace', false);
  315.  
  316.         62.     
  317.  
  318.         63.     $start = microtime(true);
  319.  
  320.         64.
  321.                 $filterChain->execute($container);
  322.  
  323.         65.     
  324.  
  325.         66.     $outputTypes = (array) $this->getParameter('output_types');
  326.  
  327.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  328.  
  329.  
  330.   19.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  331.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  332.         91.       $filter = $this->chain[$this->index];
  333.  
  334.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  335.  
  336.         93.       if($count == 1) {
  337.  
  338.         94.
  339.                     $filter->executeOnce($this, $container);
  340.  
  341.         95.       } else {
  342.  
  343.         96.         $filter->execute($this, $container);
  344.  
  345.         97.       }
  346.  
  347.  
  348.   20.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  349.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  350.        321.         $filterChain->register($controller->getFilter('execution'));
  351.  
  352.        322
  353.  
  354.        323.         // process the filter chain
  355.  
  356.        324.
  357.                     $filterChain->execute($this);
  358.  
  359.        325.       }
  360.  
  361.        326.       
  362.  
  363.        327.       // restore autoloads
  364.  
  365.  
  366.   21.       at AgaviExecutionContainer->execute()
  367.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  368.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  369.  
  370.        418.             } else {
  371.  
  372.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  373.  
  374.        420.
  375.                           $slotResponse = $slotContainer->execute();
  376.  
  377.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  378.  
  379.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  380.  
  381.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  382.  
  383.  
  384.   22.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  385.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  386.         80.    */
  387.  
  388.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  389.  
  390.         82.   {
  391.  
  392.         83.
  393.                 $this->execute($filterChain, $container);
  394.  
  395.         84.   }
  396.  
  397.         85.   
  398.  
  399.         86.   /**
  400.  
  401.  
  402.   23.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  403.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  404.         91.       $filter = $this->chain[$this->index];
  405.  
  406.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  407.  
  408.         93.       if($count == 1) {
  409.  
  410.         94.
  411.                     $filter->executeOnce($this, $container);
  412.  
  413.         95.       } else {
  414.  
  415.         96.         $filter->execute($this, $container);
  416.  
  417.         97.       }
  418.  
  419.  
  420.   24.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  421.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  422.         61.     $replace = $this->getParameter('replace', false);
  423.  
  424.         62.     
  425.  
  426.         63.     $start = microtime(true);
  427.  
  428.         64.
  429.                 $filterChain->execute($container);
  430.  
  431.         65.     
  432.  
  433.         66.     $outputTypes = (array) $this->getParameter('output_types');
  434.  
  435.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  436.  
  437.  
  438.   25.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  439.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  440.         91.       $filter = $this->chain[$this->index];
  441.  
  442.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  443.  
  444.         93.       if($count == 1) {
  445.  
  446.         94.
  447.                     $filter->executeOnce($this, $container);
  448.  
  449.         95.       } else {
  450.  
  451.         96.         $filter->execute($this, $container);
  452.  
  453.         97.       }
  454.  
  455.  
  456.   26.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  457.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  458.        321.         $filterChain->register($controller->getFilter('execution'));
  459.  
  460.        322
  461.  
  462.        323.         // process the filter chain
  463.  
  464.        324.
  465.                     $filterChain->execute($this);
  466.  
  467.        325.       }
  468.  
  469.        326.       
  470.  
  471.        327.       // restore autoloads
  472.  
  473.  
  474.   27.       at AgaviExecutionContainer->execute()
  475.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  476.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  477.  
  478.        418.             } else {
  479.  
  480.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  481.  
  482.        420.
  483.                           $slotResponse = $slotContainer->execute();
  484.  
  485.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  486.  
  487.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  488.  
  489.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  490.  
  491.  
  492.   28.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  493.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  494.         80.    */
  495.  
  496.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  497.  
  498.         82.   {
  499.  
  500.         83.
  501.                 $this->execute($filterChain, $container);
  502.  
  503.         84.   }
  504.  
  505.         85.   
  506.  
  507.         86.   /**
  508.  
  509.  
  510.   29.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  511.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  512.         91.       $filter = $this->chain[$this->index];
  513.  
  514.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  515.  
  516.         93.       if($count == 1) {
  517.  
  518.         94.
  519.                     $filter->executeOnce($this, $container);
  520.  
  521.         95.       } else {
  522.  
  523.         96.         $filter->execute($this, $container);
  524.  
  525.         97.       }
  526.  
  527.  
  528.   30.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  529.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  530.         61.     $replace = $this->getParameter('replace', false);
  531.  
  532.         62.     
  533.  
  534.         63.     $start = microtime(true);
  535.  
  536.         64.
  537.                 $filterChain->execute($container);
  538.  
  539.         65.     
  540.  
  541.         66.     $outputTypes = (array) $this->getParameter('output_types');
  542.  
  543.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  544.  
  545.  
  546.   31.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  547.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  548.         91.       $filter = $this->chain[$this->index];
  549.  
  550.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  551.  
  552.         93.       if($count == 1) {
  553.  
  554.         94.
  555.                     $filter->executeOnce($this, $container);
  556.  
  557.         95.       } else {
  558.  
  559.         96.         $filter->execute($this, $container);
  560.  
  561.         97.       }
  562.  
  563.  
  564.   32.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  565.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  566.        321.         $filterChain->register($controller->getFilter('execution'));
  567.  
  568.        322
  569.  
  570.        323.         // process the filter chain
  571.  
  572.        324.
  573.                     $filterChain->execute($this);
  574.  
  575.        325.       }
  576.  
  577.        326.       
  578.  
  579.        327.       // restore autoloads
  580.  
  581.  
  582.   33.       at AgaviExecutionContainer->execute()
  583.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  584.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  585.  
  586.        418.             } else {
  587.  
  588.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  589.  
  590.        420.
  591.                           $slotResponse = $slotContainer->execute();
  592.  
  593.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  594.  
  595.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  596.  
  597.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  598.  
  599.  
  600.   34.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  601.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  602.         80.    */
  603.  
  604.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  605.  
  606.         82.   {
  607.  
  608.         83.
  609.                 $this->execute($filterChain, $container);
  610.  
  611.         84.   }
  612.  
  613.         85.   
  614.  
  615.         86.   /**
  616.  
  617.  
  618.   35.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  619.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  620.         91.       $filter = $this->chain[$this->index];
  621.  
  622.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  623.  
  624.         93.       if($count == 1) {
  625.  
  626.         94.
  627.                     $filter->executeOnce($this, $container);
  628.  
  629.         95.       } else {
  630.  
  631.         96.         $filter->execute($this, $container);
  632.  
  633.         97.       }
  634.  
  635.  
  636.   36.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  637.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  638.         61.     $replace = $this->getParameter('replace', false);
  639.  
  640.         62.     
  641.  
  642.         63.     $start = microtime(true);
  643.  
  644.         64.
  645.                 $filterChain->execute($container);
  646.  
  647.         65.     
  648.  
  649.         66.     $outputTypes = (array) $this->getParameter('output_types');
  650.  
  651.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  652.  
  653.  
  654.   37.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  655.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  656.         91.       $filter = $this->chain[$this->index];
  657.  
  658.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  659.  
  660.         93.       if($count == 1) {
  661.  
  662.         94.
  663.                     $filter->executeOnce($this, $container);
  664.  
  665.         95.       } else {
  666.  
  667.         96.         $filter->execute($this, $container);
  668.  
  669.         97.       }
  670.  
  671.  
  672.   38.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  673.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  674.        321.         $filterChain->register($controller->getFilter('execution'));
  675.  
  676.        322
  677.  
  678.        323.         // process the filter chain
  679.  
  680.        324.
  681.                     $filterChain->execute($this);
  682.  
  683.        325.       }
  684.  
  685.        326.       
  686.  
  687.        327.       // restore autoloads
  688.  
  689.  
  690.   39.       at AgaviExecutionContainer->execute()
  691.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  692.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  693.  
  694.        418.             } else {
  695.  
  696.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  697.  
  698.        420.
  699.                           $slotResponse = $slotContainer->execute();
  700.  
  701.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  702.  
  703.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  704.  
  705.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  706.  
  707.  
  708.   40.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  709.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  710.         80.    */
  711.  
  712.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  713.  
  714.         82.   {
  715.  
  716.         83.
  717.                 $this->execute($filterChain, $container);
  718.  
  719.         84.   }
  720.  
  721.         85.   
  722.  
  723.         86.   /**
  724.  
  725.  
  726.   41.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  727.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  728.         91.       $filter = $this->chain[$this->index];
  729.  
  730.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  731.  
  732.         93.       if($count == 1) {
  733.  
  734.         94.
  735.                     $filter->executeOnce($this, $container);
  736.  
  737.         95.       } else {
  738.  
  739.         96.         $filter->execute($this, $container);
  740.  
  741.         97.       }
  742.  
  743.  
  744.   42.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  745.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  746.         61.     $replace = $this->getParameter('replace', false);
  747.  
  748.         62.     
  749.  
  750.         63.     $start = microtime(true);
  751.  
  752.         64.
  753.                 $filterChain->execute($container);
  754.  
  755.         65.     
  756.  
  757.         66.     $outputTypes = (array) $this->getParameter('output_types');
  758.  
  759.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  760.  
  761.  
  762.   43.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  763.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  764.         91.       $filter = $this->chain[$this->index];
  765.  
  766.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  767.  
  768.         93.       if($count == 1) {
  769.  
  770.         94.
  771.                     $filter->executeOnce($this, $container);
  772.  
  773.         95.       } else {
  774.  
  775.         96.         $filter->execute($this, $container);
  776.  
  777.         97.       }
  778.  
  779.  
  780.   44.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  781.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  782.        321.         $filterChain->register($controller->getFilter('execution'));
  783.  
  784.        322
  785.  
  786.        323.         // process the filter chain
  787.  
  788.        324.
  789.                     $filterChain->execute($this);
  790.  
  791.        325.       }
  792.  
  793.        326.       
  794.  
  795.        327.       // restore autoloads
  796.  
  797.  
  798.   45.       at AgaviExecutionContainer->execute()
  799.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  800.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  801.  
  802.        418.             } else {
  803.  
  804.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  805.  
  806.        420.
  807.                           $slotResponse = $slotContainer->execute();
  808.  
  809.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  810.  
  811.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  812.  
  813.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  814.  
  815.  
  816.   46.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  817.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  818.         80.    */
  819.  
  820.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  821.  
  822.         82.   {
  823.  
  824.         83.
  825.                 $this->execute($filterChain, $container);
  826.  
  827.         84.   }
  828.  
  829.         85.   
  830.  
  831.         86.   /**
  832.  
  833.  
  834.   47.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  835.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  836.         91.       $filter = $this->chain[$this->index];
  837.  
  838.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  839.  
  840.         93.       if($count == 1) {
  841.  
  842.         94.
  843.                     $filter->executeOnce($this, $container);
  844.  
  845.         95.       } else {
  846.  
  847.         96.         $filter->execute($this, $container);
  848.  
  849.         97.       }
  850.  
  851.  
  852.   48.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  853.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  854.         61.     $replace = $this->getParameter('replace', false);
  855.  
  856.         62.     
  857.  
  858.         63.     $start = microtime(true);
  859.  
  860.         64.
  861.                 $filterChain->execute($container);
  862.  
  863.         65.     
  864.  
  865.         66.     $outputTypes = (array) $this->getParameter('output_types');
  866.  
  867.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  868.  
  869.  
  870.   49.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  871.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  872.         91.       $filter = $this->chain[$this->index];
  873.  
  874.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  875.  
  876.         93.       if($count == 1) {
  877.  
  878.         94.
  879.                     $filter->executeOnce($this, $container);
  880.  
  881.         95.       } else {
  882.  
  883.         96.         $filter->execute($this, $container);
  884.  
  885.         97.       }
  886.  
  887.  
  888.   50.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  889.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  890.        321.         $filterChain->register($controller->getFilter('execution'));
  891.  
  892.        322
  893.  
  894.        323.         // process the filter chain
  895.  
  896.        324.
  897.                     $filterChain->execute($this);
  898.  
  899.        325.       }
  900.  
  901.        326.       
  902.  
  903.        327.       // restore autoloads
  904.  
  905.  
  906.   51.       at AgaviExecutionContainer->execute()
  907.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  908.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  909.  
  910.        418.             } else {
  911.  
  912.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  913.  
  914.        420.
  915.                           $slotResponse = $slotContainer->execute();
  916.  
  917.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  918.  
  919.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  920.  
  921.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  922.  
  923.  
  924.   52.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  925.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  926.         80.    */
  927.  
  928.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  929.  
  930.         82.   {
  931.  
  932.         83.
  933.                 $this->execute($filterChain, $container);
  934.  
  935.         84.   }
  936.  
  937.         85.   
  938.  
  939.         86.   /**
  940.  
  941.  
  942.   53.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  943.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  944.         91.       $filter = $this->chain[$this->index];
  945.  
  946.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  947.  
  948.         93.       if($count == 1) {
  949.  
  950.         94.
  951.                     $filter->executeOnce($this, $container);
  952.  
  953.         95.       } else {
  954.  
  955.         96.         $filter->execute($this, $container);
  956.  
  957.         97.       }
  958.  
  959.  
  960.   54.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  961.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  962.         61.     $replace = $this->getParameter('replace', false);
  963.  
  964.         62.     
  965.  
  966.         63.     $start = microtime(true);
  967.  
  968.         64.
  969.                 $filterChain->execute($container);
  970.  
  971.         65.     
  972.  
  973.         66.     $outputTypes = (array) $this->getParameter('output_types');
  974.  
  975.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  976.  
  977.  
  978.   55.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  979.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  980.         91.       $filter = $this->chain[$this->index];
  981.  
  982.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  983.  
  984.         93.       if($count == 1) {
  985.  
  986.         94.
  987.                     $filter->executeOnce($this, $container);
  988.  
  989.         95.       } else {
  990.  
  991.         96.         $filter->execute($this, $container);
  992.  
  993.         97.       }
  994.  
  995.  
  996.   56.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  997.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  998.        321.         $filterChain->register($controller->getFilter('execution'));
  999.  
  1000.        322
  1001.  
  1002.        323.         // process the filter chain
  1003.  
  1004.        324.
  1005.                     $filterChain->execute($this);
  1006.  
  1007.        325.       }
  1008.  
  1009.        326.       
  1010.  
  1011.        327.       // restore autoloads
  1012.  
  1013.  
  1014.   57.       at AgaviExecutionContainer->execute()
  1015.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  1016.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  1017.  
  1018.        418.             } else {
  1019.  
  1020.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  1021.  
  1022.        420.
  1023.                           $slotResponse = $slotContainer->execute();
  1024.  
  1025.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  1026.  
  1027.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  1028.  
  1029.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  1030.  
  1031.  
  1032.   58.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  1033.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  1034.         80.    */
  1035.  
  1036.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  1037.  
  1038.         82.   {
  1039.  
  1040.         83.
  1041.                 $this->execute($filterChain, $container);
  1042.  
  1043.         84.   }
  1044.  
  1045.         85.   
  1046.  
  1047.         86.   /**
  1048.  
  1049.  
  1050.   59.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  1051.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  1052.         91.       $filter = $this->chain[$this->index];
  1053.  
  1054.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  1055.  
  1056.         93.       if($count == 1) {
  1057.  
  1058.         94.
  1059.                     $filter->executeOnce($this, $container);
  1060.  
  1061.         95.       } else {
  1062.  
  1063.         96.         $filter->execute($this, $container);
  1064.  
  1065.         97.       }
  1066.  
  1067.  
  1068.   60.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  1069.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  1070.         61.     $replace = $this->getParameter('replace', false);
  1071.  
  1072.         62.     
  1073.  
  1074.         63.     $start = microtime(true);
  1075.  
  1076.         64.
  1077.                 $filterChain->execute($container);
  1078.  
  1079.         65.     
  1080.  
  1081.         66.     $outputTypes = (array) $this->getParameter('output_types');
  1082.  
  1083.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  1084.  
  1085.  
  1086.   61.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  1087.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  1088.         91.       $filter = $this->chain[$this->index];
  1089.  
  1090.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  1091.  
  1092.         93.       if($count == 1) {
  1093.  
  1094.         94.
  1095.                     $filter->executeOnce($this, $container);
  1096.  
  1097.         95.       } else {
  1098.  
  1099.         96.         $filter->execute($this, $container);
  1100.  
  1101.         97.       }
  1102.  
  1103.  
  1104.   62.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  1105.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  1106.        321.         $filterChain->register($controller->getFilter('execution'));
  1107.  
  1108.        322
  1109.  
  1110.        323.         // process the filter chain
  1111.  
  1112.        324.
  1113.                     $filterChain->execute($this);
  1114.  
  1115.        325.       }
  1116.  
  1117.        326.       
  1118.  
  1119.        327.       // restore autoloads
  1120.  
  1121.  
  1122.   63.       at AgaviExecutionContainer->execute()
  1123.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  1124.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  1125.  
  1126.        418.             } else {
  1127.  
  1128.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  1129.  
  1130.        420.
  1131.                           $slotResponse = $slotContainer->execute();
  1132.  
  1133.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  1134.  
  1135.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  1136.  
  1137.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  1138.  
  1139.  
  1140.   64.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  1141.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  1142.         80.    */
  1143.  
  1144.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  1145.  
  1146.         82.   {
  1147.  
  1148.         83.
  1149.                 $this->execute($filterChain, $container);
  1150.  
  1151.         84.   }
  1152.  
  1153.         85.   
  1154.  
  1155.         86.   /**
  1156.  
  1157.  
  1158.   65.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  1159.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  1160.         91.       $filter = $this->chain[$this->index];
  1161.  
  1162.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  1163.  
  1164.         93.       if($count == 1) {
  1165.  
  1166.         94.
  1167.                     $filter->executeOnce($this, $container);
  1168.  
  1169.         95.       } else {
  1170.  
  1171.         96.         $filter->execute($this, $container);
  1172.  
  1173.         97.       }
  1174.  
  1175.  
  1176.   66.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  1177.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  1178.         61.     $replace = $this->getParameter('replace', false);
  1179.  
  1180.         62.     
  1181.  
  1182.         63.     $start = microtime(true);
  1183.  
  1184.         64.
  1185.                 $filterChain->execute($container);
  1186.  
  1187.         65.     
  1188.  
  1189.         66.     $outputTypes = (array) $this->getParameter('output_types');
  1190.  
  1191.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  1192.  
  1193.  
  1194.   67.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  1195.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  1196.         91.       $filter = $this->chain[$this->index];
  1197.  
  1198.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  1199.  
  1200.         93.       if($count == 1) {
  1201.  
  1202.         94.
  1203.                     $filter->executeOnce($this, $container);
  1204.  
  1205.         95.       } else {
  1206.  
  1207.         96.         $filter->execute($this, $container);
  1208.  
  1209.         97.       }
  1210.  
  1211.  
  1212.   68.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  1213.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  1214.        321.         $filterChain->register($controller->getFilter('execution'));
  1215.  
  1216.        322
  1217.  
  1218.        323.         // process the filter chain
  1219.  
  1220.        324.
  1221.                     $filterChain->execute($this);
  1222.  
  1223.        325.       }
  1224.  
  1225.        326.       
  1226.  
  1227.        327.       // restore autoloads
  1228.  
  1229.  
  1230.   69.       at AgaviExecutionContainer->execute()
  1231.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  1232.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  1233.  
  1234.        418.             } else {
  1235.  
  1236.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  1237.  
  1238.        420.
  1239.                           $slotResponse = $slotContainer->execute();
  1240.  
  1241.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  1242.  
  1243.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  1244.  
  1245.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  1246.  
  1247.  
  1248.   70.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  1249.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  1250.         80.    */
  1251.  
  1252.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  1253.  
  1254.         82.   {
  1255.  
  1256.         83.
  1257.                 $this->execute($filterChain, $container);
  1258.  
  1259.         84.   }
  1260.  
  1261.         85.   
  1262.  
  1263.         86.   /**
  1264.  
  1265.  
  1266.   71.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  1267.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  1268.         91.       $filter = $this->chain[$this->index];
  1269.  
  1270.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  1271.  
  1272.         93.       if($count == 1) {
  1273.  
  1274.         94.
  1275.                     $filter->executeOnce($this, $container);
  1276.  
  1277.         95.       } else {
  1278.  
  1279.         96.         $filter->execute($this, $container);
  1280.  
  1281.         97.       }
  1282.  
  1283.  
  1284.   72.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  1285.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  1286.         61.     $replace = $this->getParameter('replace', false);
  1287.  
  1288.         62.     
  1289.  
  1290.         63.     $start = microtime(true);
  1291.  
  1292.         64.
  1293.                 $filterChain->execute($container);
  1294.  
  1295.         65.     
  1296.  
  1297.         66.     $outputTypes = (array) $this->getParameter('output_types');
  1298.  
  1299.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  1300.  
  1301.  
  1302.   73.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  1303.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  1304.         91.       $filter = $this->chain[$this->index];
  1305.  
  1306.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  1307.  
  1308.         93.       if($count == 1) {
  1309.  
  1310.         94.
  1311.                     $filter->executeOnce($this, $container);
  1312.  
  1313.         95.       } else {
  1314.  
  1315.         96.         $filter->execute($this, $container);
  1316.  
  1317.         97.       }
  1318.  
  1319.  
  1320.   74.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  1321.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  1322.        321.         $filterChain->register($controller->getFilter('execution'));
  1323.  
  1324.        322
  1325.  
  1326.        323.         // process the filter chain
  1327.  
  1328.        324.
  1329.                     $filterChain->execute($this);
  1330.  
  1331.        325.       }
  1332.  
  1333.        326.       
  1334.  
  1335.        327.       // restore autoloads
  1336.  
  1337.  
  1338.   75.       at AgaviExecutionContainer->execute()
  1339.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  1340.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  1341.  
  1342.        418.             } else {
  1343.  
  1344.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  1345.  
  1346.        420.
  1347.                           $slotResponse = $slotContainer->execute();
  1348.  
  1349.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  1350.  
  1351.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  1352.  
  1353.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  1354.  
  1355.  
  1356.   76.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  1357.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  1358.         80.    */
  1359.  
  1360.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  1361.  
  1362.         82.   {
  1363.  
  1364.         83.
  1365.                 $this->execute($filterChain, $container);
  1366.  
  1367.         84.   }
  1368.  
  1369.         85.   
  1370.  
  1371.         86.   /**
  1372.  
  1373.  
  1374.   77.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  1375.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  1376.         91.       $filter = $this->chain[$this->index];
  1377.  
  1378.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  1379.  
  1380.         93.       if($count == 1) {
  1381.  
  1382.         94.
  1383.                     $filter->executeOnce($this, $container);
  1384.  
  1385.         95.       } else {
  1386.  
  1387.         96.         $filter->execute($this, $container);
  1388.  
  1389.         97.       }
  1390.  
  1391.  
  1392.   78.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  1393.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  1394.         61.     $replace = $this->getParameter('replace', false);
  1395.  
  1396.         62.     
  1397.  
  1398.         63.     $start = microtime(true);
  1399.  
  1400.         64.
  1401.                 $filterChain->execute($container);
  1402.  
  1403.         65.     
  1404.  
  1405.         66.     $outputTypes = (array) $this->getParameter('output_types');
  1406.  
  1407.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  1408.  
  1409.  
  1410.   79.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  1411.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  1412.         91.       $filter = $this->chain[$this->index];
  1413.  
  1414.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  1415.  
  1416.         93.       if($count == 1) {
  1417.  
  1418.         94.
  1419.                     $filter->executeOnce($this, $container);
  1420.  
  1421.         95.       } else {
  1422.  
  1423.         96.         $filter->execute($this, $container);
  1424.  
  1425.         97.       }
  1426.  
  1427.  
  1428.   80.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  1429.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  1430.        321.         $filterChain->register($controller->getFilter('execution'));
  1431.  
  1432.        322
  1433.  
  1434.        323.         // process the filter chain
  1435.  
  1436.        324.
  1437.                     $filterChain->execute($this);
  1438.  
  1439.        325.       }
  1440.  
  1441.        326.       
  1442.  
  1443.        327.       // restore autoloads
  1444.  
  1445.  
  1446.   81.       at AgaviExecutionContainer->execute()
  1447.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  1448.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  1449.  
  1450.        418.             } else {
  1451.  
  1452.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  1453.  
  1454.        420.
  1455.                           $slotResponse = $slotContainer->execute();
  1456.  
  1457.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  1458.  
  1459.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  1460.  
  1461.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  1462.  
  1463.  
  1464.   82.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  1465.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  1466.         80.    */
  1467.  
  1468.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  1469.  
  1470.         82.   {
  1471.  
  1472.         83.
  1473.                 $this->execute($filterChain, $container);
  1474.  
  1475.         84.   }
  1476.  
  1477.         85.   
  1478.  
  1479.         86.   /**
  1480.  
  1481.  
  1482.   83.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  1483.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  1484.         91.       $filter = $this->chain[$this->index];
  1485.  
  1486.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  1487.  
  1488.         93.       if($count == 1) {
  1489.  
  1490.         94.
  1491.                     $filter->executeOnce($this, $container);
  1492.  
  1493.         95.       } else {
  1494.  
  1495.         96.         $filter->execute($this, $container);
  1496.  
  1497.         97.       }
  1498.  
  1499.  
  1500.   84.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  1501.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  1502.         61.     $replace = $this->getParameter('replace', false);
  1503.  
  1504.         62.     
  1505.  
  1506.         63.     $start = microtime(true);
  1507.  
  1508.         64.
  1509.                 $filterChain->execute($container);
  1510.  
  1511.         65.     
  1512.  
  1513.         66.     $outputTypes = (array) $this->getParameter('output_types');
  1514.  
  1515.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  1516.  
  1517.  
  1518.   85.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  1519.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  1520.         91.       $filter = $this->chain[$this->index];
  1521.  
  1522.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  1523.  
  1524.         93.       if($count == 1) {
  1525.  
  1526.         94.
  1527.                     $filter->executeOnce($this, $container);
  1528.  
  1529.         95.       } else {
  1530.  
  1531.         96.         $filter->execute($this, $container);
  1532.  
  1533.         97.       }
  1534.  
  1535.  
  1536.   86.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  1537.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  1538.        321.         $filterChain->register($controller->getFilter('execution'));
  1539.  
  1540.        322
  1541.  
  1542.        323.         // process the filter chain
  1543.  
  1544.        324.
  1545.                     $filterChain->execute($this);
  1546.  
  1547.        325.       }
  1548.  
  1549.        326.       
  1550.  
  1551.        327.       // restore autoloads
  1552.  
  1553.  
  1554.   87.       at AgaviExecutionContainer->execute()
  1555.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  1556.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  1557.  
  1558.        418.             } else {
  1559.  
  1560.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  1561.  
  1562.        420.
  1563.                           $slotResponse = $slotContainer->execute();
  1564.  
  1565.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  1566.  
  1567.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  1568.  
  1569.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  1570.  
  1571.  
  1572.   88.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  1573.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  1574.         80.    */
  1575.  
  1576.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  1577.  
  1578.         82.   {
  1579.  
  1580.         83.
  1581.                 $this->execute($filterChain, $container);
  1582.  
  1583.         84.   }
  1584.  
  1585.         85.   
  1586.  
  1587.         86.   /**
  1588.  
  1589.  
  1590.   89.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  1591.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  1592.         91.       $filter = $this->chain[$this->index];
  1593.  
  1594.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  1595.  
  1596.         93.       if($count == 1) {
  1597.  
  1598.         94.
  1599.                     $filter->executeOnce($this, $container);
  1600.  
  1601.         95.       } else {
  1602.  
  1603.         96.         $filter->execute($this, $container);
  1604.  
  1605.         97.       }
  1606.  
  1607.  
  1608.   90.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  1609.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  1610.         61.     $replace = $this->getParameter('replace', false);
  1611.  
  1612.         62.     
  1613.  
  1614.         63.     $start = microtime(true);
  1615.  
  1616.         64.
  1617.                 $filterChain->execute($container);
  1618.  
  1619.         65.     
  1620.  
  1621.         66.     $outputTypes = (array) $this->getParameter('output_types');
  1622.  
  1623.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  1624.  
  1625.  
  1626.   91.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  1627.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  1628.         91.       $filter = $this->chain[$this->index];
  1629.  
  1630.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  1631.  
  1632.         93.       if($count == 1) {
  1633.  
  1634.         94.
  1635.                     $filter->executeOnce($this, $container);
  1636.  
  1637.         95.       } else {
  1638.  
  1639.         96.         $filter->execute($this, $container);
  1640.  
  1641.         97.       }
  1642.  
  1643.  
  1644.   92.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  1645.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  1646.        321.         $filterChain->register($controller->getFilter('execution'));
  1647.  
  1648.        322
  1649.  
  1650.        323.         // process the filter chain
  1651.  
  1652.        324.
  1653.                     $filterChain->execute($this);
  1654.  
  1655.        325.       }
  1656.  
  1657.        326.       
  1658.  
  1659.        327.       // restore autoloads
  1660.  
  1661.  
  1662.   93.       at AgaviExecutionContainer->execute()
  1663.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  1664.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  1665.  
  1666.        418.             } else {
  1667.  
  1668.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  1669.  
  1670.        420.
  1671.                           $slotResponse = $slotContainer->execute();
  1672.  
  1673.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  1674.  
  1675.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  1676.  
  1677.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  1678.  
  1679.  
  1680.   94.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  1681.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  1682.         80.    */
  1683.  
  1684.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  1685.  
  1686.         82.   {
  1687.  
  1688.         83.
  1689.                 $this->execute($filterChain, $container);
  1690.  
  1691.         84.   }
  1692.  
  1693.         85.   
  1694.  
  1695.         86.   /**
  1696.  
  1697.  
  1698.   95.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  1699.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  1700.         91.       $filter = $this->chain[$this->index];
  1701.  
  1702.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  1703.  
  1704.         93.       if($count == 1) {
  1705.  
  1706.         94.
  1707.                     $filter->executeOnce($this, $container);
  1708.  
  1709.         95.       } else {
  1710.  
  1711.         96.         $filter->execute($this, $container);
  1712.  
  1713.         97.       }
  1714.  
  1715.  
  1716.   96.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  1717.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  1718.         61.     $replace = $this->getParameter('replace', false);
  1719.  
  1720.         62.     
  1721.  
  1722.         63.     $start = microtime(true);
  1723.  
  1724.         64.
  1725.                 $filterChain->execute($container);
  1726.  
  1727.         65.     
  1728.  
  1729.         66.     $outputTypes = (array) $this->getParameter('output_types');
  1730.  
  1731.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  1732.  
  1733.  
  1734.   97.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  1735.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  1736.         91.       $filter = $this->chain[$this->index];
  1737.  
  1738.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  1739.  
  1740.         93.       if($count == 1) {
  1741.  
  1742.         94.
  1743.                     $filter->executeOnce($this, $container);
  1744.  
  1745.         95.       } else {
  1746.  
  1747.         96.         $filter->execute($this, $container);
  1748.  
  1749.         97.       }
  1750.  
  1751.  
  1752.   98.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  1753.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  1754.        321.         $filterChain->register($controller->getFilter('execution'));
  1755.  
  1756.        322
  1757.  
  1758.        323.         // process the filter chain
  1759.  
  1760.        324.
  1761.                     $filterChain->execute($this);
  1762.  
  1763.        325.       }
  1764.  
  1765.        326.       
  1766.  
  1767.        327.       // restore autoloads
  1768.  
  1769.  
  1770.   99.       at AgaviExecutionContainer->execute()
  1771.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  1772.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  1773.  
  1774.        418.             } else {
  1775.  
  1776.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  1777.  
  1778.        420.
  1779.                           $slotResponse = $slotContainer->execute();
  1780.  
  1781.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  1782.  
  1783.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  1784.  
  1785.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  1786.  
  1787.  
  1788.  100.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  1789.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  1790.         80.    */
  1791.  
  1792.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  1793.  
  1794.         82.   {
  1795.  
  1796.         83.
  1797.                 $this->execute($filterChain, $container);
  1798.  
  1799.         84.   }
  1800.  
  1801.         85.   
  1802.  
  1803.         86.   /**
  1804.  
  1805.  
  1806.  101.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  1807.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  1808.         91.       $filter = $this->chain[$this->index];
  1809.  
  1810.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  1811.  
  1812.         93.       if($count == 1) {
  1813.  
  1814.         94.
  1815.                     $filter->executeOnce($this, $container);
  1816.  
  1817.         95.       } else {
  1818.  
  1819.         96.         $filter->execute($this, $container);
  1820.  
  1821.         97.       }
  1822.  
  1823.  
  1824.  102.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  1825.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  1826.         61.     $replace = $this->getParameter('replace', false);
  1827.  
  1828.         62.     
  1829.  
  1830.         63.     $start = microtime(true);
  1831.  
  1832.         64.
  1833.                 $filterChain->execute($container);
  1834.  
  1835.         65.     
  1836.  
  1837.         66.     $outputTypes = (array) $this->getParameter('output_types');
  1838.  
  1839.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  1840.  
  1841.  
  1842.  103.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  1843.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  1844.         91.       $filter = $this->chain[$this->index];
  1845.  
  1846.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  1847.  
  1848.         93.       if($count == 1) {
  1849.  
  1850.         94.
  1851.                     $filter->executeOnce($this, $container);
  1852.  
  1853.         95.       } else {
  1854.  
  1855.         96.         $filter->execute($this, $container);
  1856.  
  1857.         97.       }
  1858.  
  1859.  
  1860.  104.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  1861.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  1862.        321.         $filterChain->register($controller->getFilter('execution'));
  1863.  
  1864.        322
  1865.  
  1866.        323.         // process the filter chain
  1867.  
  1868.        324.
  1869.                     $filterChain->execute($this);
  1870.  
  1871.        325.       }
  1872.  
  1873.        326.       
  1874.  
  1875.        327.       // restore autoloads
  1876.  
  1877.  
  1878.  105.       at AgaviExecutionContainer->execute()
  1879.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  1880.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  1881.  
  1882.        418.             } else {
  1883.  
  1884.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  1885.  
  1886.        420.
  1887.                           $slotResponse = $slotContainer->execute();
  1888.  
  1889.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  1890.  
  1891.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  1892.  
  1893.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  1894.  
  1895.  
  1896.  106.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  1897.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  1898.         80.    */
  1899.  
  1900.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  1901.  
  1902.         82.   {
  1903.  
  1904.         83.
  1905.                 $this->execute($filterChain, $container);
  1906.  
  1907.         84.   }
  1908.  
  1909.         85.   
  1910.  
  1911.         86.   /**
  1912.  
  1913.  
  1914.  107.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  1915.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  1916.         91.       $filter = $this->chain[$this->index];
  1917.  
  1918.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  1919.  
  1920.         93.       if($count == 1) {
  1921.  
  1922.         94.
  1923.                     $filter->executeOnce($this, $container);
  1924.  
  1925.         95.       } else {
  1926.  
  1927.         96.         $filter->execute($this, $container);
  1928.  
  1929.         97.       }
  1930.  
  1931.  
  1932.  108.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  1933.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  1934.         61.     $replace = $this->getParameter('replace', false);
  1935.  
  1936.         62.     
  1937.  
  1938.         63.     $start = microtime(true);
  1939.  
  1940.         64.
  1941.                 $filterChain->execute($container);
  1942.  
  1943.         65.     
  1944.  
  1945.         66.     $outputTypes = (array) $this->getParameter('output_types');
  1946.  
  1947.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  1948.  
  1949.  
  1950.  109.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  1951.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  1952.         91.       $filter = $this->chain[$this->index];
  1953.  
  1954.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  1955.  
  1956.         93.       if($count == 1) {
  1957.  
  1958.         94.
  1959.                     $filter->executeOnce($this, $container);
  1960.  
  1961.         95.       } else {
  1962.  
  1963.         96.         $filter->execute($this, $container);
  1964.  
  1965.         97.       }
  1966.  
  1967.  
  1968.  110.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  1969.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  1970.        321.         $filterChain->register($controller->getFilter('execution'));
  1971.  
  1972.        322
  1973.  
  1974.        323.         // process the filter chain
  1975.  
  1976.        324.
  1977.                     $filterChain->execute($this);
  1978.  
  1979.        325.       }
  1980.  
  1981.        326.       
  1982.  
  1983.        327.       // restore autoloads
  1984.  
  1985.  
  1986.  111.       at AgaviExecutionContainer->execute()
  1987.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  1988.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  1989.  
  1990.        418.             } else {
  1991.  
  1992.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  1993.  
  1994.        420.
  1995.                           $slotResponse = $slotContainer->execute();
  1996.  
  1997.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  1998.  
  1999.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  2000.  
  2001.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  2002.  
  2003.  
  2004.  112.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  2005.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  2006.         80.    */
  2007.  
  2008.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  2009.  
  2010.         82.   {
  2011.  
  2012.         83.
  2013.                 $this->execute($filterChain, $container);
  2014.  
  2015.         84.   }
  2016.  
  2017.         85.   
  2018.  
  2019.         86.   /**
  2020.  
  2021.  
  2022.  113.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  2023.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  2024.         91.       $filter = $this->chain[$this->index];
  2025.  
  2026.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  2027.  
  2028.         93.       if($count == 1) {
  2029.  
  2030.         94.
  2031.                     $filter->executeOnce($this, $container);
  2032.  
  2033.         95.       } else {
  2034.  
  2035.         96.         $filter->execute($this, $container);
  2036.  
  2037.         97.       }
  2038.  
  2039.  
  2040.  114.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  2041.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  2042.         61.     $replace = $this->getParameter('replace', false);
  2043.  
  2044.         62.     
  2045.  
  2046.         63.     $start = microtime(true);
  2047.  
  2048.         64.
  2049.                 $filterChain->execute($container);
  2050.  
  2051.         65.     
  2052.  
  2053.         66.     $outputTypes = (array) $this->getParameter('output_types');
  2054.  
  2055.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  2056.  
  2057.  
  2058.  115.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  2059.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  2060.         91.       $filter = $this->chain[$this->index];
  2061.  
  2062.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  2063.  
  2064.         93.       if($count == 1) {
  2065.  
  2066.         94.
  2067.                     $filter->executeOnce($this, $container);
  2068.  
  2069.         95.       } else {
  2070.  
  2071.         96.         $filter->execute($this, $container);
  2072.  
  2073.         97.       }
  2074.  
  2075.  
  2076.  116.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  2077.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  2078.        321.         $filterChain->register($controller->getFilter('execution'));
  2079.  
  2080.        322
  2081.  
  2082.        323.         // process the filter chain
  2083.  
  2084.        324.
  2085.                     $filterChain->execute($this);
  2086.  
  2087.        325.       }
  2088.  
  2089.        326.       
  2090.  
  2091.        327.       // restore autoloads
  2092.  
  2093.  
  2094.  117.       at AgaviExecutionContainer->execute()
  2095.       in core.agavi_dir\filter\AgaviExecutionFilter.class.php line 420
  2096.        417.               $slotResponse = $viewCache['slots'][$layerName][$slotName];
  2097.  
  2098.        418.             } else {
  2099.  
  2100.        419.               // $lm->log('Running slot "' . $slotName . '"...');
  2101.  
  2102.        420.
  2103.                           $slotResponse = $slotContainer->execute();
  2104.  
  2105.        421.               if($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
  2106.  
  2107.        422.                 // $lm->log('Adding response of slot "' . $slotName . '" to cache...');
  2108.  
  2109.        423.                 $viewCache['slots'][$layerName][$slotName] = $slotResponse;
  2110.  
  2111.  
  2112.  118.       at AgaviExecutionFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  2113.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  2114.         80.    */
  2115.  
  2116.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  2117.  
  2118.         82.   {
  2119.  
  2120.         83.
  2121.                 $this->execute($filterChain, $container);
  2122.  
  2123.         84.   }
  2124.  
  2125.         85.   
  2126.  
  2127.         86.   /**
  2128.  
  2129.  
  2130.  119.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  2131.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  2132.         91.       $filter = $this->chain[$this->index];
  2133.  
  2134.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  2135.  
  2136.         93.       if($count == 1) {
  2137.  
  2138.         94.
  2139.                     $filter->executeOnce($this, $container);
  2140.  
  2141.         95.       } else {
  2142.  
  2143.         96.         $filter->execute($this, $container);
  2144.  
  2145.         97.       }
  2146.  
  2147.  
  2148.  120.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  2149.       in core.agavi_dir\filter\AgaviExecutionTimeFilter.class.php line 64
  2150.         61.     $replace = $this->getParameter('replace', false);
  2151.  
  2152.         62.     
  2153.  
  2154.         63.     $start = microtime(true);
  2155.  
  2156.         64.
  2157.                 $filterChain->execute($container);
  2158.  
  2159.         65.     
  2160.  
  2161.         66.     $outputTypes = (array) $this->getParameter('output_types');
  2162.  
  2163.         67.     if(is_array($outputTypes) && !in_array($container->getOutputType()->getName(), $outputTypes)) {
  2164.  
  2165.  
  2166.  121.       at AgaviExecutionTimeFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  2167.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  2168.         91.       $filter = $this->chain[$this->index];
  2169.  
  2170.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  2171.  
  2172.         93.       if($count == 1) {
  2173.  
  2174.         94.
  2175.                     $filter->executeOnce($this, $container);
  2176.  
  2177.         95.       } else {
  2178.  
  2179.         96.         $filter->execute($this, $container);
  2180.  
  2181.         97.       }
  2182.  
  2183.  
  2184.  122.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  2185.       in core.agavi_dir\controller\AgaviExecutionContainer.class.php line 324
  2186.        321.         $filterChain->register($controller->getFilter('execution'));
  2187.  
  2188.        322
  2189.  
  2190.        323.         // process the filter chain
  2191.  
  2192.        324.
  2193.                     $filterChain->execute($this);
  2194.  
  2195.        325.       }
  2196.  
  2197.        326.       
  2198.  
  2199.        327.       // restore autoloads
  2200.  
  2201.  
  2202.  123.       at AgaviExecutionContainer->execute()
  2203.       in core.agavi_dir\filter\AgaviDispatchFilter.class.php line 50
  2204.         47.    */
  2205.  
  2206.         48.   public function execute(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  2207.  
  2208.         49.   {
  2209.  
  2210.         50.
  2211.                 $container->setResponse($container->execute());
  2212.  
  2213.         51.   }
  2214.  
  2215.         52. }
  2216.  
  2217.         53
  2218.  
  2219.  
  2220.  124.       at AgaviDispatchFilter->execute([object AgaviFilterChain], [object AgaviExecutionContainer])
  2221.       in core.agavi_dir\filter\AgaviFilter.class.php line 83
  2222.         80.    */
  2223.  
  2224.         81.   public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
  2225.  
  2226.         82.   {
  2227.  
  2228.         83.
  2229.                 $this->execute($filterChain, $container);
  2230.  
  2231.         84.   }
  2232.  
  2233.         85.   
  2234.  
  2235.         86.   /**
  2236.  
  2237.  
  2238.  125.       at AgaviFilter->executeOnce([object AgaviFilterChain], [object AgaviExecutionContainer])
  2239.       in core.agavi_dir\filter\AgaviFilterChain.class.php line 94
  2240.         91.       $filter = $this->chain[$this->index];
  2241.  
  2242.         92.       $count = ++self::$filterLog[$this->filterLogKey][get_class($filter)];
  2243.  
  2244.         93.       if($count == 1) {
  2245.  
  2246.         94.
  2247.                     $filter->executeOnce($this, $container);
  2248.  
  2249.         95.       } else {
  2250.  
  2251.         96.         $filter->execute($this, $container);
  2252.  
  2253.         97.       }
  2254.  
  2255.  
  2256.  126.       at AgaviFilterChain->execute([object AgaviExecutionContainer])
  2257.       in core.agavi_dir\controller\AgaviController.class.php line 185
  2258.        182.       $filterChain->register($this->filters['dispatch']);
  2259.  
  2260.        183.       
  2261.  
  2262.        184.       // go, go, go!
  2263.  
  2264.        185.
  2265.                   $filterChain->execute($container);
  2266.  
  2267.        186.       
  2268.  
  2269.        187.       $response = $container->getResponse();
  2270.  
  2271.        188.       $response->merge($this->response);
  2272.  
  2273.  
  2274.  127.       at AgaviController->dispatch()
  2275.       in _D:\httpdocs\ths3\branches\3.0\pub\index.php line 30

advertising

Update the Post

Either update this post and resubmit it with changes, or make a new post.

You may also comment on this post.

update paste below
details of the post (optional)

Note: Only the paste content is required, though the following information can be useful to others.

Save name / title?

(space separated, optional)



Please note that information posted here will expire by default in one month. If you do not want it to expire, please set the expiry time above. If it is set to expire, web search engines will not be allowed to index it prior to it expiring. Items that are not marked to expire will be indexable by search engines. Be careful with your passwords. All illegal activities will be reported and any information will be handed over to the authorities, so be good.

worth-right
worth-right