PHP Plugins::implemented方法代码示例

 /**
  * All handlers must implement act() to conform to handler API.
  * This is the default implementation of act(), which attempts
  * to call a class member method of $this->act_$action().  Any
  * subclass is welcome to override this default implementation.
  *
  * @param string $action the action that was in the URL rule
  */
 public function act($action)
 {
     if (null === $this->handler_vars) {
         $this->handler_vars = new SuperGlobal(array());
     }
     $this->action = $action;
     $this->theme->assign('matched_rule', URL::get_matched_rule());
     $request = new StdClass();
     foreach (URL::get_active_rules() as $rule) {
         $request->{$rule->name} = false;
     }
     $request->{$this->theme->matched_rule->name} = true;
     $this->theme->assign('request', $request);
     $action_hook = 'plugin_act_' . $action;
     $before_action_hook = 'before_' . $action_hook;
     $theme_hook = 'route_' . $action;
     $after_action_hook = 'after_' . $action_hook;
     Plugins::act($before_action_hook, $this);
     Plugins::act($action_hook, $this);
     if (Plugins::implemented($theme_hook, 'theme')) {
         $theme = Themes::create();
         $rule = URL::get_matched_rule();
         Plugins::theme($theme_hook, $theme, $rule->named_arg_values, $this);
     }
     Plugins::act($after_action_hook);
 }

 /**
  * function __set
  * Handles setting virtual properties for this class
  * @param string Name of the property
  * @param mixed Value to set it to
  * @return mixed The set value
  **/
 public function __set($name, $value)
 {
     $classname = strtolower(get_class($this));
     $hook = 'set_' . $classname . '_' . $name;
     if (Plugins::implemented($hook, 'action')) {
         return Plugins::act('set_' . $classname . '_' . $name, $value, $this);
     }
     if (isset($this->properties_loaded[$name])) {
         $this->newfields[$name] = $value;
     } else {
         $this->fields[$name] = $value;
         $this->properties_loaded[$name] = true;
     }
     return $value;
 }

 /**
  * Overrides QueryRecord __get to implement custom object properties
  * @param string $name Name of property to return
  * @return mixed The requested field value
  */
 public function __get($name)
 {
     // some properties are considered special and accidentally filtering them would be bad, so we exclude those
     $fieldnames = array_merge(array_keys($this->fields), array('permalink', 'tags', 'comments', 'comment_count', 'approved_comment_count', 'comment_feed_link', 'author', 'editlink', 'info'));
     $filter = false;
     if (!in_array($name, $fieldnames) && strpos($name, '_') !== false) {
         $field_matches = implode('|', $fieldnames);
         if (preg_match('/^(' . $field_matches . ')_(.+)$/', $name, $matches)) {
             list($junk, $name, $filter) = $matches;
         }
     }
     switch ($name) {
         case 'statusname':
             $out = self::status_name($this->status);
             break;
         case 'typename':
             $out = self::type_name($this->content_type);
             break;
         case 'permalink':
             $out = $this->get_permalink();
             break;
         case 'editlink':
             $out = $this->get_editlink();
             break;
         case 'tags':
             $out = $this->get_tags();
             break;
         case 'comments':
             $out = $this->get_comments();
             break;
         case 'comment_count':
             $out = $this->get_comments()->count();
             break;
         case 'approved_comment_count':
             $out = Comments::count_by_id($this->id);
             break;
         case 'comment_feed_link':
             $out = $this->get_comment_feed_link();
             break;
         case 'author':
             $out = $this->get_author();
             break;
         case 'info':
             $out = $this->get_info();
             break;
         case 'excerpt':
             $field = 'content' . ($filter ? '_' . $filter : '_out');
             $out = $this->__get($field);
             if (!Plugins::implemented('post_excerpt', 'filter')) {
                 $out = Format::more($out, $this, Options::get('excerpt_settings', array('max_paragraphs' => 2)));
             }
             break;
         default:
             $out = parent::__get($name);
             break;
     }
     if ($filter != 'internal') {
         $out = Plugins::filter("post_get", $out, $name, $this);
         $out = Plugins::filter("post_{$name}", $out, $this);
     }
     if ($filter) {
         $out = Plugins::filter("post_{$name}_{$filter}", $out, $this);
     }
     return $out;
 }

 /**
  * Runs this job.
  *
  * Executes the Cron Job callback. Deletes the Cron Job if end_time is reached
  * or if it failed to execute the last # consecutive attempts. Also sends notification
  * by email to specified address.
  * Note: end_time can be null, ie. "The Never Ending Cron Job".
  *
  * Callback is passed a param_array of the Cron Job fields and the execution time
  * as the 'now' field. The 'result' field contains the result of the last execution; either
  * 'executed' or 'failed'.
  *
  * @todo send notification of execution/failure.
  */
 public function execute()
 {
     $paramarray = array_merge(array('now' => $this->now), $this->to_array());
     // this is an ugly hack that we could probably work around better by forking each cron into its own process
     // we increment the failure count now so that if we don't return after calling the callback (ie: a fatal error) it still counts against it, rather than simply never running
     // and preventing all those queued up after it from running
     $this->failures = $this->failures + 1;
     // check to see if we have failed too many times before we update, we might go ahead and skip this one
     if ($this->failures > Options::get('cron_max_failures', 10)) {
         EventLog::log(_t('CronJob %s has failed %d times and is being deactivated!', array($this->name, $this->failures - 1)), 'alert', 'cron');
         $this->active = 0;
     }
     // update before we run it
     $this->update();
     // if the check has been deactivated, just return
     if ($this->active == 0) {
         return;
     }
     if (is_callable($this->callback)) {
         // this is a callable we can actually call, so do it
         $result = call_user_func($this->callback, $paramarray);
     } else {
         if (!is_string($this->callback) && is_callable($this->callback, true, $callable_name)) {
             // this looks like a callable to PHP, but it cannot be called at present and should not be assumed to be a plugin filter name
             // there is nothing for us to do, but it was a specifically-named function for us to call, so assume this is a failure
             $result = false;
         } else {
             // this is not callable and doesn't look like one - it should simply be a textual plugin filter name
             // is this plugin filter actually implemented?
             if (Plugins::implemented($this->callback, 'filter')) {
                 // then run it and use that result
                 $result = true;
                 $result = Plugins::filter($this->callback, $result, $paramarray);
             } else {
                 // the filter isn't implemented, consider that a failure
                 $result = false;
             }
         }
     }
     if ($result === false) {
         $this->result = 'failed';
         // simply increment the failure counter. if it's over the limit it'll be deactivated on the next go-around
         $this->failures = $this->failures + 1;
         EventLog::log(_t('CronJob %s failed.', array($this->name)), 'err', 'cron');
     } else {
         $this->result = 'executed';
         // reset failures, we were successful
         $this->failures = 0;
         EventLog::log(_t('CronJob %s completed successfully.', array($this->name)), 'debug', 'cron');
         // it ran successfully, so check if it's time to delete it.
         if (!is_null($this->end_time) && $this->now >= $this->end_time) {
             EventLog::log(_t('CronJob %s is not scheduled to run again and is being deleted.', array($this->name)), 'debug', 'cron');
             $this->delete();
             return;
         }
     }
     $this->last_run = $this->now;
     $this->next_run = $this->now->int + $this->increment;
     $this->update();
 }