You are here

Home » API reference » Conditional Rules 7 » rules_conditional.plugin.inc

class RuleConditionSet in Conditional Rules 7

Same name and namespace in other branches
  1. 8 includes/rules_conditional.plugin.inc \RuleConditionSet

Rule as condition set.

A rule condition set evaluates a set of actions before evaluating the result condition on the new state.

Hierarchy

Expanded class hierarchy of RuleConditionSet

1 string reference to 'RuleConditionSet'
rules_conditional_rules_plugin_info in ./rules_conditional.rules.inc
Implements hook_rules_plugin_info().

File

includes/rules_conditional.plugin.inc, line 463
Rules plugin implementation.

View source 
class RuleConditionSet extends RulesAnd {
  protected $itemName = 'rule condition set';

  /** @var RulesActionSet */
  protected $actions = NULL;
  public function __construct($variables = array()) {
    parent::__construct($variables);
    if (!isset($this->actions)) {
      $this->actions = rules_action_set();
      $this->actions->parent = $this;
    }
  }
  public function __sleep() {
    return parent::__sleep() + drupal_map_assoc(array(
      'actions',
    ));
  }

  /**
   * Get an iterator over all contained actions.
   * @return RulesRecursiveElementIterator
   */
  public function actions() {
    return $this->actions
      ->getIterator();
  }

  /**
   * Returns the contained action set to evaluate the result for.
   */
  public function actionContainer() {
    return $this->actions;
  }

  /**
   * Adds an action to the rule condition. Pass either an instance of the
   * RulesActionInterface or the arguments as needed by rules_action().
   *
   * This method can be chained.
   */
  public function action($name, $settings = array()) {
    $this->actions
      ->action($name, $settings);
    return $this;
  }

  /**
   * Returns a recursive iterator for result conditions.
   * @return RulesRecursiveElementIterator
   */
  public function conditions() {
    return parent::getIterator();
  }
  public function evaluate(RulesState $state) {
    rules_log('Evaluating actions of rule condition set %label.', array(
      '%label' => $this
        ->label(),
    ), RulesLog::INFO, $this);
    $this->actions
      ->evaluate($state);
    rules_log('Evaluating result conditions of rule condition set %label.', array(
      '%label' => $this
        ->label(),
    ), RulesLog::INFO, $this);
    return parent::evaluate($state);
  }
  public function integrityCheck() {
    parent::integrityCheck();
    $this->actions
      ->integrityCheck();
    return $this;
  }
  public function access() {
    return $this->actions
      ->access() && parent::access();
  }
  public function dependencies() {
    $modules = array(
      'rules_conditional' => 1,
    );
    $modules += array_flip($this->actions
      ->dependencies());
    $modules += array_flip(parent::dependencies());
    return array_keys($modules);
  }
  public function destroy() {
    $this->actions
      ->destroy();
    parent::destroy();
  }

  /**
   * @return RulesRecursiveElementIterator
   */
  public function getIterator() {
    $array = array_merge(array(
      $this->actions,
    ), $this->children);
    return new RulesRecursiveElementIterator($array);
  }
  protected function stateVariables($element = NULL) {
    $vars = $this
      ->availableVariables();
    if (isset($element) && $element !== $this->actions) {

      // Provide action variables for conditions.
      foreach ($this->actions->children as $child) {
        $vars += $child
          ->providesVariables();
      }

      // Provide condition state variables.
      foreach ($this->children as $child) {
        if ($child === $element) {
          break;
        }
        $vars += $child
          ->providesVariables();

        // Assert variable info from child conditions.
        if (!$child
          ->isNegated() && ($assertions = $child
          ->variableInfoAssertions())) {
          $vars = RulesData::addMetadataAssertions($vars, $assertions);
        }
      }
    }
    return $vars;
  }
  protected function exportChildren($key = NULL) {
    $export = array();
    if ($this->actions->children) {
      $export += $this->actions
        ->exportChildren('DO');
    }
    $export += parent::exportChildren('RESULT');
    return $export;
  }
  protected function importChildren($export, $key = NULL) {
    if (!empty($export['DO'])) {
      $this->actions
        ->importChildren($export, 'DO');
    }
    parent::importChildren($export, 'RESULT');
  }
  public function __clone() {
    parent::__clone();
    $this->actions = clone $this->actions;
    $this->actions->parent = $this;
  }

  /**
   * Deletes nested elements by default.
   */
  public function delete($keep_children = FALSE) {
    parent::delete($keep_children);
  }
  public function resetInternalCache() {
    parent::resetInternalCache();
    $this->actions
      ->resetInternalCache();
  }

}

Members

Namesort descending Modifiers Type Description Overrides
RuleConditionSet::$actions protected property @var RulesActionSet
RuleConditionSet::$itemName protected property The name of the item this class represents in the info hook. Overrides RulesAnd::$itemName
RuleConditionSet::access public function Whether the currently logged in user has access to all configured elements. Overrides RulesContainerPlugin::access
RuleConditionSet::action public function Adds an action to the rule condition. Pass either an instance of the RulesActionInterface or the arguments as needed by rules_action().
RuleConditionSet::actionContainer public function Returns the contained action set to evaluate the result for.
RuleConditionSet::actions public function Get an iterator over all contained actions.
RuleConditionSet::conditions public function Returns a recursive iterator for result conditions.
RuleConditionSet::delete public function Deletes nested elements by default. Overrides RulesContainerPlugin::delete
RuleConditionSet::dependencies public function Calculates an array of required modules. Overrides RulesContainerPlugin::dependencies
RuleConditionSet::destroy public function Removes circular object references so PHP garbage collector can work. Overrides RulesContainerPlugin::destroy
RuleConditionSet::evaluate public function Evaluate the element on a given rules evaluation state. Overrides RulesAnd::evaluate
RuleConditionSet::exportChildren protected function Overrides RulesConditionContainer::exportChildren
RuleConditionSet::getIterator public function Overrides RulesContainerPlugin::getIterator
RuleConditionSet::importChildren protected function Overrides RulesConditionContainer::importChildren
RuleConditionSet::integrityCheck public function Makes sure the plugin is configured right. Overrides RulesContainerPlugin::integrityCheck
RuleConditionSet::resetInternalCache public function Resets any internal static caches. Overrides RulesContainerPlugin::resetInternalCache
RuleConditionSet::stateVariables protected function Overridden to exclude variable assertions of negated conditions. Overrides RulesConditionContainer::stateVariables
RuleConditionSet::__clone public function By default we do a deep clone. Overrides RulesContainerPlugin::__clone
RuleConditionSet::__construct public function Overrides RulesContainerPlugin::__construct
RuleConditionSet::__sleep public function Overrides RulesConditionContainer::__sleep
RulesAnd::label public function Returns the label of the element. Overrides RulesPlugin::label
RulesConditionContainer::$negate protected property
RulesConditionContainer::condition public function Adds a condition to the container.
RulesConditionContainer::isNegated public function Returns whether the element is configured to negate the result. Overrides RulesConditionInterface::isNegated
RulesConditionContainer::negate public function Negate this condition. Overrides RulesConditionInterface::negate
RulesConditionContainer::returnVariables protected function Just return the condition container's result. Overrides RulesPlugin::returnVariables
RulesContainerPlugin::$children protected property
RulesContainerPlugin::availableVariables public function Returns info about variables available to be used as arguments for this element. Overrides RulesPlugin::availableVariables
RulesContainerPlugin::componentVariables public function Returns the specified variables, in case the plugin is used as component.
RulesContainerPlugin::executeByArgs public function Executes container with the given arguments. Overrides RulesPlugin::executeByArgs 1
RulesContainerPlugin::exportFlat protected function Determines whether the element should be exported in flat style. 1
RulesContainerPlugin::exportToArray protected function Overrides RulesPlugin::exportToArray 1
RulesContainerPlugin::import public function Applies the given export. Overrides RulesPlugin::import 1
RulesContainerPlugin::optimize public function Overrides optimize(). Overrides RulesPlugin::optimize
RulesContainerPlugin::parameterInfo public function Returns info about parameters needed for executing the configured plugin. Overrides RulesPlugin::parameterInfo
RulesContainerPlugin::setUpVariables protected function Returns info about all variables that have to be setup in the state. Overrides RulesPlugin::setUpVariables
RulesContainerPlugin::sortChildren public function Sorts all child elements by their weight. 1
RulesContainerPlugin::variableInfoAssertions protected function Returns asserted additions to the available variable info. Overrides RulesPlugin::variableInfoAssertions 1
RulesExtendable::$itemInfo protected property
RulesExtendable::facesAs public function
RulesExtendable::forceSetUp public function Forces the object to be setUp, this executes setUp() if not done yet. 1
RulesExtendable::itemFacesAs public static function Returns whether the a RuleExtendable supports the given interface.
RulesExtendable::rebuildCache public function Allows items to add something to the rules cache. 1
RulesExtendable::setUp protected function 1
RulesExtendable::__call public function Magic method: Invoke the dynamically implemented methods.
RulesPlugin::$availableVariables protected property Static cache for availableVariables(). 1
RulesPlugin::$cache protected property Overrides RulesExtendable::$cache
RulesPlugin::$elementId protected property Identifies an element inside a configuration.
RulesPlugin::$hook protected property Overrides RulesExtendable::$hook
RulesPlugin::$id public property If this is a configuration saved to the db, the id of it.
RulesPlugin::$info protected property Info about this element. Usage depends on the plugin. 2
RulesPlugin::$name public property
RulesPlugin::$parent protected property The parent element, if any.
RulesPlugin::$settings public property An array of settings for this element.
RulesPlugin::$weight public property
RulesPlugin::applyDataSelector public function Applies the given data selector.
RulesPlugin::checkParameterSettings protected function Checks whether parameters are correctly configured.
RulesPlugin::checkVarName protected function
RulesPlugin::compare protected static function
RulesPlugin::depth public function Returns the depth of this element in the configuration.
RulesPlugin::elementId public function Returns the element id, which identifies the element inside the config.
RulesPlugin::elementMap public function Gets the element map helper object, which helps mapping elements to ids.
RulesPlugin::elements public function Iterate over all elements nested below the current element.
RulesPlugin::ensureNameExists protected function Ensure the configuration has a name. If not, generate one.
RulesPlugin::entityInfo public function
RulesPlugin::entityType public function
RulesPlugin::execute public function Execute the configuration.
RulesPlugin::export public function Exports a rule configuration.
RulesPlugin::exportParameterSetting protected function
RulesPlugin::exportSettings protected function 1
RulesPlugin::form public function Seamlessly invokes the method implemented via faces.
RulesPlugin::form_submit public function
RulesPlugin::form_validate public function
RulesPlugin::getArgument protected function Returns the argument for the parameter $name described with $info.
RulesPlugin::getArgumentInfo public function Returns info about the configured argument.
RulesPlugin::getExecutionArguments protected function Gets the right arguments for executing the element.
RulesPlugin::getPluginName public function Gets the name of this plugin instance. 1
RulesPlugin::hasStatus public function Checks if the configuration has a certain exportable status.
RulesPlugin::identifier public function Returns the config name.
RulesPlugin::importParameterSetting protected function
RulesPlugin::importSettings protected function 1
RulesPlugin::info public function Returns the info of the plugin. 2
RulesPlugin::internalIdentifier public function
RulesPlugin::isRoot public function Returns whether the element is the root of the configuration.
RulesPlugin::parentElement public function Returns the element's parent.
RulesPlugin::plugin public function Returns the name of the element's plugin.
RulesPlugin::pluginInfo public function Returns info about the element's plugin.
RulesPlugin::pluginParameterInfo public function Returns info about parameters needed by the plugin. 2
RulesPlugin::pluginProvidesVariables public function Returns info about variables 'provided' by the plugin. 2
RulesPlugin::processSettings public function Processes the settings e.g. to prepare input evaluators. 1
RulesPlugin::providesVariables public function Returns info about all variables provided for later evaluated elements. 2
RulesPlugin::returnExport protected function Finalizes the configuration export.
RulesPlugin::root public function Gets the root element of the configuration.
RulesPlugin::save public function Saves the configuration to the database. 1
RulesPlugin::setParent public function Sets a new parent element.
RulesPlugin::setUpState public function Sets up the execution state for the given arguments.
RulesPlugin::__toString public function When converted to a string, just use the export format.