Visit `Conditional`.

@param {Conditional} cond
@api public
774348
function(cond){
    var test = cond.test;

    var blockConsequent = this.visit(cond.consequent, cond);
    var c = t.ifStatement(
      cond.astTest || this.parseExpr(test),
      t.blockStatement(blockConsequent)
    );


    if (cond.alternate) {
      if (cond.alternate.type === 'Conditional') {
        c.alternate = this.visitConditional(cond.alternate)[0];
      } else {
        var blockAlternate = this.visit(cond.alternate, cond);
        c.alternate = t.blockStatement(blockAlternate);
      }
    }
    return [c];
  }
418903
public PropertyConstraint ifTrue(PropertyConstraint ifConstraint, PropertyConstraint thenConstraint,
			PropertyConstraint elseConstraint) {
		return new ConditionalPropertyConstraint(ifConstraint, thenConstraint, elseConstraint);
	}
479759
public function cond($cond, $dash=false)
	{
		$ds = $this->ds();
		return SqlHelper::parse_cond($ds, $cond, $dash);
	}
1174233
public function orWhere($cond)
    {
        if (is_array($cond)) {
            foreach ($cond as $key => $val) {
                if (is_string($key)) {
                    $this->addWhere('OR', array($key, $val));
                } else {
                    $this->addWhere('OR', array($val));
                }
            }
        } else {
            $this->addWhere('OR', func_get_args());
        }
        return $this;
    }
1055056
protected function fixJoinCondition($cond)
    {
        if (!$cond) {
            return '';
        }

        $cond = $this->quoteNamesIn($cond);

        if (strtoupper(substr(ltrim($cond), 0, 3)) == 'ON ') {
            return $cond;
        }

        if (strtoupper(substr(ltrim($cond), 0, 6)) == 'USING ') {
            return $cond;
        }

        return 'ON ' . $cond;
    }
1180325
def _iterate_fields_cond(self, pkt, val, use_val):
        """"""
        # Iterate through the fields
        for fld, cond in self.flds:
            if isinstance(cond, tuple):
                if use_val:
                    if cond[1](pkt, val):
                        return fld
                    continue
                else:
                    cond = cond[0]
            if cond(pkt):
                return fld
        return self.dflt
839888
public function searchAll(array $cond = array(), $order = false): array
    {
        $options = array(
            'order' => $order,
            'count' => 0,
            'offset' => 0
        );

        $result = $this->search($cond, $options);

        return $result->getAllResults();
    }
394718
def _cond(self, unused_x, unused_cumul_out, unused_prev_state,
            unused_cumul_state, cumul_halting, unused_iteration,
            unused_remainder):
    """"""
    return tf.reduce_any(cumul_halting < 1)
457033
function Base(condition, negate) {
  // Set up flags
  var self = this;
  this.flags = {
    not: false,
    deep: false,
    chain: false,
    noCase: false,
    unordered: false
  };

  // Add this condition to the current list
  this.current = [{
    val: condition,
    negate: negate,
    actual: condition
  }];

  // Set up helpers
  _.each(['And', 'But', 'Or', 'Xor'], function(joiner) {
    self.__defineGetter__(joiner, function() {
      return utils.delegate(self.test(), joiner.toLowerCase());
    });
  });
  _.each(['does', 'should', 'has', 'have', 'is', 'to', 'be', 'been'], function(getter) {
    self.__defineGetter__(getter, function() {
      return self;
    });
  });
  _.each(['deep', 'deeply'], function(getter) {
    self.__defineGetter__(getter, function() {
      self.flags.deep = true;
      return self;
    });
  });
  self.__defineGetter__('roughly', function() {
    self.flags.unordered = true;
    return self;
  });
  self.__defineGetter__('not', function() {
    self.flags.not = true;
    return self;
  });
  self.__defineGetter__('Not', function() {
    self.flags.groupNot = true;
    return self;
  });
  _.each(['noCase', 'caseless'], function(getter) {
    self.__defineGetter__(getter, function() {
      self.flags.noCase = true;
      return self;
    });
  });
}
1262934
private boolean conditionalExclude(int tPosBegin, int tPosEnd) {
        if (isCondEnabled(condLevel)) {
            return false;
        }
        excludeTemplateRange(tPosBegin, tPosEnd);
        return true;
    }
473198
public void add(CharRange cond)
    {
        if (set.isEmpty())
        {
            set.add(cond);
        }
        else
        {
            List<CharRange> remlist = new ArrayList<CharRange>();
            List<CharRange> addlist = new ArrayList<CharRange>();
            boolean is = false;
            for (CharRange r : set)
            {
                if (r.intersect(cond))
                {
                    remlist.add(r);
                    addlist.addAll(CharRange.removeOverlap(cond, r));
                    is = true;
                }
            }
            if (!is)
            {
                set.add(cond);
            }
            set.removeAll(remlist);
            set.addAll(addlist);
        }
    }
232225
function rangeWhile(cond, fn) {
    var i = 0, res = [];

    while(cond(i)) {
        res[i] = fn(i);
        i++;
    }
    return res;
}
957647
Node createIf(Node cond, Node then) {
    return IR.ifNode(cond, then);
  }
883321
protected function sort($data,$cond) {
		$cols=\Base::instance()->split($cond);
		uasort(
			$data,
			function($val1,$val2) use($cols) {
				foreach ($cols as $col) {
					$parts=explode(' ',$col,2);
					$order=empty($parts[1])?
						SORT_ASC:
						constant($parts[1]);
					$col=$parts[0];
					if (!array_key_exists($col,$val1))
						$val1[$col]=NULL;
					if (!array_key_exists($col,$val2))
						$val2[$col]=NULL;
					list($v1,$v2)=[$val1[$col],$val2[$col]];
					if ($out=strnatcmp($v1,$v2)*
						(($order==SORT_ASC)*2-1))
						return $out;
				}
				return 0;
			}
		);
		return $data;
	}
793633
function() {
    this.expect('unless');
    this.state.push('conditional');
    this.cond = true;
    var node = new nodes.If(this.expression(), true);
    this.cond = false;
    node.block = this.block(node, false);
    this.state.pop();
    return node;
  }
371233
public static boolean and(final INDArray n, final Condition cond) {
        if (cond instanceof BaseCondition) {
            long val = (long) Nd4j.getExecutioner().exec(new MatchCondition(n, cond)).getDouble(0);

            if (val == n.length())
                return true;
            else
                return false;

        } else {
            throw new RuntimeException("Can only execute BaseCondition conditions using this method");
        }
    }
995374
public function _elseif($cond)
    {
        if (!$this->conditionalProxy) {
            throw new LogicException(__METHOD__ .' must be called after _if()');
        }

        return $this->conditionalProxy->_elseif($cond);
    }