How to use com.oath.cyclops.matching

Best Java code snippets using com.oath.cyclops.matching (Showing top 20 results out of 315)

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 OutputStreamWriter o =OutputStream out;new OutputStreamWriter(out)
OutputStream out;String charsetName;new OutputStreamWriter(out, charsetName)
HttpURLConnection connection;new OutputStreamWriter(connection.getOutputStream())
Smart code suggestions by Tabnine
}

public static <T, R> Case<T, R> Case(Pattern<T> pattern1, Pattern<T> pattern2, Function<T, R> supplier) {
  return new Case.Case0<>(pattern1.and(pattern2), supplier);
}

public static <T extends Deconstruct1<T1>, T1> PatternMatching<Tuple1<T1>> Match(T value) {
  return new PatternMatching<>(value.unapply());
}

public static <T extends Deconstruct2<T1, T2>, T1, T2> PatternMatching<Tuple2<T1, T2>> Match(T value) {
  return new PatternMatching<>(value.unapply());
}

public static <T extends Deconstruct4<T1, T2, T3, T4>, T1, T2, T3, T4> PatternMatching<Tuple4<T1, T2, T3, T4>> Match(T value) {
  return new PatternMatching<>(value.unapply());
}

public static <T extends Deconstruct<T1>, T1> PatternMatching<T1> Match(T value) {
  return new PatternMatching<>(value.unapply());
}

public static <T extends Deconstruct3<T1, T2, T3>, T1, T2, T3> PatternMatching<Tuple3<T1, T2, T3>> Match(T value) {
  return new PatternMatching<>(value.unapply());
}

public static <T extends Deconstruct5<T1, T2, T3, T4, T5>, T1, T2, T3, T4, T5> PatternMatching<Tuple5<T1, T2, T3, T4, T5>> Match(T value) {
  return new PatternMatching<>(value.unapply());
}

public <R> R with(Case<T1, R> case1, Case<T2, R> case2, Case<T3, R> case3, Case<T4, R> case4, Case<T5, R> case5) {
  return value.fold(a -> case1.test(a), b -> case2.test(b), c -> case3.test(c), d -> case4.test(d), e -> case5.test(e)).orElse(null);
}

public <R> R with(Case<T1, R> case1, Case<T2, R> case2, Case<T3, R> case3, Case<T4, R> case4) {
  return value.fold(a -> case1.test(a), b -> case2.test(b), c -> case3.test(c), d -> case4.test(d)).orElse(null);
}

public <R> R with(Case<T1, R> case1, Case<T2, R> case2, Case<T3, R> case3) {
  return value.fold(a -> case1.test(a), b -> case2.test(b), c -> case3.test(c)).orElse(null);
}

public static <T, R> Case<Optional<T>, R> Case(Supplier<R> supplier0, Supplier<R> supplier1) {
  return new Case.CaseOptional<>(supplier0, supplier1);
}

public static <T, R> Case<T, R> Case(Predicate<T> predicate, Function<T, R> supplier) {
  return new Case.Case0<>(predicate, supplier);
}

public static <T1, T2, T3, T4, T5, R> Case<Tuple5<T1, T2, T3, T4, T5>, R> Case(Predicate<T1> predicate1, Predicate<T2> predicate2, Predicate<T3> predicate3, Predicate<T4> predicate4, Predicate<T5> predicate5, Function<Tuple5<T1, T2, T3, T4, T5>, R> fn) {
  return new Case.Case5<>(predicate1, predicate2, predicate3, predicate4, predicate5, fn);
}

public static <T> OptionalMatching<T> Match(final Optional<T> value) {
  return new OptionalMatching<T>(value);
}

public static <T1, T2> Matching.PatternMatching2<T1, T2> MatchType(Sealed2<T1, T2> value) {
  return new Matching.PatternMatching2<>(value);
}

public static <T1, T2, T3, T4, T5> PatternMatching5<T1, T2, T3, T4, T5> MatchType(Sealed5<T1, T2, T3, T4, T5> value) {
  return new PatternMatching5<>(value);
}

public static <T, R> Case<T, R> Case(Function<? super T, ? extends R> fn) {
  return new Case.CaseFn(fn);
}

public void dataSaver(int data){
 remote.save(data);
}
public int remoteStringLength(String data){

public String dataLoader(){
 return remote.data();
}
public void dataSaver(int data){

public static <T, R> Case<T, R> Case(Pattern<T> pattern1, Pattern<T> pattern2, Supplier<R> supplier) {
  return new Case.Case0<>(pattern1.and(pattern2), value -> supplier.get());
}