Package org.drools.model

Class PatternDSL

java.lang.Object

org.drools.model.DSL

org.drools.model.PatternDSL

public class PatternDSL
extends DSL

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	PatternDSL.CombinedPatternExprItem<T>
static interface	PatternDSL.ExchangeDef<T>
static class	PatternDSL.ExchangeDefImpl<T>
static class	PatternDSL.FixedTemporalPatternExpr<T>
static class	PatternDSL.LogicalCombiner
static class	PatternDSL.PatternBinding1<T,A>
static class	PatternDSL.PatternBinding2<T,U,A>
static class	PatternDSL.PatternBinding3<T,U,V,A>
static class	PatternDSL.PatternBinding4<T,U,V,W,A>
static class	PatternDSL.PatternBindingImpl<T,A>
static interface	PatternDSL.PatternDef<T>
static class	PatternDSL.PatternDefImpl<T>
static class	PatternDSL.PatternExpr1<T>
static class	PatternDSL.PatternExpr10<T,A,B,C,D,E,F,G,H,I>
static class	PatternDSL.PatternExpr11<T,A,B,C,D,E,F,G,H,I,J>
static class	PatternDSL.PatternExpr12<T,A,B,C,D,E,F,G,H,I,J,K>
static class	PatternDSL.PatternExpr13<T,A,B,C,D,E,F,G,H,I,J,K,L>
static class	PatternDSL.PatternExpr2<T,U>
static class	PatternDSL.PatternExpr3<T,A,B>
static class	PatternDSL.PatternExpr4<T,A,B,C>
static class	PatternDSL.PatternExpr5<T,A,B,C,D>
static class	PatternDSL.PatternExpr6<T,A,B,C,D,E>
static class	PatternDSL.PatternExpr7<T,A,B,C,D,E,F>
static class	PatternDSL.PatternExpr8<T,A,B,C,D,E,F,G,H>
static class	PatternDSL.PatternExpr9<T,A,B,C,D,E,F,G,H>
static class	PatternDSL.PatternExprImpl<T>
static interface	PatternDSL.PatternItem<T>
static class	PatternDSL.ReactOn
static class	PatternDSL.SubPatternDefImpl<T>
static class	PatternDSL.TemporalPatternExpr<T,U>

Constructor Summary

Constructors

Constructor	Description
PatternDSL()

Method Summary

Modifier and Type	Method	Description
static <T,U> AlphaIndex<T,U>	alphaIndexedBy(Class<U> indexedClass, Index.ConstraintType constraintType, int indexId, Function1<T,U> leftOperandExtractor, U rightValue)
static <T,U,V> BetaIndex<T,U,V>	betaIndexedBy(Class<V> indexedClass, Index.ConstraintType constraintType, int indexId, Function1<T,V> leftOperandExtractor, Function1<U,?> rightOperandExtractor)
static <T,U,V> BetaIndex<T,U,V>	betaIndexedBy(Class<V> indexedClass, Index.ConstraintType constraintType, int indexId, Function1<T,V> leftOperandExtractor, Function1<U,?> rightOperandExtractor, Class<?> rightReturnType)
static <T,A,B,V> BetaIndex2<T,A,B,V>	betaIndexedBy(Class<V> indexedClass, Index.ConstraintType constraintType, int indexId, Function1<T,V> leftOperandExtractor, Function2<A,B,?> rightOperandExtractor, Class<?> rightReturnType)
static <T,A,B,C,V> BetaIndex3<T,A,B,C,V>	betaIndexedBy(Class<V> indexedClass, Index.ConstraintType constraintType, int indexId, Function1<T,V> leftOperandExtractor, Function3<A,B,C,?> rightOperandExtractor, Class<?> rightReturnType)
static <T,A,B,C,D,V> BetaIndex4<T,A,B,C,D,V>	betaIndexedBy(Class<V> indexedClass, Index.ConstraintType constraintType, int indexId, Function1<T,V> leftOperandExtractor, Function4<A,B,C,D,?> rightOperandExtractor, Class<?> rightReturnType)
static <T> PatternDSL.PatternDef<T>	pattern(Variable<T> var)
static <T> PatternDSL.PatternDef<T>	pattern(Variable<T> var, DeclarationSource source)
static Query0Def	query(String name)
static <T1> Query1Def<T1>	query(String name, Class<T1> type1)
static <T1,T2> Query2Def<T1,T2>	query(String name, Class<T1> type1, Class<T2> type2)
static <T1,T2,T3> Query3Def<T1,T2,T3>	query(String name, Class<T1> type1, Class<T2> type2, Class<T3> type3)
static <T1,T2,T3,T4> Query4Def<T1,T2,T3,T4>	query(String name, Class<T1> type1, Class<T2> type2, Class<T3> type3, Class<T4> type4)
static <T1,T2,T3,T4,T5> Query5Def<T1,T2,T3,T4,T5>	query(String name, Class<T1> type1, Class<T2> type2, Class<T3> type3, Class<T4> type4, Class<T5> type5)
static <T1,T2,T3,T4,T5,T6> Query6Def<T1,T2,T3,T4,T5,T6>	query(String name, Class<T1> type1, Class<T2> type2, Class<T3> type3, Class<T4> type4, Class<T5> type5, Class<T6> type6)
static <T1,T2,T3,T4,T5,T6,T7> Query7Def<T1,T2,T3,T4,T5,T6,T7>	query(String name, Class<T1> type1, Class<T2> type2, Class<T3> type3, Class<T4> type4, Class<T5> type5, Class<T6> type6, Class<T7> type7)
static <T1,T2,T3,T4,T5,T6,T7,T8> Query8Def<T1,T2,T3,T4,T5,T6,T7,T8>	query(String name, Class<T1> type1, Class<T2> type2, Class<T3> type3, Class<T4> type4, Class<T5> type5, Class<T6> type6, Class<T7> type7, Class<T8> type8)
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Query9Def<T1,T2,T3,T4,T5,T6,T7,T8,T9>	query(String name, Class<T1> type1, Class<T2> type2, Class<T3> type3, Class<T4> type4, Class<T5> type5, Class<T6> type6, Class<T7> type7, Class<T8> type8, Class<T9> type9)
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Query10Def<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>	query(String name, Class<T1> type1, Class<T2> type2, Class<T3> type3, Class<T4> type4, Class<T5> type5, Class<T6> type6, Class<T7> type7, Class<T8> type8, Class<T9> type9, Class<T10> type10)
static <T1> Query1Def<T1>	query(String name, Class<T1> type1, String arg1name)
static <T1,T2> Query2Def<T1,T2>	query(String name, Class<T1> type1, String arg1name, Class<T2> type2, String arg2name)
static <T1,T2,T3> Query3Def<T1,T2,T3>	query(String name, Class<T1> type1, String arg1name, Class<T2> type2, String arg2name, Class<T3> type3, String arg3name)
static <T1,T2,T3,T4> Query4Def<T1,T2,T3,T4>	query(String name, Class<T1> type1, String arg1name, Class<T2> type2, String arg2name, Class<T3> type3, String arg3name, Class<T4> type4, String arg4name)
static <T1,T2,T3,T4,T5> Query5Def<T1,T2,T3,T4,T5>	query(String name, Class<T1> type1, String arg1name, Class<T2> type2, String arg2name, Class<T3> type3, String arg3name, Class<T4> type4, String arg4name, Class<T5> type5, String arg5name)
static <T1,T2,T3,T4,T5,T6> Query6Def<T1,T2,T3,T4,T5,T6>	query(String name, Class<T1> type1, String arg1name, Class<T2> type2, String arg2name, Class<T3> type3, String arg3name, Class<T4> type4, String arg4name, Class<T5> type5, String arg5name, Class<T6> type6, String arg6name)
static <T1,T2,T3,T4,T5,T6,T7> Query7Def<T1,T2,T3,T4,T5,T6,T7>	query(String name, Class<T1> type1, String arg1name, Class<T2> type2, String arg2name, Class<T3> type3, String arg3name, Class<T4> type4, String arg4name, Class<T5> type5, String arg5name, Class<T6> type6, String arg6name, Class<T7> type7, String arg7name)
static <T1,T2,T3,T4,T5,T6,T7,T8> Query8Def<T1,T2,T3,T4,T5,T6,T7,T8>	query(String name, Class<T1> type1, String arg1name, Class<T2> type2, String arg2name, Class<T3> type3, String arg3name, Class<T4> type4, String arg4name, Class<T5> type5, String arg5name, Class<T6> type6, String arg6name, Class<T7> type7, String arg7name, Class<T8> type8, String arg8name)
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Query9Def<T1,T2,T3,T4,T5,T6,T7,T8,T9>	query(String name, Class<T1> type1, String arg1name, Class<T2> type2, String arg2name, Class<T3> type3, String arg3name, Class<T4> type4, String arg4name, Class<T5> type5, String arg5name, Class<T6> type6, String arg6name, Class<T7> type7, String arg7name, Class<T8> type8, String arg8name, Class<T9> type9, String arg9name)
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Query10Def<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>	query(String name, Class<T1> type1, String arg1name, Class<T2> type2, String arg2name, Class<T3> type3, String arg3name, Class<T4> type4, String arg4name, Class<T5> type5, String arg5name, Class<T6> type6, String arg6name, Class<T7> type7, String arg7name, Class<T8> type8, String arg8name, Class<T9> type9, String arg9name, Class<T10> type10, String arg10name)
static Query0Def	query(String pkg, String name)
static <T1> Query1Def<T1>	query(String pkg, String name, Class<T1> type1)
static <T1,T2> Query2Def<T1,T2>	query(String pkg, String name, Class<T1> type1, Class<T2> type2)
static <T1,T2,T3> Query3Def<T1,T2,T3>	query(String pkg, String name, Class<T1> type1, Class<T2> type2, Class<T3> type3)
static <T1,T2,T3,T4> Query4Def<T1,T2,T3,T4>	query(String pkg, String name, Class<T1> type1, Class<T2> type2, Class<T3> type3, Class<T4> type4)
static <T1,T2,T3,T4,T5> Query5Def<T1,T2,T3,T4,T5>	query(String pkg, String name, Class<T1> type1, Class<T2> type2, Class<T3> type3, Class<T4> type4, Class<T5> type5)
static <T1,T2,T3,T4,T5,T6> Query6Def<T1,T2,T3,T4,T5,T6>	query(String pkg, String name, Class<T1> type1, Class<T2> type2, Class<T3> type3, Class<T4> type4, Class<T5> type5, Class<T6> type6)
static <T1,T2,T3,T4,T5,T6,T7> Query7Def<T1,T2,T3,T4,T5,T6,T7>	query(String pkg, String name, Class<T1> type1, Class<T2> type2, Class<T3> type3, Class<T4> type4, Class<T5> type5, Class<T6> type6, Class<T7> type7)
static <T1,T2,T3,T4,T5,T6,T7,T8> Query8Def<T1,T2,T3,T4,T5,T6,T7,T8>	query(String pkg, String name, Class<T1> type1, Class<T2> type2, Class<T3> type3, Class<T4> type4, Class<T5> type5, Class<T6> type6, Class<T7> type7, Class<T8> type8)
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Query9Def<T1,T2,T3,T4,T5,T6,T7,T8,T9>	query(String pkg, String name, Class<T1> type1, Class<T2> type2, Class<T3> type3, Class<T4> type4, Class<T5> type5, Class<T6> type6, Class<T7> type7, Class<T8> type8, Class<T9> type9)
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Query10Def<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>	query(String pkg, String name, Class<T1> type1, Class<T2> type2, Class<T3> type3, Class<T4> type4, Class<T5> type5, Class<T6> type6, Class<T7> type7, Class<T8> type8, Class<T9> type9, Class<T10> type10)
static <T1> Query1Def<T1>	query(String pkg, String name, Class<T1> type1, String arg1name)
static <T1,T2> Query2Def<T1,T2>	query(String pkg, String name, Class<T1> type1, String arg1name, Class<T2> type2, String arg2name)
static <T1,T2,T3> Query3Def<T1,T2,T3>	query(String pkg, String name, Class<T1> type1, String arg1name, Class<T2> type2, String arg2name, Class<T3> type3, String arg3name)
static <T1,T2,T3,T4> Query4Def<T1,T2,T3,T4>	query(String pkg, String name, Class<T1> type1, String arg1name, Class<T2> type2, String arg2name, Class<T3> type3, String arg3name, Class<T4> type4, String arg4name)
static <T1,T2,T3,T4,T5> Query5Def<T1,T2,T3,T4,T5>	query(String pkg, String name, Class<T1> type1, String arg1name, Class<T2> type2, String arg2name, Class<T3> type3, String arg3name, Class<T4> type4, String arg4name, Class<T5> type5, String arg5name)
static <T1,T2,T3,T4,T5,T6> Query6Def<T1,T2,T3,T4,T5,T6>	query(String pkg, String name, Class<T1> type1, String arg1name, Class<T2> type2, String arg2name, Class<T3> type3, String arg3name, Class<T4> type4, String arg4name, Class<T5> type5, String arg5name, Class<T6> type6, String arg6name)
static <T1,T2,T3,T4,T5,T6,T7> Query7Def<T1,T2,T3,T4,T5,T6,T7>	query(String pkg, String name, Class<T1> type1, String arg1name, Class<T2> type2, String arg2name, Class<T3> type3, String arg3name, Class<T4> type4, String arg4name, Class<T5> type5, String arg5name, Class<T6> type6, String arg6name, Class<T7> type7, String arg7name)
static <T1,T2,T3,T4,T5,T6,T7,T8> Query8Def<T1,T2,T3,T4,T5,T6,T7,T8>	query(String pkg, String name, Class<T1> type1, String arg1name, Class<T2> type2, String arg2name, Class<T3> type3, String arg3name, Class<T4> type4, String arg4name, Class<T5> type5, String arg5name, Class<T6> type6, String arg6name, Class<T7> type7, String arg7name, Class<T8> type8, String arg8name)
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Query9Def<T1,T2,T3,T4,T5,T6,T7,T8,T9>	query(String pkg, String name, Class<T1> type1, String arg1name, Class<T2> type2, String arg2name, Class<T3> type3, String arg3name, Class<T4> type4, String arg4name, Class<T5> type5, String arg5name, Class<T6> type6, String arg6name, Class<T7> type7, String arg7name, Class<T8> type8, String arg8name, Class<T9> type9, String arg9name)
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Query10Def<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>	query(String pkg, String name, Class<T1> type1, String arg1name, Class<T2> type2, String arg2name, Class<T3> type3, String arg3name, Class<T4> type4, String arg4name, Class<T5> type5, String arg5name, Class<T6> type6, String arg6name, Class<T7> type7, String arg7name, Class<T8> type8, String arg8name, Class<T9> type9, String arg9name, Class<T10> type10, String arg10name)
static PatternDSL.ReactOn	reactOn(String... reactOn)
static <T> PatternDSL.PatternDef<T>	receive(Exchange<T> exchange)
static RuleBuilder	rule(String name)
static RuleBuilder	rule(String pkg, String name)
static <T> PatternDSL.ExchangeDef<T>	send(Exchange<T> exchange)
static ConditionalConsequenceBuilder	when()
static <A> ConditionalConsequenceBuilder	when(String exprId, Variable<A> var, Predicate1<A> predicate)
static <A,B> ConditionalConsequenceBuilder	when(String exprId, Variable<A> var1, Variable<B> var2, Predicate2<A,B> predicate)
static <A> ConditionalConsequenceBuilder	when(Variable<A> var, Predicate1<A> predicate)
static <A,B> ConditionalConsequenceBuilder	when(Variable<A> var1, Variable<B> var2, Predicate2<A,B> predicate)
static ConditionalConsequenceBuilder	when(ExprViewItem expr)

Methods inherited from class org.drools.model.DSL

accFunction, accFunction, accFunction, accFunction, accumulate, after, after, after, after, and, annotationValue, any, before, before, before, before, coincides, coincides, coincides, combineExprs, declarationOf, declarationOf, declarationOf, declarationOf, declarationOf, declarationOf, declarationOf, declarationOf, declarationOf, declarationOf, declarationOf, declarationOf, declarationOf, declarationOf, declarationOf, declarationOf, during, during, during, entryPoint, eval, eval, exchangeOf, exchangeOf, execute, execute, executeScript, exists, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, expr, finishedby, finishedby, finishes, finishes, forall, from, from, from, from, from, from, from, globalOf, globalOf, groupBy, groupBy, groupBy, groupBy, includes, includes, includes, meets, meets, metby, metby, newDataStore, newDataStream, not, not, on, on, on, on, on, on, on, on, on, on, on, on, on, on, on, on, on, on, on, on, on, on, on, on, on, or, overlappedby, overlappedby, overlappedby, overlaps, overlaps, overlaps, reactiveFrom, startedby, startedby, starts, starts, storeOf, supply, supply, supply, supply, typeMetaData, unitData, unitData, valueOf, window, window, window, window, window, window

Methods inherited from class java.lang.Object

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

Constructor Detail

PatternDSL

public PatternDSL()

Method Detail

pattern

public static <T> PatternDSL.PatternDef<T> pattern(Variable<T> var)

pattern

public static <T> PatternDSL.PatternDef<T> pattern(Variable<T> var,
                                                   DeclarationSource source)

alphaIndexedBy

public static <T,U> AlphaIndex<T,U> alphaIndexedBy(Class<U> indexedClass,
                                                               Index.ConstraintType constraintType,
                                                               int indexId,
                                                               Function1<T,U> leftOperandExtractor,
                                                               U rightValue)

betaIndexedBy

public static <T,U,V> BetaIndex<T,U,V> betaIndexedBy(Class<V> indexedClass,
                                                                             Index.ConstraintType constraintType,
                                                                             int indexId,
                                                                             Function1<T,V> leftOperandExtractor,
                                                                             Function1<U,?> rightOperandExtractor)

betaIndexedBy

public static <T,U,V> BetaIndex<T,U,V> betaIndexedBy(Class<V> indexedClass,
                                                                             Index.ConstraintType constraintType,
                                                                             int indexId,
                                                                             Function1<T,V> leftOperandExtractor,
                                                                             Function1<U,?> rightOperandExtractor,
                                                                             Class<?> rightReturnType)

betaIndexedBy

public static <T,A,B,V> BetaIndex2<T,A,B,V> betaIndexedBy(Class<V> indexedClass,
                                                                                              Index.ConstraintType constraintType,
                                                                                              int indexId,
                                                                                              Function1<T,V> leftOperandExtractor,
                                                                                              Function2<A,B,?> rightOperandExtractor,
                                                                                              Class<?> rightReturnType)

betaIndexedBy

public static <T,A,B,C,V> BetaIndex3<T,A,B,C,V> betaIndexedBy(Class<V> indexedClass,
                                                                                                              Index.ConstraintType constraintType,
                                                                                                              int indexId,
                                                                                                              Function1<T,V> leftOperandExtractor,
                                                                                                              Function3<A,B,C,?> rightOperandExtractor,
                                                                                                              Class<?> rightReturnType)

betaIndexedBy

public static <T,A,B,C,D,V> BetaIndex4<T,A,B,C,D,V> betaIndexedBy(Class<V> indexedClass,
                                                                                                                              Index.ConstraintType constraintType,
                                                                                                                              int indexId,
                                                                                                                              Function1<T,V> leftOperandExtractor,
                                                                                                                              Function4<A,B,C,D,?> rightOperandExtractor,
                                                                                                                              Class<?> rightReturnType)

reactOn

public static PatternDSL.ReactOn reactOn(String... reactOn)

when

public static <A> ConditionalConsequenceBuilder when(Variable<A> var,
                                                     Predicate1<A> predicate)

when

public static <A> ConditionalConsequenceBuilder when(String exprId,
                                                     Variable<A> var,
                                                     Predicate1<A> predicate)

when

public static <A,B> ConditionalConsequenceBuilder when(Variable<A> var1,
                                                             Variable<B> var2,
                                                             Predicate2<A,B> predicate)

when

public static <A,B> ConditionalConsequenceBuilder when(String exprId,
                                                             Variable<A> var1,
                                                             Variable<B> var2,
                                                             Predicate2<A,B> predicate)

when

public static ConditionalConsequenceBuilder when(ExprViewItem expr)

when

public static ConditionalConsequenceBuilder when()

rule

public static RuleBuilder rule(String name)

rule

public static RuleBuilder rule(String pkg,
                               String name)

query

public static Query0Def query(String name)

query

public static Query0Def query(String pkg,
                              String name)

query

public static <T1> Query1Def<T1> query(String name,
                                       Class<T1> type1)

query

public static <T1> Query1Def<T1> query(String pkg,
                                       String name,
                                       Class<T1> type1)

query

public static <T1> Query1Def<T1> query(String name,
                                       Class<T1> type1,
                                       String arg1name)

query

public static <T1> Query1Def<T1> query(String pkg,
                                       String name,
                                       Class<T1> type1,
                                       String arg1name)

query

public static <T1,T2> Query2Def<T1,T2> query(String name,
                                                         Class<T1> type1,
                                                         Class<T2> type2)

query

public static <T1,T2> Query2Def<T1,T2> query(String pkg,
                                                         String name,
                                                         Class<T1> type1,
                                                         Class<T2> type2)

query

public static <T1,T2> Query2Def<T1,T2> query(String name,
                                                         Class<T1> type1,
                                                         String arg1name,
                                                         Class<T2> type2,
                                                         String arg2name)

query

public static <T1,T2> Query2Def<T1,T2> query(String pkg,
                                                         String name,
                                                         Class<T1> type1,
                                                         String arg1name,
                                                         Class<T2> type2,
                                                         String arg2name)

query

public static <T1,T2,T3> Query3Def<T1,T2,T3> query(String name,
                                                                           Class<T1> type1,
                                                                           Class<T2> type2,
                                                                           Class<T3> type3)

query

public static <T1,T2,T3> Query3Def<T1,T2,T3> query(String pkg,
                                                                           String name,
                                                                           Class<T1> type1,
                                                                           Class<T2> type2,
                                                                           Class<T3> type3)

query

public static <T1,T2,T3> Query3Def<T1,T2,T3> query(String name,
                                                                           Class<T1> type1,
                                                                           String arg1name,
                                                                           Class<T2> type2,
                                                                           String arg2name,
                                                                           Class<T3> type3,
                                                                           String arg3name)

query

public static <T1,T2,T3> Query3Def<T1,T2,T3> query(String pkg,
                                                                           String name,
                                                                           Class<T1> type1,
                                                                           String arg1name,
                                                                           Class<T2> type2,
                                                                           String arg2name,
                                                                           Class<T3> type3,
                                                                           String arg3name)

query

public static <T1,T2,T3,T4> Query4Def<T1,T2,T3,T4> query(String name,
                                                                                             Class<T1> type1,
                                                                                             Class<T2> type2,
                                                                                             Class<T3> type3,
                                                                                             Class<T4> type4)

query

public static <T1,T2,T3,T4> Query4Def<T1,T2,T3,T4> query(String pkg,
                                                                                             String name,
                                                                                             Class<T1> type1,
                                                                                             Class<T2> type2,
                                                                                             Class<T3> type3,
                                                                                             Class<T4> type4)

query

public static <T1,T2,T3,T4> Query4Def<T1,T2,T3,T4> query(String name,
                                                                                             Class<T1> type1,
                                                                                             String arg1name,
                                                                                             Class<T2> type2,
                                                                                             String arg2name,
                                                                                             Class<T3> type3,
                                                                                             String arg3name,
                                                                                             Class<T4> type4,
                                                                                             String arg4name)

query

public static <T1,T2,T3,T4> Query4Def<T1,T2,T3,T4> query(String pkg,
                                                                                             String name,
                                                                                             Class<T1> type1,
                                                                                             String arg1name,
                                                                                             Class<T2> type2,
                                                                                             String arg2name,
                                                                                             Class<T3> type3,
                                                                                             String arg3name,
                                                                                             Class<T4> type4,
                                                                                             String arg4name)

query

public static <T1,T2,T3,T4,T5> Query5Def<T1,T2,T3,T4,T5> query(String name,
                                                                                                               Class<T1> type1,
                                                                                                               Class<T2> type2,
                                                                                                               Class<T3> type3,
                                                                                                               Class<T4> type4,
                                                                                                               Class<T5> type5)

query

public static <T1,T2,T3,T4,T5> Query5Def<T1,T2,T3,T4,T5> query(String pkg,
                                                                                                               String name,
                                                                                                               Class<T1> type1,
                                                                                                               Class<T2> type2,
                                                                                                               Class<T3> type3,
                                                                                                               Class<T4> type4,
                                                                                                               Class<T5> type5)

query

public static <T1,T2,T3,T4,T5> Query5Def<T1,T2,T3,T4,T5> query(String name,
                                                                                                               Class<T1> type1,
                                                                                                               String arg1name,
                                                                                                               Class<T2> type2,
                                                                                                               String arg2name,
                                                                                                               Class<T3> type3,
                                                                                                               String arg3name,
                                                                                                               Class<T4> type4,
                                                                                                               String arg4name,
                                                                                                               Class<T5> type5,
                                                                                                               String arg5name)

query

public static <T1,T2,T3,T4,T5> Query5Def<T1,T2,T3,T4,T5> query(String pkg,
                                                                                                               String name,
                                                                                                               Class<T1> type1,
                                                                                                               String arg1name,
                                                                                                               Class<T2> type2,
                                                                                                               String arg2name,
                                                                                                               Class<T3> type3,
                                                                                                               String arg3name,
                                                                                                               Class<T4> type4,
                                                                                                               String arg4name,
                                                                                                               Class<T5> type5,
                                                                                                               String arg5name)

query

public static <T1,T2,T3,T4,T5,T6> Query6Def<T1,T2,T3,T4,T5,T6> query(String name,
                                                                                                                                 Class<T1> type1,
                                                                                                                                 Class<T2> type2,
                                                                                                                                 Class<T3> type3,
                                                                                                                                 Class<T4> type4,
                                                                                                                                 Class<T5> type5,
                                                                                                                                 Class<T6> type6)

query

public static <T1,T2,T3,T4,T5,T6> Query6Def<T1,T2,T3,T4,T5,T6> query(String pkg,
                                                                                                                                 String name,
                                                                                                                                 Class<T1> type1,
                                                                                                                                 Class<T2> type2,
                                                                                                                                 Class<T3> type3,
                                                                                                                                 Class<T4> type4,
                                                                                                                                 Class<T5> type5,
                                                                                                                                 Class<T6> type6)

query

public static <T1,T2,T3,T4,T5,T6> Query6Def<T1,T2,T3,T4,T5,T6> query(String name,
                                                                                                                                 Class<T1> type1,
                                                                                                                                 String arg1name,
                                                                                                                                 Class<T2> type2,
                                                                                                                                 String arg2name,
                                                                                                                                 Class<T3> type3,
                                                                                                                                 String arg3name,
                                                                                                                                 Class<T4> type4,
                                                                                                                                 String arg4name,
                                                                                                                                 Class<T5> type5,
                                                                                                                                 String arg5name,
                                                                                                                                 Class<T6> type6,
                                                                                                                                 String arg6name)

query

public static <T1,T2,T3,T4,T5,T6> Query6Def<T1,T2,T3,T4,T5,T6> query(String pkg,
                                                                                                                                 String name,
                                                                                                                                 Class<T1> type1,
                                                                                                                                 String arg1name,
                                                                                                                                 Class<T2> type2,
                                                                                                                                 String arg2name,
                                                                                                                                 Class<T3> type3,
                                                                                                                                 String arg3name,
                                                                                                                                 Class<T4> type4,
                                                                                                                                 String arg4name,
                                                                                                                                 Class<T5> type5,
                                                                                                                                 String arg5name,
                                                                                                                                 Class<T6> type6,
                                                                                                                                 String arg6name)

query

public static <T1,T2,T3,T4,T5,T6,T7> Query7Def<T1,T2,T3,T4,T5,T6,T7> query(String name,
                                                                                                                                                   Class<T1> type1,
                                                                                                                                                   Class<T2> type2,
                                                                                                                                                   Class<T3> type3,
                                                                                                                                                   Class<T4> type4,
                                                                                                                                                   Class<T5> type5,
                                                                                                                                                   Class<T6> type6,
                                                                                                                                                   Class<T7> type7)

query

public static <T1,T2,T3,T4,T5,T6,T7> Query7Def<T1,T2,T3,T4,T5,T6,T7> query(String pkg,
                                                                                                                                                   String name,
                                                                                                                                                   Class<T1> type1,
                                                                                                                                                   Class<T2> type2,
                                                                                                                                                   Class<T3> type3,
                                                                                                                                                   Class<T4> type4,
                                                                                                                                                   Class<T5> type5,
                                                                                                                                                   Class<T6> type6,
                                                                                                                                                   Class<T7> type7)

query

public static <T1,T2,T3,T4,T5,T6,T7> Query7Def<T1,T2,T3,T4,T5,T6,T7> query(String name,
                                                                                                                                                   Class<T1> type1,
                                                                                                                                                   String arg1name,
                                                                                                                                                   Class<T2> type2,
                                                                                                                                                   String arg2name,
                                                                                                                                                   Class<T3> type3,
                                                                                                                                                   String arg3name,
                                                                                                                                                   Class<T4> type4,
                                                                                                                                                   String arg4name,
                                                                                                                                                   Class<T5> type5,
                                                                                                                                                   String arg5name,
                                                                                                                                                   Class<T6> type6,
                                                                                                                                                   String arg6name,
                                                                                                                                                   Class<T7> type7,
                                                                                                                                                   String arg7name)

query

public static <T1,T2,T3,T4,T5,T6,T7> Query7Def<T1,T2,T3,T4,T5,T6,T7> query(String pkg,
                                                                                                                                                   String name,
                                                                                                                                                   Class<T1> type1,
                                                                                                                                                   String arg1name,
                                                                                                                                                   Class<T2> type2,
                                                                                                                                                   String arg2name,
                                                                                                                                                   Class<T3> type3,
                                                                                                                                                   String arg3name,
                                                                                                                                                   Class<T4> type4,
                                                                                                                                                   String arg4name,
                                                                                                                                                   Class<T5> type5,
                                                                                                                                                   String arg5name,
                                                                                                                                                   Class<T6> type6,
                                                                                                                                                   String arg6name,
                                                                                                                                                   Class<T7> type7,
                                                                                                                                                   String arg7name)

query

public static <T1,T2,T3,T4,T5,T6,T7,T8> Query8Def<T1,T2,T3,T4,T5,T6,T7,T8> query(String name,
                                                                                                                                                                     Class<T1> type1,
                                                                                                                                                                     Class<T2> type2,
                                                                                                                                                                     Class<T3> type3,
                                                                                                                                                                     Class<T4> type4,
                                                                                                                                                                     Class<T5> type5,
                                                                                                                                                                     Class<T6> type6,
                                                                                                                                                                     Class<T7> type7,
                                                                                                                                                                     Class<T8> type8)

query

public static <T1,T2,T3,T4,T5,T6,T7,T8> Query8Def<T1,T2,T3,T4,T5,T6,T7,T8> query(String pkg,
                                                                                                                                                                     String name,
                                                                                                                                                                     Class<T1> type1,
                                                                                                                                                                     Class<T2> type2,
                                                                                                                                                                     Class<T3> type3,
                                                                                                                                                                     Class<T4> type4,
                                                                                                                                                                     Class<T5> type5,
                                                                                                                                                                     Class<T6> type6,
                                                                                                                                                                     Class<T7> type7,
                                                                                                                                                                     Class<T8> type8)

query

public static <T1,T2,T3,T4,T5,T6,T7,T8> Query8Def<T1,T2,T3,T4,T5,T6,T7,T8> query(String name,
                                                                                                                                                                     Class<T1> type1,
                                                                                                                                                                     String arg1name,
                                                                                                                                                                     Class<T2> type2,
                                                                                                                                                                     String arg2name,
                                                                                                                                                                     Class<T3> type3,
                                                                                                                                                                     String arg3name,
                                                                                                                                                                     Class<T4> type4,
                                                                                                                                                                     String arg4name,
                                                                                                                                                                     Class<T5> type5,
                                                                                                                                                                     String arg5name,
                                                                                                                                                                     Class<T6> type6,
                                                                                                                                                                     String arg6name,
                                                                                                                                                                     Class<T7> type7,
                                                                                                                                                                     String arg7name,
                                                                                                                                                                     Class<T8> type8,
                                                                                                                                                                     String arg8name)

query

public static <T1,T2,T3,T4,T5,T6,T7,T8> Query8Def<T1,T2,T3,T4,T5,T6,T7,T8> query(String pkg,
                                                                                                                                                                     String name,
                                                                                                                                                                     Class<T1> type1,
                                                                                                                                                                     String arg1name,
                                                                                                                                                                     Class<T2> type2,
                                                                                                                                                                     String arg2name,
                                                                                                                                                                     Class<T3> type3,
                                                                                                                                                                     String arg3name,
                                                                                                                                                                     Class<T4> type4,
                                                                                                                                                                     String arg4name,
                                                                                                                                                                     Class<T5> type5,
                                                                                                                                                                     String arg5name,
                                                                                                                                                                     Class<T6> type6,
                                                                                                                                                                     String arg6name,
                                                                                                                                                                     Class<T7> type7,
                                                                                                                                                                     String arg7name,
                                                                                                                                                                     Class<T8> type8,
                                                                                                                                                                     String arg8name)

query

public static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Query9Def<T1,T2,T3,T4,T5,T6,T7,T8,T9> query(String name,
                                                                                                                                                                                       Class<T1> type1,
                                                                                                                                                                                       Class<T2> type2,
                                                                                                                                                                                       Class<T3> type3,
                                                                                                                                                                                       Class<T4> type4,
                                                                                                                                                                                       Class<T5> type5,
                                                                                                                                                                                       Class<T6> type6,
                                                                                                                                                                                       Class<T7> type7,
                                                                                                                                                                                       Class<T8> type8,
                                                                                                                                                                                       Class<T9> type9)

query

public static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Query9Def<T1,T2,T3,T4,T5,T6,T7,T8,T9> query(String pkg,
                                                                                                                                                                                       String name,
                                                                                                                                                                                       Class<T1> type1,
                                                                                                                                                                                       Class<T2> type2,
                                                                                                                                                                                       Class<T3> type3,
                                                                                                                                                                                       Class<T4> type4,
                                                                                                                                                                                       Class<T5> type5,
                                                                                                                                                                                       Class<T6> type6,
                                                                                                                                                                                       Class<T7> type7,
                                                                                                                                                                                       Class<T8> type8,
                                                                                                                                                                                       Class<T9> type9)

query

public static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Query9Def<T1,T2,T3,T4,T5,T6,T7,T8,T9> query(String name,
                                                                                                                                                                                       Class<T1> type1,
                                                                                                                                                                                       String arg1name,
                                                                                                                                                                                       Class<T2> type2,
                                                                                                                                                                                       String arg2name,
                                                                                                                                                                                       Class<T3> type3,
                                                                                                                                                                                       String arg3name,
                                                                                                                                                                                       Class<T4> type4,
                                                                                                                                                                                       String arg4name,
                                                                                                                                                                                       Class<T5> type5,
                                                                                                                                                                                       String arg5name,
                                                                                                                                                                                       Class<T6> type6,
                                                                                                                                                                                       String arg6name,
                                                                                                                                                                                       Class<T7> type7,
                                                                                                                                                                                       String arg7name,
                                                                                                                                                                                       Class<T8> type8,
                                                                                                                                                                                       String arg8name,
                                                                                                                                                                                       Class<T9> type9,
                                                                                                                                                                                       String arg9name)

query

public static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Query9Def<T1,T2,T3,T4,T5,T6,T7,T8,T9> query(String pkg,
                                                                                                                                                                                       String name,
                                                                                                                                                                                       Class<T1> type1,
                                                                                                                                                                                       String arg1name,
                                                                                                                                                                                       Class<T2> type2,
                                                                                                                                                                                       String arg2name,
                                                                                                                                                                                       Class<T3> type3,
                                                                                                                                                                                       String arg3name,
                                                                                                                                                                                       Class<T4> type4,
                                                                                                                                                                                       String arg4name,
                                                                                                                                                                                       Class<T5> type5,
                                                                                                                                                                                       String arg5name,
                                                                                                                                                                                       Class<T6> type6,
                                                                                                                                                                                       String arg6name,
                                                                                                                                                                                       Class<T7> type7,
                                                                                                                                                                                       String arg7name,
                                                                                                                                                                                       Class<T8> type8,
                                                                                                                                                                                       String arg8name,
                                                                                                                                                                                       Class<T9> type9,
                                                                                                                                                                                       String arg9name)

query

public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Query10Def<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> query(String name,
                                                                                                                                                                                                            Class<T1> type1,
                                                                                                                                                                                                            Class<T2> type2,
                                                                                                                                                                                                            Class<T3> type3,
                                                                                                                                                                                                            Class<T4> type4,
                                                                                                                                                                                                            Class<T5> type5,
                                                                                                                                                                                                            Class<T6> type6,
                                                                                                                                                                                                            Class<T7> type7,
                                                                                                                                                                                                            Class<T8> type8,
                                                                                                                                                                                                            Class<T9> type9,
                                                                                                                                                                                                            Class<T10> type10)

query

public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Query10Def<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> query(String pkg,
                                                                                                                                                                                                            String name,
                                                                                                                                                                                                            Class<T1> type1,
                                                                                                                                                                                                            Class<T2> type2,
                                                                                                                                                                                                            Class<T3> type3,
                                                                                                                                                                                                            Class<T4> type4,
                                                                                                                                                                                                            Class<T5> type5,
                                                                                                                                                                                                            Class<T6> type6,
                                                                                                                                                                                                            Class<T7> type7,
                                                                                                                                                                                                            Class<T8> type8,
                                                                                                                                                                                                            Class<T9> type9,
                                                                                                                                                                                                            Class<T10> type10)

query

public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Query10Def<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> query(String name,
                                                                                                                                                                                                            Class<T1> type1,
                                                                                                                                                                                                            String arg1name,
                                                                                                                                                                                                            Class<T2> type2,
                                                                                                                                                                                                            String arg2name,
                                                                                                                                                                                                            Class<T3> type3,
                                                                                                                                                                                                            String arg3name,
                                                                                                                                                                                                            Class<T4> type4,
                                                                                                                                                                                                            String arg4name,
                                                                                                                                                                                                            Class<T5> type5,
                                                                                                                                                                                                            String arg5name,
                                                                                                                                                                                                            Class<T6> type6,
                                                                                                                                                                                                            String arg6name,
                                                                                                                                                                                                            Class<T7> type7,
                                                                                                                                                                                                            String arg7name,
                                                                                                                                                                                                            Class<T8> type8,
                                                                                                                                                                                                            String arg8name,
                                                                                                                                                                                                            Class<T9> type9,
                                                                                                                                                                                                            String arg9name,
                                                                                                                                                                                                            Class<T10> type10,
                                                                                                                                                                                                            String arg10name)

query

public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Query10Def<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> query(String pkg,
                                                                                                                                                                                                            String name,
                                                                                                                                                                                                            Class<T1> type1,
                                                                                                                                                                                                            String arg1name,
                                                                                                                                                                                                            Class<T2> type2,
                                                                                                                                                                                                            String arg2name,
                                                                                                                                                                                                            Class<T3> type3,
                                                                                                                                                                                                            String arg3name,
                                                                                                                                                                                                            Class<T4> type4,
                                                                                                                                                                                                            String arg4name,
                                                                                                                                                                                                            Class<T5> type5,
                                                                                                                                                                                                            String arg5name,
                                                                                                                                                                                                            Class<T6> type6,
                                                                                                                                                                                                            String arg6name,
                                                                                                                                                                                                            Class<T7> type7,
                                                                                                                                                                                                            String arg7name,
                                                                                                                                                                                                            Class<T8> type8,
                                                                                                                                                                                                            String arg8name,
                                                                                                                                                                                                            Class<T9> type9,
                                                                                                                                                                                                            String arg9name,
                                                                                                                                                                                                            Class<T10> type10,
                                                                                                                                                                                                            String arg10name)

send

public static <T> PatternDSL.ExchangeDef<T> send(Exchange<T> exchange)

receive

public static <T> PatternDSL.PatternDef<T> receive(Exchange<T> exchange)