class RulesConditionContainer

abstract class RulesConditionContainer extends RulesContainerPlugin implements RulesConditionInterface {
    protected $negate = FALSE;
    
    /**
     * Adds a condition to the container.
     *
     * Pass in either an instance of the RulesConditionInterface or the arguments
     * as needed by rules_condition().
     *
     * @return $this
     */
    public function condition($name, $settings = array()) {
        $condition = is_object($name) && $name instanceof RulesConditionInterface ? $name : rules_condition($name, $settings);
        $condition->setParent($this);
        return $this;
    }
    
    /**
     * Negate this condition.
     *
     * @return RulesConditionContainer
     */
    public function negate($negate = TRUE) {
        $this->negate = (bool) $negate;
        return $this;
    }
    public function isNegated() {
        return $this->negate;
    }
    public function __sleep() {
        return parent::__sleep() + array(
            'negate' => 'negate',
        );
    }
    
    /**
     * Just return the condition container's result.
     */
    protected function returnVariables(RulesState $state, $result = NULL) {
        return $result;
    }
    protected function exportChildren($key = NULL) {
        $key = isset($key) ? $key : strtoupper($this->plugin());
        return parent::exportChildren($this->negate ? 'NOT ' . $key : $key);
    }
    protected function importChildren($export, $key = NULL) {
        $key = isset($key) ? $key : strtoupper($this->plugin());
        // Care for negated elements.
        if (!isset($export[$key]) && isset($export['NOT ' . $key])) {
            $this->negate = TRUE;
            $key = 'NOT ' . $key;
        }
        parent::importChildren($export, $key);
    }
    
    /**
     * Overridden to exclude variable assertions of negated conditions.
     */
    protected function stateVariables($element = NULL) {
        $vars = $this->availableVariables();
        if (isset($element)) {
            // Add in variables provided by siblings executed before the element.
            foreach ($this->children as $child) {
                if ($child === $element) {
                    break;
                }
                $vars += $child->providesVariables();
                // Take variable info assertions into account.
                if (!$this->negate && !$child->isNegated() && ($assertions = $child->variableInfoAssertions())) {
                    $vars = RulesData::addMetadataAssertions($vars, $assertions);
                }
            }
        }
        return $vars;
    }

}