casecontent_condition : casecontent_condition COMMA expression
164860
def p_casecontent_condition_single(self, p):
        ''
        p[0] = p[1] + (p[3],)
        p.set_lineno(0, p.lineno(1))
478579
private void writeOutTypeCondition(BytecodeContext bc) throws TransformerException {
	WhileVisitor whileVisitor = new WhileVisitor();
	loopVisitor = whileVisitor;
	whileVisitor.visitBeforeExpression(bc);
	bc.getFactory().toExprBoolean(getAttribute("condition").getValue()).writeOut(bc, Expression.MODE_VALUE);
	whileVisitor.visitAfterExpressionBeforeBody(bc);
	getBody().writeOut(bc);
	whileVisitor.visitAfterBody(bc, getEnd());

    }
500831
def parse_case(self, node):
        
        
        try:
            condition = node.lattrib['condition']
        except:
            condition = None
            
        try:
            value = node.lattrib['value']
        except:
            self.raise_error('<Case> must specify a value')

        self.current_conditional_derived_variable.add_case(Case(condition, value))
1309403
def p_lconst_case_list(self, p):
        ''''''
        if len(p) == 4:
            p[0] = [('lconst', (p[1], p[3]))]
        elif len(p) == 6:
            p[1].append(('lconst', (p[3], p[5])))
            p[0] = p[1]
418202
static Node getConditionExpression(Node n) {
    switch (n.getToken()) {
      case IF:
      case WHILE:
        return n.getFirstChild();
      case DO:
        return n.getLastChild();
      case FOR:
        return n.getSecondChild();
      case FOR_IN:
      case FOR_OF:
      case FOR_AWAIT_OF:
      case CASE:
        return null;
      default:
        break;
    }
    throw new IllegalArgumentException(n + " does not have a condition.");
  }
20330
void setInConditionsAsTables() {

        for (int i = rangeVariables.length - 1; i >= 0; i--) {
            RangeVariable rangeVar = rangeVariables[i];
            Expression    in       = inExpressions[i];

            if (in != null) {
                Index index = rangeVar.rangeTable.getIndexForColumn(
                    in.getLeftNode().nodes[0].getColumnIndex());
                RangeVariable newRangeVar =
                    new RangeVariable(in.getRightNode().subQuery.getTable(),
                                      null, null, null, compileContext);
                RangeVariable[] newList =
                    new RangeVariable[rangeVariables.length + 1];

                ArrayUtil.copyAdjustArray(rangeVariables, newList,
                                          newRangeVar, i, 1);

                rangeVariables = newList;

                // make two columns as arg
                ColumnSchema left = rangeVar.rangeTable.getColumn(
                    in.getLeftNode().nodes[0].getColumnIndex());
                ColumnSchema right = newRangeVar.rangeTable.getColumn(0);
                Expression e = new ExpressionLogical(rangeVar, left,
                                                     newRangeVar, right);

                rangeVar.addIndexCondition(e, index, flags[i]);
            }
        }
    }
13810
def p_case_list(p):
    ''''''
    if len(p) == 6:
        p[0] = p[1] + [ast.Case(p[3], p[5], lineno=p.lineno(2))]
    elif len(p) == 5:
        p[0] = p[1] + [ast.Default(p[4], lineno=p.lineno(2))]
    else:
        p[0] = []
1278772
def _active_case(self, value: ObjectValue) -> Optional["CaseNode"]:
        """"""
        for c in self.children:
            for cc in c.data_children():
                if cc.iname() in value:
                    return c
1131189
public static function writeCondition($content, $condition = null, $global = false)
    {
        if (empty($condition)) {
            return $content;
        }
        return '<!--[' . $condition . ']>'
            . ($global ? '<!-->' : '')
            . ' ' . $content . ' '
            . ($global ? '<!--' : '')
            . '<![endif]-->';
    }
590822
def _condition_as_sql(self, qn, connection):
        '''
        
        '''
        def escape(value):
            if isinstance(value, bool):
                value = str(int(value))
            if isinstance(value, six.string_types):
                # Escape params used with LIKE
                if '%' in value:
                    value = value.replace('%', '%%')
                # Escape single quotes
                if "'" in value:
                    value = value.replace("'", "''")
                # Add single quote to text values
                value = "'" + value + "'"
            return value

        sql, param = self.condition.query.where.as_sql(qn, connection)
        param = map(escape, param)

        return sql % tuple(param)
19919
def p_case_list(p):
    
    if len(p) == 1:
        p[0] = node.stmt_list()
    elif len(p) == 3:
        assert isinstance(p[2], node.stmt_list)
        p[0] = p[2]
    elif len(p) == 6:
        p[0] = node.if_stmt(
            cond_expr=node.expr(
                op="==", args=node.expr_list([p[2]])),
            then_stmt=p[4],
            else_stmt=p[5])
        p[0].cond_expr.args.append(
            None)  # None will be replaced using backpatch()
    else:
        assert 0
742911
public static void ensureNotEmptyContent( String name, boolean trim, String[] value )
    {
        ensureNotEmpty( name, value );
        for ( int i = 0; i < value.length; i++ ) {
            ensureNotEmpty( value[i] + "[" + i + "]", value[i] );
            if ( trim ) {
                ensureNotEmpty( value[i] + "[" + i + "]", value[i].trim() );
            }
        }
    }
793997
def ContainsIgnoreCase(self, value):
    
    self._awql = self._CreateSingleValueCondition(value, 'CONTAINS_IGNORE_CASE')
    return self._query_builder
1207511
public function compileConditions()
    {
        $ret = [];
        if (!empty($this->conditions)) {
            $ret['where'] = implode(' ', $this->conditions);
        }
        return $ret;
    }
1169245
def p_case_clause(self, p):
        """"""
        p[0] = self.asttypes.Case(expr=p[2], elements=p[4])
        p[0].setpos(p)
668052
private Optional<IndexBooleanExpression> getSupplementaryCondition(Set<String> allColumnsInColumnRelations, Map<String, Set<Object>> condition) {
        Map<String, Set<Object>> fixedValuesMap = condition.keySet().stream()
                .filter(cn -> !allColumnsInColumnRelations.contains(cn))
                .collect(Collectors.toMap(Function.identity(), condition::get));
        return fixedValuesMap.isEmpty() ?
                Optional.empty() :
                Optional.of(new IndexBooleanExpression(fixedValuesMap));
    }
1287949
def to_mixed_case(s):
    
    out = ''
    last_c = ''
    for c in s:
        if c == '_':
            pass
        elif last_c in ('', '_'):
            out += c.upper()
        else:
            out += c.lower()
        last_c = c
    return out