add a Case block to the expression

@param ca   the object for switch-expression to match
@param func function to apply when matches and return a result for
expression to return
@return <code>this</code>
345862
public SwitchBlock<T, R> Case(T ca, def<R> func) {
                if (!found) {
                        if (method.applyCheckPrimitive(boolean.class, toSwitch, ca)) {
                                res = func.apply();
                                found = true;
                        }
                }
                return this;
        }
70067
@Nonnull
	public <V1 extends T1, V2 extends T2> LToByteBiFunctionBuilder<T1, T2> aCase(Class<V1> argC1, Class<V2> argC2, LToByteBiFunction<V1, V2> function) {
		PartialCaseWithByteProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)) && (argC2 == null || argC2.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}
157288
public SwitchBuilder addCase(Expression caseLabel, Statement body) {
    clauses.add(new Switch.CaseClause(ImmutableList.of(caseLabel), body));
    return this;
  }
632293
@Nonnull
	public <V extends T> LConsumerBuilder<T> casesOf(Class<V> argC, Consumer<LConsumerBuilder<V>> pcpConsumer) {
		PartialCase.The pc = partialCaseFactoryMethod(a -> (argC == null || argC.isInstance(a)));

		pc.specifySubCases((Consumer) pcpConsumer);
		return self();
	}
972828
public static void mixin(final String funcName, final Function<String, String> func) {
        FUNCTIONS.put(funcName, func);
    }
976870
def add_function(self, func):
        
        for block in func.blocks:
            self.add_obj(block.addr, block)
1363130
@Nonnull
	public <V extends T> LConsumerBuilder<T> aCase(Class<V> argC, LConsumer<V> function) {
		PartialCase.The pc = partialCaseFactoryMethod(a -> (argC == null || argC.isInstance(a)));

		pc.evaluate(function);
		return self();
	}
946491
@Nonnull
	public <V extends T> LToIntFunctionBuilder<T> aCase(Class<V> argC, LToIntFunction<V> function) {
		PartialCaseWithIntProduct.The pc = partialCaseFactoryMethod(a -> (argC == null || argC.isInstance(a)));

		pc.evaluate(function);
		return self();
	}
707937
public function fold(callable $func, $acc) : self
    {
        $list = $this->list;

        foreach ($list as $val) {
            $acc = $func($acc, $val);
        }

        return new static($acc);
    }
153955
public <T extends Function> T addFunction(T function) {
		addItem(function, functions, "functions");
		return function;
	}
858529
private final void switchBlock(Data data, Body body) throws TemplateException {
	while (data.srcCode.isValidIndex()) {
	    comments(data);
	    if (data.srcCode.isCurrent("case ") || data.srcCode.isCurrent("default", ':') || data.srcCode.isCurrent('}')) return;

	    Body prior = data.setParent(body);
	    statement(data, body, CTX_SWITCH);
	    data.setParent(prior);
	}
    }
1175817
function bindInternal4(func, thisContext) {
    return function (a, b, c, d) {
      return func.call(thisContext, a, b, c, d);
    };
  }
824842
@Nonnull
	public <V1 extends T1, V2 extends T2, V3 extends T3> LToIntTriFunctionBuilder<T1, T2, T3> aCase(Class<V1> argC1, Class<V2> argC2, Class<V3> argC3, LToIntTriFunction<V1, V2, V3> function) {
		PartialCaseWithIntProduct.The pc = partialCaseFactoryMethod((a1, a2, a3) -> (argC1 == null || argC1.isInstance(a1)) && (argC2 == null || argC2.isInstance(a2)) && (argC3 == null || argC3.isInstance(a3)));

		pc.evaluate(function);
		return self();
	}
1131537
@Nonnull
	public <V extends T> LToCharFunctionBuilder<T> aCase(Class<V> argC, LToCharFunction<V> function) {
		PartialCaseWithCharProduct.The pc = partialCaseFactoryMethod(a -> (argC == null || argC.isInstance(a)));

		pc.evaluate(function);
		return self();
	}
1344937
public function setFunc($func)
    {
        if ($func === null) {
            $this->func = $func;
            return $this;
        }

        if (!is_string($func)) {
            throw new InvalidArgumentException(
                'Function name should be a string.'
            );
        }

        $func = strtoupper($func);
        if (!in_array($func, $this->validFunc())) {
            throw new InvalidArgumentException(sprintf(
                'Function "%s" not allowed in this context.',
                $func
            ));
        }

        $this->func = $func;
        return $this;
    }
1312329
public <R> AnimaQuery<T> and(TypeFunction<T, R> function, Object value) {
        return this.where(function, value);
    }
654166
@SuppressWarnings("unchecked")
  public T queue(final String name, Function... funcs) {
    for (final Function f : funcs) {
      for (Element e : elements()) {
        queue(e, name, f);
      }
    }
    return (T) this;
  }