You are here

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

class RulesConditionalCase in Conditional Rules 7

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

Switch case.

Hierarchy

Expanded class hierarchy of RulesConditionalCase

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

File

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

View source 
class RulesConditionalCase extends RulesConditionalElement {
  protected $itemName = 'case';

  /**
   * @var RulesPlugin
   */
  protected $condition;

  /**
   * Evaluated condition results.
   * @var array
   */
  protected $conditionResultCache = array();
  public function __construct($settings = array(), $fallThrough = FALSE) {
    parent::__construct();
    if (isset($settings['value'])) {
      $this->settings['value'] = $settings['value'];
    }
    elseif (isset($settings['value:select'])) {
      $this->settings['value:select'] = $settings['value:select'];
    }
    $this->settings += array(
      'fall_through' => $fallThrough,
    );
  }
  public function __destruct() {
    unset($this->condition);
    unset($this->conditionResultCache);
  }
  public function forceSetUp() {
    parent::forceSetUp();
    $this
      ->setUpCondition();
  }
  public function pluginParameterInfo() {
    $parameterInfo = array(
      'value' => array(
        'type' => '*',
        'label' => t('Data value'),
        'description' => t('The value to compare the data with.'),
        'allow null' => TRUE,
      ),
      'fall_through' => array(
        'type' => 'boolean',
        'label' => t('Fall through'),
        'description' => t('Fall through to next case when complete. If this option is checked, the next case is automatically executed (regardless of the case value) when this case is finished. If not, the switch will terminate when the case is finished.'),
        'optional' => TRUE,
        'default value' => FALSE,
        'restriction' => 'input',
      ),
    );

    // Derive parameter info from switch variable selector.
    $dataSelector = isset($this->parent->settings['data:select']) ? $this->parent->settings['data:select'] : NULL;
    if ($wrapper = $this
      ->applyDataSelector($dataSelector)) {
      $parameterInfo['value']['type'] = $wrapper
        ->type();
    }
    return $parameterInfo;
  }
  public function stateVariables($element = NULL) {
    $this
      ->forceSetUp();
    if (!isset($element) || $element === $this->condition) {
      return parent::stateVariables();
    }
    else {

      // Add assertions from the condition.
      $variables = parent::stateVariables($element);
      if (isset($this->condition) && ($assertions = $this->condition
        ->call('variableInfoAssertions'))) {
        $variables = RulesData::addMetadataAssertions($variables, $assertions);
      }
      return $variables;
    }
  }
  protected function setUpCondition() {
    if (!isset($this->condition) && isset($this->parent)) {

      // Prepare settings for 'data_is' condition.
      $settings = array(
        'data:select' => $this->parent->settings['data:select'],
        'op' => '==',
      );
      if (isset($this->settings['value:select'])) {
        $settings['value:select'] = $this->settings['value:select'];
      }
      elseif (isset($this->settings['value'])) {
        $settings['value'] = $this->settings['value'];
      }
      else {

        // Abort if settings are incomplete.
        return;
      }

      // Set up 'data_is'.
      $this->condition = rules_condition('data_is', $settings);
      $this->condition->parent = $this;
      $this->condition
        ->processSettings();
    }
  }

  /**
   * Returns whether this case should fall through.
   */
  public function fallThrough() {
    return !empty($this->settings['fall_through']);
  }

  /**
   * Determines whether this branch can be evaluated.
   */
  public function canEvaluate(RulesState $state) {
    $this
      ->forceSetUp();

    // Check if this element has fallen through.
    if ($previous = $this
      ->getPreviousSibling()) {

      /** @var $previous self */
      if ($previous instanceof self && $previous
        ->fallThrough() && $previous
        ->canEvaluate($state)) {
        return TRUE;
      }
    }

    // Evaluate condition for the given state once.
    $this->conditionResultCache += array(
      'state' => array(),
      'result' => array(),
    );
    if (empty($this->conditionResultCache['state']) || !($cacheKey = array_search($state, $this->conditionResultCache['state'], TRUE))) {
      $cacheKey = count($this->conditionResultCache['state']);
      $this->conditionResultCache['state'][$cacheKey] = $state;
      $this->conditionResultCache['result'][$cacheKey] = $this->condition
        ->evaluate($state);
    }
    return !empty($this->conditionResultCache['result'][$cacheKey]);
  }
  public function resetInternalCache() {
    parent::resetInternalCache();
    $this->condition = NULL;
    $this->conditionResultCache = array();
  }

}

Members

Namesort descending Modifiers Type Description Overrides
RulesActionContainer::action public function Adds an action to the container.
RulesActionContainer::componentProvidesVariables public function Returns an array of provided variable names.
RulesActionContainer::evaluate public function Evaluate, whereas by default new vars are visible in the parent's scope. Overrides RulesPlugin::evaluate 2
RulesActionContainer::exportToArray protected function Overrides RulesContainerPlugin::exportToArray 1
RulesActionContainer::import public function Applies the given export. Overrides RulesContainerPlugin::import 1
RulesActionContainer::pluginProvidesVariables public function Returns info about variables 'provided' by the plugin. Overrides RulesPlugin::pluginProvidesVariables
RulesConditionalCase::$condition protected property
RulesConditionalCase::$conditionResultCache protected property Evaluated condition results.
RulesConditionalCase::$itemName protected property The name of the item this class represents in the info hook. Overrides RulesExtendable::$itemName
RulesConditionalCase::canEvaluate public function Determines whether this branch can be evaluated. Overrides RulesConditionalElement::canEvaluate
RulesConditionalCase::fallThrough public function Returns whether this case should fall through.
RulesConditionalCase::forceSetUp public function Forces the object to be setUp, this executes setUp() if not done yet. Overrides RulesExtendable::forceSetUp
RulesConditionalCase::pluginParameterInfo public function Returns info about parameters needed by the plugin. Overrides RulesPlugin::pluginParameterInfo
RulesConditionalCase::resetInternalCache public function Resets any internal static caches. Overrides RulesContainerPlugin::resetInternalCache
RulesConditionalCase::setUpCondition protected function
RulesConditionalCase::stateVariables public function Returns available state variables for an element. Overrides RulesContainerPlugin::stateVariables
RulesConditionalCase::__construct public function Overrides RulesActionContainer::__construct
RulesConditionalCase::__destruct public function
RulesConditionalElement::$parent protected property The parent conditional. Overrides RulesPlugin::$parent
RulesConditionalElement::checkSiblings protected function Checks basic conditional element integrity.
RulesConditionalElement::delete public function Deletes the element and its children. Overrides RulesContainerPlugin::delete 1
RulesConditionalElement::dependencies public function Calculates an array of required modules. Overrides RulesContainerPlugin::dependencies 1
RulesConditionalElement::exportChildren protected function Overrides RulesContainerPlugin::exportChildren 3
RulesConditionalElement::exportSettings protected function Overrides RulesPlugin::exportSettings
RulesConditionalElement::getAllSibling public function Gets sibling elements.
RulesConditionalElement::getNextSibling public function Gets the next sibling element.
RulesConditionalElement::getPreviousSibling public function Gets the previous sibling element.
RulesConditionalElement::importChildren protected function Overrides RulesContainerPlugin::importChildren 3
RulesConditionalElement::integrityCheck public function Makes sure the plugin is configured right. Overrides RulesContainerPlugin::integrityCheck 1
RulesConditionalElement::isDefault public function Determines whether this branch is default, i.e. covers the remainder of conditions outside of all non-default branches inside the conditional. 3
RulesConditionalElement::label public function Returns the label of the element. Overrides RulesPlugin::label 1
RulesConditionalElement::providesVariables public function Returns info about all variables provided for later evaluated elements. Overrides RulesActionContainer::providesVariables 1
RulesConditionalElement::setParent public function @todo Remove once http://drupal.org/node/1671344 is resolved. Overrides RulesPlugin::setParent
RulesContainerPlugin::$children protected property
RulesContainerPlugin::access public function Whether the currently logged in user has access to all configured elements. Overrides RulesPlugin::access 1
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::destroy public function Removes circular object references so PHP garbage collector can work. Overrides RulesPlugin::destroy 1
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::getIterator public function Allows access to the children through the iterator. 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
RulesContainerPlugin::__clone public function By default we do a deep clone. Overrides RulesPlugin::__clone 1
RulesContainerPlugin::__sleep public function Overrides RulesPlugin::__sleep 2
RulesExtendable::$itemInfo protected property
RulesExtendable::facesAs public function
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::$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::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::processSettings public function Processes the settings e.g. to prepare input evaluators. 1
RulesPlugin::returnExport protected function Finalizes the configuration export.
RulesPlugin::returnVariables protected function Gets variables to return once the configuration has been executed. 2
RulesPlugin::root public function Gets the root element of the configuration.
RulesPlugin::save public function Saves the configuration to the database. 1
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.