org.cthul.matchers.fluent8 Class Hierarchy (Cthul Fluent Matchers Java 8 Lib 1.0 API)

Class Hierarchy

java.lang.Object
- org.cthul.matchers.fluent.builder.AbstractFluentStepBuilder<Value,BaseFluent,TheFluent,This> (implements org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>)
  - org.cthul.matchers.fluent.builder.AbstractFluentBuilder<Value,This> (implements org.cthul.matchers.fluent.ext.ExtensibleFluent<Value,This>)
    - org.cthul.matchers.fluent.builder.AbstractFluentAssertBuilder<Value,This> (implements org.cthul.matchers.fluent.ext.ExtensibleFluentAssert<Value,This>)
      - org.cthul.matchers.fluent.builder.FluentAssertBuilder<Value,This> (implements org.cthul.matchers.fluent.ext.ExtensibleFluentAssert<Value,This>)
        
        org.cthul.matchers.fluent8.BigDecimalFluent.Assert<Value> (implements org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ClassFluent.Assert<Value> (implements org.cthul.matchers.fluent8.ClassFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.CollectionFluent.Assert<T,Value> (implements org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ComparableFluent.Assert<C,Value> (implements org.cthul.matchers.fluent8.ComparableFluent<C,Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.DoubleFluent.Assert<Value> (implements org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ExceptionFluent.Assert<Value> (implements org.cthul.matchers.fluent8.ExceptionFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IntegerFluent.Assert<Value> (implements org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IterableFluent.Assert<T,Value> (implements org.cthul.matchers.fluent8.IterableFluent<T,Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.MapFluent.Assert<K,V,Value> (implements org.cthul.matchers.fluent8.MapFluent<K,V,Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ObjectFluent.Assert<Value> (implements org.cthul.matchers.fluent8.ObjectFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ProcFluent.Assert<Value> (implements org.cthul.matchers.fluent8.ProcFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.StringFluent.Assert<Value> (implements org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)
  - org.cthul.matchers.fluent.builder.FluentStepBuilder<Value,TheFluent,This>
    - org.cthul.matchers.fluent8.BigDecimalFluent.Step<Value,TheFluent,This> (implements org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.ClassFluent.Step<Value,TheFluent,This> (implements org.cthul.matchers.fluent8.ClassFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.CollectionFluent.Step<T,Value,TheFluent,This> (implements org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.ComparableFluent.Step<C,Value,TheFluent,This> (implements org.cthul.matchers.fluent8.ComparableFluent<C,Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.DoubleFluent.Step<Value,TheFluent,This> (implements org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.ExceptionFluent.Step<Value,TheFluent,This> (implements org.cthul.matchers.fluent8.ExceptionFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.IntegerFluent.Step<Value,TheFluent,This> (implements org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.IterableFluent.Step<T,Value,TheFluent,This> (implements org.cthul.matchers.fluent8.IterableFluent<T,Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.MapFluent.Step<K,V,Value,TheFluent,This> (implements org.cthul.matchers.fluent8.MapFluent<K,V,Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.ObjectFluent.Step<Value,TheFluent,This> (implements org.cthul.matchers.fluent8.ObjectFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.ProcFluent.Step<Value,TheFluent,This> (implements org.cthul.matchers.fluent8.ProcFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.StringFluent.Step<Value,TheFluent,This> (implements org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)

Interface Hierarchy

org.cthul.matchers.fluent8.FluentAssert
org.cthul.matchers.fluent.FluentStep<Value,TheFluent>
- org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>
  - org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent<C,Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.BigDecimalFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.BigDecimalFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
  - org.cthul.matchers.fluent8.ClassFluent<Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent8.ObjectFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.ClassFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.ClassFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
  - org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent8.IterableFluent<T,Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.CollectionFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IterableFluent.AndChain<T,Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.CollectionFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IterableFluent.OrChain<T,Value,TheFluent,This>)
  - org.cthul.matchers.fluent8.ComparableFluent<C,Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent8.ObjectFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.BigDecimalFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.BigDecimalFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.BigDecimalFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.DoubleFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.IntegerFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.StringFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.BigDecimalFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.DoubleFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.IntegerFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.StringFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.DoubleFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.DoubleFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.IntegerFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.IntegerFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.StringFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.StringFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
  - org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent<C,Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.DoubleFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.DoubleFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
  - org.cthul.matchers.fluent8.ExceptionFluent<Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent8.ObjectFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.ExceptionFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.ExceptionFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
  - org.cthul.matchers.fluent.ext.ExtensibleFluent<Value,This> (also extends org.cthul.matchers.fluent.Fluent<Value>)
    - org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>
      - org.cthul.matchers.fluent8.BigDecimalFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ClassFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ClassFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.CollectionFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.IterableFluent.AndChain<T,Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent<C,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.BigDecimalFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.DoubleFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IntegerFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.StringFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.DoubleFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.ExceptionFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ExceptionFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.IntegerFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.IterableFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.IterableFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.CollectionFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.MapFluent.AndChain<K,V,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.MapFluent<K,V,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ObjectFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ClassFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ClassFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent<C,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.BigDecimalFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.DoubleFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IntegerFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.StringFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ExceptionFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ExceptionFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IterableFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IterableFluent<T,Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.CollectionFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.MapFluent.AndChain<K,V,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.MapFluent<K,V,Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ProcFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ProcFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.ProcFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ProcFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.StringFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>
      - org.cthul.matchers.fluent8.BigDecimalFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ClassFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ClassFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.CollectionFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.IterableFluent.OrChain<T,Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent<C,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.BigDecimalFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.DoubleFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IntegerFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.StringFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.DoubleFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.ExceptionFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ExceptionFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.IntegerFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.IterableFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.IterableFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.CollectionFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.MapFluent.OrChain<K,V,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.MapFluent<K,V,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ObjectFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ClassFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ClassFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent<C,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.BigDecimalFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.DoubleFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IntegerFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.StringFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ExceptionFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ExceptionFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IterableFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IterableFluent<T,Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.CollectionFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.MapFluent.OrChain<K,V,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.MapFluent<K,V,Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ProcFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ProcFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.ProcFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ProcFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.StringFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)
  - org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent<C,Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.IntegerFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.IntegerFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
  - org.cthul.matchers.fluent8.IterableFluent<T,Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent8.ObjectFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.CollectionFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IterableFluent.AndChain<T,Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.CollectionFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IterableFluent.OrChain<T,Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.IterableFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.CollectionFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.IterableFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.CollectionFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
  - org.cthul.matchers.fluent8.MapFluent<K,V,Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent8.ObjectFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.MapFluent.AndChain<K,V,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.MapFluent.OrChain<K,V,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
  - org.cthul.matchers.fluent8.ObjectFluent<Value,BaseFluent,TheFluent,This>
    - org.cthul.matchers.fluent8.ClassFluent<Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.ClassFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ClassFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.ComparableFluent<C,Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.BigDecimalFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.BigDecimalFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.BigDecimalFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.DoubleFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IntegerFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.StringFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.BigDecimalFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.DoubleFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IntegerFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.StringFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.DoubleFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.DoubleFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IntegerFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IntegerFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.StringFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.StringFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.ExceptionFluent<Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.ExceptionFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ExceptionFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.IterableFluent<T,Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.CollectionFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IterableFluent.AndChain<T,Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.CollectionFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IterableFluent.OrChain<T,Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.IterableFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.CollectionFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.IterableFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.CollectionFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.MapFluent<K,V,Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.MapFluent.AndChain<K,V,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.MapFluent.OrChain<K,V,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ClassFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ClassFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent<C,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.BigDecimalFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.DoubleFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IntegerFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.StringFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.ExceptionFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ExceptionFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.IterableFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IterableFluent<T,Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.CollectionFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.MapFluent.AndChain<K,V,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.MapFluent<K,V,Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.ProcFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ProcFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ClassFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ClassFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent<C,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.BigDecimalFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.DoubleFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IntegerFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.StringFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.ExceptionFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ExceptionFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.IterableFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IterableFluent<T,Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.CollectionFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.MapFluent.OrChain<K,V,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.MapFluent<K,V,Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.ProcFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ProcFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.ProcFluent<Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.ProcFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ProcFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
  - org.cthul.matchers.fluent8.ProcFluent<Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent8.ObjectFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.ProcFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.ProcFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
  - org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent<C,Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent8.StringFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
    - org.cthul.matchers.fluent8.StringFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
- org.cthul.matchers.fluent.Fluent<Value>
  - org.cthul.matchers.fluent.ext.ExtensibleFluent<Value,This> (also extends org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>
      - org.cthul.matchers.fluent8.BigDecimalFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ClassFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ClassFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.CollectionFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.IterableFluent.AndChain<T,Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent<C,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.BigDecimalFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.DoubleFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IntegerFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.StringFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.DoubleFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.ExceptionFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ExceptionFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.IntegerFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.IterableFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.IterableFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.CollectionFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.MapFluent.AndChain<K,V,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.MapFluent<K,V,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ObjectFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ClassFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ClassFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent<C,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.BigDecimalFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.DoubleFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IntegerFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.StringFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ExceptionFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ExceptionFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IterableFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IterableFluent<T,Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.CollectionFluent.AndChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.MapFluent.AndChain<K,V,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.MapFluent<K,V,Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ProcFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ProcFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.ProcFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ObjectFluent.AndChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ProcFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.StringFluent.AndChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.AndChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)
    - org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>
      - org.cthul.matchers.fluent8.BigDecimalFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ClassFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ClassFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.CollectionFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.IterableFluent.OrChain<T,Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent<C,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.BigDecimalFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.DoubleFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IntegerFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.StringFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.DoubleFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.ExceptionFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ExceptionFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.IntegerFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.IterableFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.IterableFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.CollectionFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.MapFluent.OrChain<K,V,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.MapFluent<K,V,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>)
      - org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ObjectFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ClassFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ClassFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent<C,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.BigDecimalFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.BigDecimalFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.DoubleFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.DoubleFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IntegerFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IntegerFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.StringFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ExceptionFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ExceptionFluent<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.IterableFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.IterableFluent<T,Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.CollectionFluent.OrChain<T,Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.CollectionFluent<T,Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>)
        
        org.cthul.matchers.fluent8.MapFluent.OrChain<K,V,Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.MapFluent<K,V,Value,BaseFluent,TheFluent,This>)
        
        org.cthul.matchers.fluent8.ProcFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent.FluentStep.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ProcFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.ProcFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ObjectFluent.OrChain<Value,TheFluent,This>, org.cthul.matchers.fluent8.ProcFluent<Value,BaseFluent,TheFluent,This>)
      - org.cthul.matchers.fluent8.StringFluent.OrChain<Value,TheFluent,This> (also extends org.cthul.matchers.fluent8.ComparableFluent.OrChain<C,Value,TheFluent,This>, org.cthul.matchers.fluent8.StringFluent<Value,BaseFluent,TheFluent,This>)

Hierarchy For Package org.cthul.matchers.fluent8

Class Hierarchy

Interface Hierarchy