class Rule

class Rule extends RulesActionContainer {
    protected $conditions = NULL;
    
    /**
     * @var string
     */
    protected $itemName = 'rule';
    
    /**
     * @var string
     */
    public $label = 'unlabeled';
    public function __construct($variables = array(), $providesVars = array()) {
        parent::__construct($variables, $providesVars);
        // Initialize the conditions container.
        if (!isset($this->conditions)) {
            $this->conditions = rules_and();
            // Don't use setParent() to avoid having it added to the children.
            $this->conditions->parent = $this;
        }
    }
    
    /**
     * Gets an iterator over all contained conditions.
     *
     * Note that this iterator also implements the ArrayAccess interface.
     *
     * @return RulesRecursiveElementIterator
     */
    public function conditions() {
        return $this->conditions
            ->getIterator();
    }
    
    /**
     * Returns the "And" condition container, which contains all conditions of
     * this rule.
     *
     * @return RulesAnd
     */
    public function conditionContainer() {
        return $this->conditions;
    }
    public function __sleep() {
        return parent::__sleep() + drupal_map_assoc(array(
            'conditions',
            'label',
        ));
    }
    
    /**
     * Gets an iterator over all contained actions.
     *
     * Note that this iterator also implements the ArrayAccess interface.
     *
     * @return RulesRecursiveElementIterator
     */
    public function actions() {
        return parent::getIterator();
    }
    
    /**
     * Adds a condition.
     *
     * Pass either an instance of the RulesConditionInterface or the arguments as
     * needed by rules_condition().
     *
     * @return $this
     */
    public function condition($name, $settings = array()) {
        $this->conditions
            ->condition($name, $settings);
        return $this;
    }
    public function sortChildren($deep = FALSE) {
        $this->conditions
            ->sortChildren($deep);
        parent::sortChildren($deep);
    }
    public function evaluate(RulesState $state) {
        rules_log('Evaluating conditions of rule %label.', array(
            '%label' => $this->label,
        ), RulesLog::INFO, $this);
        if ($this->conditions
            ->evaluate($state)) {
            rules_log('Rule %label fires.', array(
                '%label' => $this->label,
            ), RulesLog::INFO, $this, TRUE);
            parent::evaluate($state);
            rules_log('Rule %label has fired.', array(
                '%label' => $this->label,
            ), RulesLog::INFO, $this, FALSE);
        }
    }
    
    /**
     * Fires the rule, i.e. evaluates the rule without checking its conditions.
     *
     * @see RulesPlugin::evaluate()
     */
    public function fire(RulesState $state) {
        rules_log('Firing rule %label.', array(
            '%label' => $this->label,
        ), RulesLog::INFO, $this);
        parent::evaluate($state);
    }
    public function integrityCheck() {
        parent::integrityCheck();
        $this->conditions
            ->integrityCheck();
        return $this;
    }
    public function access() {
        return (!isset($this->conditions) || $this->conditions
            ->access()) && parent::access();
    }
    public function dependencies() {
        return array_keys(array_flip($this->conditions
            ->dependencies()) + array_flip(parent::dependencies()));
    }
    public function destroy() {
        $this->conditions
            ->destroy();
        parent::destroy();
    }
    
    /**
     * @return RulesRecursiveElementIterator
     */
    public function getIterator() {
        $array = array_merge(array(
            $this->conditions,
        ), $this->children);
        return new RulesRecursiveElementIterator($array);
    }
    protected function stateVariables($element = NULL) {
        // Don't add in provided action variables for the conditions.
        if (isset($element) && $element === $this->conditions) {
            return $this->availableVariables();
        }
        $vars = parent::stateVariables($element);
        // Take variable info assertions of conditions into account.
        if ($assertions = $this->conditions
            ->variableInfoAssertions()) {
            $vars = RulesData::addMetadataAssertions($vars, $assertions);
        }
        return $vars;
    }
    protected function exportFlat() {
        return $this->isRoot();
    }
    protected function exportToArray() {
        $export = parent::exportToArray();
        if (!$this->isRoot()) {
            $export[strtoupper($this->plugin())]['LABEL'] = $this->label;
        }
        return $export;
    }
    protected function exportChildren($key = NULL) {
        $export = array();
        if ($this->conditions->children) {
            $export = $this->conditions
                ->exportChildren('IF');
        }
        return $export + parent::exportChildren('DO');
    }
    public function import(array $export) {
        if (!$this->isRoot() && isset($export[strtoupper($this->plugin())]['LABEL'])) {
            $this->label = $export[strtoupper($this->plugin())]['LABEL'];
        }
        parent::import($export);
    }
    protected function importChildren($export, $key = NULL) {
        if (!empty($export['IF'])) {
            $this->conditions
                ->importChildren($export, 'IF');
        }
        parent::importChildren($export, 'DO');
    }
    public function __clone() {
        parent::__clone();
        $this->conditions = clone $this->conditions;
        $this->conditions->parent = $this;
    }
    
    /**
     * Overrides RulesPlugin::variableInfoAssertions().
     *
     * Rules may not provide any variable info assertions, as Rules are only
     * conditionally executed.
     */
    protected function variableInfoAssertions() {
        return array();
    }
    
    /**
     * Overridden to ensure the whole Rule is deleted at once.
     */
    public function delete($keep_children = FALSE) {
        parent::delete($keep_children);
    }
    
    /**
     * Overridden to expose the variables of all actions for embedded rules.
     */
    public function providesVariables() {
        $provides = parent::providesVariables();
        if (!$this->isRoot()) {
            foreach ($this->actions() as $action) {
                $provides += $action->providesVariables();
            }
        }
        return $provides;
    }
    public function resetInternalCache() {
        parent::resetInternalCache();
        $this->conditions
            ->resetInternalCache();
    }

}