cyclops.companion

Class Xors

java.lang.Object

cyclops.companion.Xors

public class Xors
extends java.lang.Object

This class contains static methods for Structural Pattern matching

Constructor Summary

Constructors

Constructor and Description
Xors()

Method Summary

Modifier and Type	Method and Description
static <T> Xor<Queue<T>,Topic<T>>	adapter(Adapter<T> adapter) Create a Pattern Matcher on cyclops2-react adapter type (note this will only match on known types within the cyclops2-react library)
static <W extends WitnessType<W>,T> Xor<AnyMValue<W,T>,AnyMSeq<W,T>>	anyM(AnyM<W,T> anyM) Pattern Match on a FutureW handling success and failure cases differently
static <T> Xor<java.util.concurrent.BlockingQueue<T>,java.util.Queue<T>>	blocking(java.util.Queue<T> queue) Pattern matching on the blocking / non-blocking nature of a Queue

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Xors

public Xors()

Method Detail

adapter

public static <T> Xor<Queue<T>,Topic<T>> adapter(Adapter<T> adapter)

Create a Pattern Matcher on cyclops2-react adapter type (note this will only match on known types within the cyclops2-react library)

  
     Adapter<Integer> adapter = QueueFactories.<Integer>unboundedQueue()
                                              .build();
                                              
     String result =   Xors.adapter(adapter)
                                       .visit(queue->"we have a queue",topic->"we have a topic");
                      
    //"we have a queue"                                                  
  
 

Parameters:

adapter - Adapter toNested match on

Returns:

Structural pattern matcher for Adapter types.

anyM

public static <W extends WitnessType<W>,T> Xor<AnyMValue<W,T>,AnyMSeq<W,T>> anyM(AnyM<W,T> anyM)

Pattern Match on a FutureW handling success and failure cases differently

  
  Eval<Integer> result = Xors.future(FutureW.ofResult(1))
                                         .matches(c-> c.is( when(some(1)), transform(10)),
                                                  c->c.is(when(instanceOf(RuntimeException.class)), transform(2)),
                                                  otherwise(3));
        
        //Eval.now[10]
 
  Eval<Integer> result = Xors.future(FutureW.ofError(new RuntimeException()))
                                         .matches(c-> c.is( when(some(10)), transform(2)),
                                                  c->c.is(when(instanceOf(RuntimeException.class)), transform(2)),
                                                  otherwise(3));
        
       //Eval.now(2)
 
 
 
 

Parameters:

future - Future toNested match on

Returns:

Pattern Matcher for Futures public static MXor future(final FutureW future) { return () -> future.toXor() .swap(); } USE EITHER public static MXor tryMatch(final Try match) { return () -> match.toXor() .swap(); }

blocking

public static <T> Xor<java.util.concurrent.BlockingQueue<T>,java.util.Queue<T>> blocking(java.util.Queue<T> queue)

Pattern matching on the blocking / non-blocking nature of a Queue

  
  Xors.blocking(new ManyToManyConcurrentArrayQueue(10))
                  .visit(c->"blocking", c->"not")
         //"not"
    
   
       Xors.blocking(new LinkedBlockingQueue(10))
                 .visit(c->"blocking", c->"not")
        //"blocking
 
 
 

Parameters:

queue - Queue toNested pattern match on

Returns:

Pattern matchier on the blocking / non-blocking nature of the supplied Queue