You are here

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

abstract class RulesConditionalPredicateElement in Conditional Rules 7

Same name and namespace in other branches
  1. 8 includes/rules_conditional.core.inc \RulesConditionalPredicateElement

Base conditional element that uses a predicate.

Hierarchy

Expanded class hierarchy of RulesConditionalPredicateElement

File

includes/rules_conditional.core.inc, line 396
Conditional Rules framework implementation.

View source 
abstract class RulesConditionalPredicateElement extends RulesConditionalElement {

  /**
   * @var RulesCondition
   */
  protected $predicate;
  public function __construct($predicate = NULL, $settings = array()) {
    parent::__construct();
    if (isset($predicate)) {
      $predicate = is_object($predicate) && $predicate instanceof RulesConditionInterface ? $predicate : rules_condition($predicate, $settings);
      $this
        ->setPredicate($predicate);
    }
  }

  /**
   * Sets a condition as predicate.
   */
  protected function setPredicate($predicate) {
    $this->predicate = $predicate;
    $this->predicate->parent = $this;

    // Set up variables with the new parent.
    $this
      ->resetInternalCache();
  }
  public function resetInternalCache() {
    parent::resetInternalCache();
    if (isset($this->predicate)) {
      $this->predicate
        ->resetInternalCache();
    }
  }
  public function __sleep() {
    $array = parent::__sleep();
    $array['predicate'] = 'predicate';
    return $array;
  }
  public function __clone() {
    parent::__clone();
    $this->predicate = clone $this->predicate;
    $this->predicate->parent = $this;
  }
  public function label() {
    $text = '@plugin';
    $variables = array(
      '@plugin' => $this
        ->pluginLabel(),
    );
    if (isset($this->predicate)) {
      $text = '@plugin: @label';
      $variables['@label'] = $this->predicate
        ->label();
    }
    return t($text, $variables);
  }
  public function pluginLabel() {
    return parent::label();
  }
  public function integrityCheck() {
    if (!isset($this->predicate)) {
      throw new RulesIntegrityException(t('The conditional "%plugin" does not have a valid predicate.', array(
        '%plugin' => $this
          ->plugin(),
      )), $this);
    }
    parent::integrityCheck();
    return $this;
  }

  /**
   * Adds predicate assertions to state.
   */
  protected function stateVariables($element = NULL) {
    if (!isset($element) || $element === $this->predicate) {
      return parent::stateVariables();
    }
    else {

      // Add assertions from the predicate.
      $variables = parent::stateVariables($element);
      if (isset($this->predicate) && ($assertions = $this->predicate
        ->call('variableInfoAssertions'))) {
        $variables = RulesData::addMetadataAssertions($variables, $assertions);
      }
      return $variables;
    }
  }
  public function dependencies() {
    $modules = array_flip(parent::dependencies());
    if (isset($this->predicate)) {
      $modules += array_flip($this->predicate
        ->dependencies());
    }
    return array_keys($modules);
  }

  /**
   * Negates the predicate.
   */
  public function negate($negate = TRUE) {
    $this->predicate
      ->negate($negate);
    return $this;
  }

  /**
   * Returns whether the predicate is negated.
   */
  public function isNegated() {
    return $this->predicate
      ->isNegated();
  }

  /**
   * Evaluates the predicate.
   */
  public function canEvaluate(RulesState $state) {
    return $this->predicate
      ->evaluate($state);
  }

  /**
   * Imports predicate.
   */
  protected function importChildren($export, $key = NULL) {
    $this
      ->importPredicate($export);
    parent::importChildren($export, 'DO');
  }

  /**
   * Imports predicate.
   */
  protected function importPredicate($export, $key = NULL) {
    if (!isset($key)) {
      $key = strtoupper($this
        ->plugin());
    }
    $predicate = rules_plugin_factory('condition');
    $this
      ->setPredicate($predicate);
    $predicate
      ->import($export[$key]);
  }

  /**
   * Exports predicate with actions.
   */
  protected function exportChildren($key = NULL) {
    $export = $this
      ->exportPredicate();
    return $export + parent::exportChildren('DO');
  }

  /**
   * Exports predicate.
   */
  protected function exportPredicate($key = NULL) {
    $export = array();
    if (!isset($key)) {
      $key = strtoupper($this
        ->plugin());
    }
    if (isset($this->predicate)) {
      $export[$key] = $this->predicate
        ->export();
    }
    return $export;
  }
  protected function exportFlat() {
    return TRUE;
  }

}

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
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::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::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::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
RulesConditionalPredicateElement::$predicate protected property
RulesConditionalPredicateElement::canEvaluate public function Evaluates the predicate. Overrides RulesConditionalElement::canEvaluate
RulesConditionalPredicateElement::dependencies public function Calculates an array of required modules. Overrides RulesConditionalElement::dependencies
RulesConditionalPredicateElement::exportChildren protected function Exports predicate with actions. Overrides RulesConditionalElement::exportChildren
RulesConditionalPredicateElement::exportFlat protected function Determines whether the element should be exported in flat style. Overrides RulesContainerPlugin::exportFlat
RulesConditionalPredicateElement::exportPredicate protected function Exports predicate. 1
RulesConditionalPredicateElement::importChildren protected function Imports predicate. Overrides RulesConditionalElement::importChildren
RulesConditionalPredicateElement::importPredicate protected function Imports predicate. 1
RulesConditionalPredicateElement::integrityCheck public function Makes sure the plugin is configured right. Overrides RulesConditionalElement::integrityCheck
RulesConditionalPredicateElement::isNegated public function Returns whether the predicate is negated.
RulesConditionalPredicateElement::label public function Returns the label of the element. Overrides RulesConditionalElement::label
RulesConditionalPredicateElement::negate public function Negates the predicate.
RulesConditionalPredicateElement::pluginLabel public function 1
RulesConditionalPredicateElement::resetInternalCache public function Resets any internal static caches. Overrides RulesContainerPlugin::resetInternalCache
RulesConditionalPredicateElement::setPredicate protected function Sets a condition as predicate.
RulesConditionalPredicateElement::stateVariables protected function Adds predicate assertions to state. Overrides RulesContainerPlugin::stateVariables
RulesConditionalPredicateElement::__clone public function By default we do a deep clone. Overrides RulesContainerPlugin::__clone
RulesConditionalPredicateElement::__construct public function Overrides RulesActionContainer::__construct
RulesConditionalPredicateElement::__sleep public function Overrides RulesContainerPlugin::__sleep
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::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
RulesExtendable::$itemInfo protected property
RulesExtendable::$itemName protected property The name of the item this class represents in the info hook. 9
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::$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::pluginParameterInfo public function Returns info about parameters needed by the plugin. 2
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.