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;
    }

}