class RulesEventSet

class RulesEventSet extends RulesRuleSet {
  
  /**
   * @var string
   */
  protected $itemName = 'event set';
  
  /**
   * Event sets may recurse as we block recursions on rule-level.
   *
   * @var bool
   */
  public $recursion = TRUE;
  public function __construct($info = array()) {
    $this->setup();
    $this->info = $info;
  }
  public function executeByArgs($args = array()) {
    rules_log('Reacting on event %label.', array(
      '%label' => $this->info['label'],
    ), RulesLog::INFO, NULL, TRUE);
    $state = $this->setUpState($args);
    module_invoke_all('rules_config_execute', $this);
    $this->evaluate($state);
    $state->cleanUp($this);
    rules_log('Finished reacting on event %label.', array(
      '%label' => $this->info['label'],
    ), RulesLog::INFO, NULL, FALSE);
  }
  
  /**
   * Rebuilds the event cache.
   *
   * We cache event-sets per event in order to allow efficient usage via
   * rules_invoke_event().
   *
   * @see rules_get_cache()
   * @see rules_invoke_event()
   */
  public static function rebuildEventCache() {
    // Set up the per-event cache.
    $events = rules_fetch_data('event_info');
    $sets = array();
    // Add all rules associated with this event to an EventSet for caching.
    $rules = rules_config_load_multiple(FALSE, array(
      'plugin' => 'reaction rule',
      'active' => TRUE,
    ));
    foreach ($rules as $name => $rule) {
      foreach ($rule->events() as $event_name) {
        $event_base_name = rules_get_event_base_name($event_name);
        // Skip not defined events.
        if (empty($events[$event_base_name])) {
          continue;
        }
        // Create an event set if not yet done.
        if (!isset($sets[$event_name])) {
          $handler = rules_get_event_handler($event_name, $rule->getEventSettings($event_name));
          // Start the event dispatcher for this event, if any.
          if ($handler instanceof RulesEventDispatcherInterface && !$handler->isWatching()) {
            $handler->startWatching();
          }
          // Update the event info with the variables available based on the
          // event settings.
          $event_info = $events[$event_base_name];
          $event_info['variables'] = $handler->availableVariables();
          $sets[$event_name] = new RulesEventSet($event_info);
          $sets[$event_name]->name = $event_name;
        }
        // If a rule is marked as dirty, check if this still applies.
        if ($rule->dirty) {
          rules_config_update_dirty_flag($rule);
        }
        if (!$rule->dirty) {
          // Clone the rule to avoid modules getting the changed version from
          // the static cache.
          $sets[$event_name]->rule(clone $rule);
        }
      }
    }
    // Create cache items for all created sets.
    foreach ($sets as $event_name => $set) {
      $set->sortChildren();
      $set->optimize();
      // Allow modules to alter the cached event set.
      drupal_alter('rules_event_set', $event_name, $set);
      rules_set_cache('event_' . $event_name, $set);
    }
    // Cache a whitelist of configured events so we can use it to speed up later
    // calls. See rules_invoke_event().
    rules_set_cache('rules_event_whitelist', array_flip(array_keys($sets)));
  }
  protected function stateVariables($element = NULL) {
    return $this->availableVariables();
  }
  
  /**
   * Do not save since this class is for caching purposes only.
   *
   * @see RulesPlugin::save()
   */
  public function save($name = NULL, $module = 'rules') {
    return FALSE;
  }

}