PHP self::process方法代码示例

 public static function processStatic(Ajde_Template_Parser $parser, $attributes)
 {
     $instance = new self($parser, $attributes);
     $t = new stdClass();
     // Force unique object hash, see http://www.php.net/manual/es/function.spl-object-hash.php#76220
     return $instance->process();
 }

 /**
  * Create an instance and process data
  * @param  object $scope Scope
  * @param  \Carbon\Carbon $date Date
  * @param  int $period Period
  * @return self Line chart instance
  */
 public static function forge($scope, $date, $period)
 {
     $chart = new self($scope, $date);
     $chart->setPeriod($period);
     $chart->process();
     return $chart;
 }

 public static function instance()
 {
     if (!is_404()) {
         return;
     }
     $image_creator = new self();
     $image_creator->process();
 }

 public function quickLogin($idNumber, $password, $rememberMe = true)
 {
     $form = new self();
     $form->idNumber = $idNumber;
     $form->password = $password;
     $form->rememberMe = $rememberMe;
     return $form->process();
 }

 public static function import($uri)
 {
     $feed = new self();
     $zend_feed = \Zend_Feed::import($uri);
     $feed->feed = $zend_feed;
     $feed->encoding = $feed->feed->getDOM()->ownerDocument->encoding;
     $feed->process();
     return $feed;
 }

 /**
  * Processa i dati
  * @param type $data
  */
 public function process($data)
 {
     foreach ($data as $nodeName => $nodeValue) {
         // $nodeValue è sempre un oggetto
         if ($nodeValue->count() > 0 || count($nodeValue->attributes()) > 0) {
             // se ha figli o ha attributi, allora lo considero come oggetto da parsare
             // se ha attributi li metto in $_attributes
             $clone = new self();
             $clone->process($nodeValue);
             foreach ($nodeValue->attributes() as $attrName => $attrValue) {
                 $clone->setAttribute($attrName, $attrValue);
             }
             $this->{$nodeName} = $clone;
         } else {
             // altrimenti è una stringa
             $this->{$nodeName} = (string) $nodeValue;
         }
     }
 }

 /**
  * Crea una struttura dati $section con i valori $value
  * @param String $section
  * @param String|Array $value
  * @return \self
  */
 public function createChild($section, $value)
 {
     $e = explode($this->_separator, $section, 2);
     $newSection = $e[0];
     $dataSend = array($e[1] => $value);
     if ($this->{$newSection} instanceof self) {
         $child = $this->{$newSection};
     } else {
         $child = new self();
     }
     $child->process($dataSend);
     return $child;
 }

 /**
  * @param string $file
  * @param string $sep (Optional.)
  * @param string $quote (Optional.)
  * @param boolean $header (Optional.)
  * @return \CsvImport
  */
 public static function import($file, $sep = self::SEP_COMMA, $quote = self::QUOTE_AUTO, $header = false)
 {
     $self = new self(array('filename' => $file, 'separator' => $sep, 'quotes' => $quote, 'header' => $header));
     return $self->process();
 }

 /**
  * Create an instance and process data
  * @param  object $scope Scope
  * @param  \Carbon\Carbon $date Date
  * @return self Line chart instance
  */
 public static function forge($scope, $date)
 {
     $chart = new self($scope, $date);
     $chart->process();
     return $chart;
 }

 /**
  * Parses the command line
  *
  * See getopt() for a complete description.
  *
  * @param  numeric $version      the getopt version: 1 or 2
  * @param  array   $args         the arguments
  * @param  string  $shortOptions the short options definition, e.g. "ab:c::"
  * @param  array   $longOptions  the long options definition
  * @param  string  $ambiguity    directive to handle option names ambiguity
  * @return array   the parsed options, their arguments and parameters
  * @access public
  * @static
  */
 public static function doGetopt($version = null, $args = array(), $shortOptions = '', $longOptions = array(), $ambiguity = '')
 {
     $getopt = new self();
     return $getopt->process($args, $shortOptions, $longOptions, $ambiguity, $version);
 }

 public static function import($tpl_name)
 {
     $is_aliased = preg_match("~^\\@(.+)~", $tpl_name, $real_name);
     if ($is_aliased) {
         $tpl_name = $real_name[1];
     } else {
         $tpl_name = fx::getComponentFullName($tpl_name);
     }
     if (isset(self::$imported_classes[$tpl_name])) {
         return self::$imported_classes[$tpl_name];
     }
     $processor = new self();
     $processor->setTemplateName($tpl_name);
     if ($is_aliased) {
         $processor->isAliased(true);
     }
     $classname = $processor->getCompiledClassName();
     $processor->addDefaultSourceDirs();
     try {
         $processor->process();
     } catch (\Exception $e) {
         self::$imported_classes[$tpl_name] = false;
         return false;
     }
     self::$imported_classes[$tpl_name] = $classname;
     $classname::init();
     return $classname;
 }

 /**
  * @param DibiConnection $dibiConnection
  * @param string $migrationsFolder
  * @param string $tempDirectory
  */
 public static function handle(DibiConnection $dibiConnection, $migrationsFolder, $tempDirectory)
 {
     $instance = new self($dibiConnection, $migrationsFolder, $tempDirectory);
     $instance->process();
 }

 public static function processStatic(Parser $parser, $attributes)
 {
     $instance = new self($parser, $attributes);
     return $instance->process();
 }

 /**
  * @param string $source
  * @param array $options
  * @return string
  */
 public static function minify($source, $options = [])
 {
     $min = new self($options);
     return $min->process($source);
 }

 /**
  *
  * @param array $input
  */
 public static function process_request(array $input)
 {
     $c = new self();
     $c->process($input);
 }