signature:
public class JavaWriter { /** * Build a string representation of a type and optionally its generic type arguments . */
public static String type ( Class < ? > raw , String ... parameters ) { } }

implementation: if ( parameters . length == 0 ) { return raw . getCanonicalName ( ) ; } if ( raw . getTypeParameters ( ) . length != parameters . length ) { throw new IllegalArgumentException ( ) ; } StringBuilder result = new StringBuilder ( ) ; result . append ( raw . getCanonicalName ( ) ) ; result . append ( "<" ) ; result . append ( parameters [ 0 ] ) ; for ( int i = 1 ; i < parameters . length ; i ++ ) { result . append ( ", " ) ; result . append ( parameters [ i ] ) ; } result . append ( ">" ) ; return result . toString ( ) ;


signature:
public class JavaWriter { /** * Build a string representation of the raw type for a ( optionally generic ) type . */
public static String rawType ( String type ) { } }

implementation: int lessThanIndex = type . indexOf ( '<' ) ; if ( lessThanIndex != - 1 ) { return type . substring ( 0 , lessThanIndex ) ; } return type ;


signature:
public class JavaWriter { /** * Emits the modifiers to the writer . */
private void emitModifiers ( Set < Modifier > modifiers ) throws IOException { } }

implementation:
if ( modifiers . isEmpty ( ) ) { return ; } // Use an EnumSet to ensure the proper ordering
if ( ! ( modifiers instanceof EnumSet ) ) { modifiers = EnumSet . copyOf ( modifiers ) ; } for ( Modifier modifier : modifiers ) { out . append ( modifier . toString ( ) ) . append ( ' ' ) ; }


signature:
public class ParcelablePleaseAction { /** * Get the class where currently the curser is */
private PsiClass getPsiClassFromContext ( AnActionEvent e ) { } }

implementation: PsiFile psiFile = e . getData ( LangDataKeys . PSI_FILE ) ; Editor editor = e . getData ( PlatformDataKeys . EDITOR ) ; if ( psiFile == null || editor == null ) { return null ; } int offset = editor . getCaretModel ( ) . getOffset ( ) ; PsiElement element = psiFile . findElementAt ( offset ) ; return PsiTreeUtil . getParentOfType ( element , PsiClass . class ) ;


signature:
public class CodeGenerator { /** * Finds and removes a given method
 * @ param methodName
 * @ param arguments */
private void findAndRemoveMethod ( String methodName , String ... arguments ) { } }

implementation:
// Maybe there ' s an easier way to do this with mClass . findMethodBySignature ( ) , but I ' m not an expert on Psi *
PsiMethod [ ] methods = psiClass . findMethodsByName ( methodName , false ) ; for ( PsiMethod method : methods ) { PsiParameterList parameterList = method . getParameterList ( ) ; if ( parameterList . getParametersCount ( ) == arguments . length ) { boolean shouldDelete = true ; PsiParameter [ ] parameters = parameterList . getParameters ( ) ; for ( int i = 0 ; i < arguments . length ; i ++ ) { if ( ! parameters [ i ] . getType ( ) . getCanonicalText ( ) . equals ( arguments [ i ] ) ) { shouldDelete = false ; } } if ( shouldDelete ) { method . delete ( ) ; } } }


signature:
public class CodeGenerator { /** * Generate and insert the Parcel and ParcelablePlease code */
public void generate ( ) { } }

implementation:
PsiElementFactory elementFactory = JavaPsiFacade . getElementFactory ( psiClass . getProject ( ) ) ; JavaCodeStyleManager styleManager = JavaCodeStyleManager . getInstance ( psiClass . getProject ( ) ) ; // Clear any previous
clearPrevious ( ) ; // Implements parcelable
makeClassImplementParcelable ( elementFactory , styleManager ) ; // @ ParcelablePlease Annotation
addAnnotation ( elementFactory , styleManager ) ; // Creator
PsiField creatorField = elementFactory . createFieldFromText ( generateCreator ( ) , psiClass ) ; // Describe contents method
PsiMethod describeContentsMethod = elementFactory . createMethodFromText ( generateDescribeContents ( ) , psiClass ) ; // Method for writing to the parcel
PsiMethod writeToParcelMethod = elementFactory . createMethodFromText ( generateWriteToParcel ( ) , psiClass ) ; styleManager . shortenClassReferences ( psiClass . addBefore ( describeContentsMethod , psiClass . getLastChild ( ) ) ) ; styleManager . shortenClassReferences ( psiClass . addBefore ( writeToParcelMethod , psiClass . getLastChild ( ) ) ) ; styleManager . shortenClassReferences ( psiClass . addBefore ( creatorField , psiClass . getLastChild ( ) ) ) ;


signature:
public class CodeGenerator { /** * Add the @ Parcelable annotation if not already annotated */
private void addAnnotation ( PsiElementFactory elementFactory , JavaCodeStyleManager styleManager ) { } }

implementation: boolean annotated = AnnotationUtil . isAnnotated ( psiClass , ANNOTATION_PACKAGE + "." + ANNOTATION_NAME , false ) ; if ( ! annotated ) { styleManager . shortenClassReferences ( psiClass . getModifierList ( ) . addAnnotation ( ANNOTATION_NAME ) ) ; }


signature:
public class CodeGenerator { /** * Make the class implementing Parcelable */
private void makeClassImplementParcelable ( PsiElementFactory elementFactory , JavaCodeStyleManager styleManager ) { } }

implementation:
final PsiClassType [ ] implementsListTypes = psiClass . getImplementsListTypes ( ) ; final String implementsType = "android.os.Parcelable" ; for ( PsiClassType implementsListType : implementsListTypes ) { PsiClass resolved = implementsListType . resolve ( ) ; // Already implements Parcelable , no need to add it
if ( resolved != null && implementsType . equals ( resolved . getQualifiedName ( ) ) ) { return ; } } PsiJavaCodeReferenceElement implementsReference = elementFactory . createReferenceFromText ( implementsType , psiClass ) ; PsiReferenceList implementsList = psiClass . getImplementsList ( ) ; if ( implementsList != null ) { styleManager . shortenClassReferences ( implementsList . add ( implementsReference ) ) ; }


signature:
public class ParcelablePleaseProcessor { /** * Checks if the element is a class */
private boolean isClass ( Element element ) { } }

implementation:
if ( element . getKind ( ) == ElementKind . CLASS ) { if ( element . getModifiers ( ) . contains ( Modifier . ABSTRACT ) ) { ProcessorMessage . error ( element , "Element %s is annotated with @%s but is an abstract class. " + "Abstract classes can not be annotated. Annotate the concrete class " + "that implements all abstract methods with @%s" , element . getSimpleName ( ) , ParcelablePlease . class . getSimpleName ( ) , ParcelablePlease . class . getSimpleName ( ) ) ; return false ; } if ( element . getModifiers ( ) . contains ( Modifier . PRIVATE ) ) { ProcessorMessage . error ( element , "The private class %s is annotated with @%s. " + "Private classes are not supported because of lacking visibility." , element . getSimpleName ( ) , ParcelablePlease . class . getSimpleName ( ) ) ; return false ; } // Ok , its a valid class
return true ; } else { ProcessorMessage . error ( element , "Element %s is annotated with @%s but is not a class. Only Classes are supported" , element . getSimpleName ( ) , ParcelablePlease . class . getSimpleName ( ) ) ; return false ; }


signature:
public class TypeUtils { /** * Checks if a TypeMirror equals a class */
public static boolean isTypeOf ( TypeMirror type , Class < ? > clazz ) { } }

implementation: return type . toString ( ) . equals ( clazz . getCanonicalName ( ) ) ;


signature:
public class TypeUtils { /** * Returns the class this element is part of */
public static Class < ? > isTypeOf ( TypeMirror type , List < Class < ? > > classList ) { } }

implementation: for ( Class < ? > c : classList ) { if ( isTypeOf ( type , c ) ) { return c ; } } return null ;


signature:
public class TypeUtils { /** * Get the Package name
 * @ throws IOException */
public static String getPackageName ( Elements elementUtils , TypeElement type ) throws IOException { } }

implementation:
PackageElement pkg = elementUtils . getPackageOf ( type ) ; if ( ! pkg . isUnnamed ( ) ) { return pkg . getQualifiedName ( ) . toString ( ) ; } else { return "" ; // Default package
}


signature:
public class TypeUtils { /** * Get the qualified name of a class . Also respects innner classes
 * @ param elementUtils Elements
 * @ param type TypeElement
 * @ return The qualified name of the class represented by the passed type element
 * @ throws IOException */
public static String getBinaryName ( Elements elementUtils , TypeElement type ) throws IOException { } }

implementation: String packageName = getPackageName ( elementUtils , type ) ; String qualifiedName = type . getQualifiedName ( ) . toString ( ) ; if ( packageName . length ( ) > 0 ) { return packageName + '.' + qualifiedName . substring ( packageName . length ( ) + 1 ) . replace ( '.' , '$' ) ; } else { return qualifiedName . replace ( '.' , '$' ) ; }


signature:
public class CodeGenerator { /** * Generate the writeToParcel method
 * @ throws IOException */
private void generateWriteToParcel ( JavaWriter jw , String originClass , List < ParcelableField > fields ) throws IOException { } }

implementation:
jw . beginMethod ( "void" , "writeToParcel" , EnumSet . of ( Modifier . PUBLIC , Modifier . STATIC ) , originClass , PARAM_SOURCE , "Parcel" , PARAM_PARCEL , "int" , PARAM_FLAGS ) ; for ( ParcelableField field : fields ) { FieldCodeGen gen = field . getCodeGenerator ( ) ; if ( gen == null ) { // Already checked before , but let ' s check it again
ProcessorMessage . error ( field . getElement ( ) , "The field %s is not Parcelable or of unsupported type. Use a @%s" , field . getFieldName ( ) , Bagger . class . getSimpleName ( ) + " to provide your own serialisation mechanism" ) ; throw new IOException ( "Unparcelable Field " + field . getFieldName ( ) ) ; } jw . emitEmptyLine ( ) ; gen . generateWriteToParcel ( field , jw ) ; } jw . endMethod ( ) ;


signature:
public class ParcelableField { /** * Checks if a class is public */
private boolean isPublicClass ( DeclaredType type ) { } }

implementation: Element element = type . asElement ( ) ; return element . getModifiers ( ) . contains ( javax . lang . model . element . Modifier . PUBLIC ) ;


signature:
public class ParcelableField { /** * Checks if an public empty constructor is available */
private boolean hasPublicEmptyConstructor ( DeclaredType type ) { } }

implementation: Element element = type . asElement ( ) ; List < ? extends Element > containing = element . getEnclosedElements ( ) ; for ( Element e : containing ) { if ( e . getKind ( ) == ElementKind . CONSTRUCTOR ) { ExecutableElement c = ( ExecutableElement ) e ; if ( ( c . getParameters ( ) == null || c . getParameters ( ) . isEmpty ( ) ) && c . getModifiers ( ) . contains ( javax . lang . model . element . Modifier . PUBLIC ) ) { return true ; } } } return false ;


signature:
public class POrthonormalization { /** * Orthonormalize the given vectors .
 * @ param v0 Vector 0
 * @ param v1 Vector 1
 * @ param v2 Vector 2
 * @ param < T > A phantom type parameter
 * @ return The set of vectors , orthonormalized */
public static < T > POrthonormalized3D < T > orthonormalize3D ( final PVector3D < T > v0 , final PVector3D < T > v1 , final PVector3D < T > v2 ) { } }

implementation: final PVector3D < T > rv0 = PVectors3D . normalize ( v0 ) ; final PVector3D < T > rv1 ; final PVector3D < T > rv2 ; { final double v0_dot_v1 = PVectors3D . dotProduct ( rv0 , v1 ) ; final PVector3D < T > v0_s = PVectors3D . scale ( rv0 , v0_dot_v1 ) ; rv1 = PVectors3D . normalize ( PVectors3D . subtract ( v1 , v0_s ) ) ; } { final double v1_dot_v2 = PVectors3D . dotProduct ( rv1 , v2 ) ; final double v0_dot_v2 = PVectors3D . dotProduct ( rv0 , v2 ) ; final PVector3D < T > v0_s = PVectors3D . scale ( rv0 , v0_dot_v2 ) ; final PVector3D < T > v2_s = PVectors3D . scale ( rv1 , v1_dot_v2 ) ; final PVector3D < T > vs = PVectors3D . add ( v0_s , v2_s ) ; rv2 = PVectors3D . normalize ( PVectors3D . subtract ( v2 , vs ) ) ; } return POrthonormalized3D . of ( rv0 , rv1 , rv2 ) ;


signature:
public class POrthonormalization { /** * Orthonormalize the given vectors .
 * @ param v0 Vector 0
 * @ param v1 Vector 1
 * @ param v2 Vector 2
 * @ param < T > A phantom type parameter
 * @ return The set of vectors , orthonormalized */
public static < T > POrthonormalized4D < T > orthonormalize4D ( final PVector4D < T > v0 , final PVector4D < T > v1 , final PVector4D < T > v2 ) { } }

implementation: final PVector4D < T > rv0 = PVectors4D . normalize ( v0 ) ; final PVector4D < T > rv1 ; final PVector4D < T > rv2 ; { final double v0_dot_v1 = PVectors4D . dotProduct ( rv0 , v1 ) ; final PVector4D < T > v0_s = PVectors4D . scale ( rv0 , v0_dot_v1 ) ; rv1 = PVectors4D . normalize ( PVectors4D . subtract ( v1 , v0_s ) ) ; } { final double v1_dot_v2 = PVectors4D . dotProduct ( rv1 , v2 ) ; final double v0_dot_v2 = PVectors4D . dotProduct ( rv0 , v2 ) ; final PVector4D < T > v0_s = PVectors4D . scale ( rv0 , v0_dot_v2 ) ; final PVector4D < T > v2_s = PVectors4D . scale ( rv1 , v1_dot_v2 ) ; final PVector4D < T > vs = PVectors4D . add ( v0_s , v2_s ) ; rv2 = PVectors4D . normalize ( PVectors4D . subtract ( v2 , vs ) ) ; } return POrthonormalized4D . of ( rv0 , rv1 , rv2 ) ;


signature:
public class PVectorByteBufferedIntegral2s16 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedIntegral2s16 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedIntegral2s16 < > ( b , base , offset ) ;


signature:
public class PVector4FGenerator { /** * Create a generator initialized with a default component generator .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < PVector4F < T > > create ( ) { } }

implementation: return new PVector4FGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_FLOAT_LOWER , GeneratorConstants . BOUND_LARGE_FLOAT_UPPER ) ) ;


signature:
public class PVector4FGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 65536.0 , 65536.0 ] } .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < PVector4F < T > > createSmall ( ) { } }

implementation: return new PVector4FGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_SMALL_FLOAT_LOWER , GeneratorConstants . BOUND_SMALL_FLOAT_UPPER ) ) ;


signature:
public class PVector4FGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < PVector4F < T > > createNormal ( ) { } }

implementation: return new PVector4FGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_FLOAT_LOWER , GeneratorConstants . BOUND_NORMAL_FLOAT_UPPER ) ) ;


signature:
public class PVectorByteBufferedIntegral2s64 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedIntegral2s64 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedIntegral2s64 < > ( b , base , offset ) ;


signature:
public class Determinants { /** * Calculate the determinant of the given 3x3 matrix values .
 * @ param r0c0 The value at row 0 column 0
 * @ param r0c1 The value at row 0 column 1
 * @ param r0c2 The value at row 0 column 2
 * @ param r1c0 The value at row 1 column 0
 * @ param r1c1 The value at row 1 column 1
 * @ param r1c2 The value at row 1 column 2
 * @ param r2c0 The value at row 2 column 0
 * @ param r2c1 The value at row 2 column 1
 * @ param r2c2 The value at row 2 column 2
 * @ return The determinant */
public static double determinant3x3 ( final double r0c0 , final double r0c1 , final double r0c2 , final double r1c0 , final double r1c1 , final double r1c2 , final double r2c0 , final double r2c1 , final double r2c2 ) { } }


signature:
public class Determinants { /** * CHECKSTYLE : OFF */
public static double determinant4x4 ( final double r0c0 , final double r0c1 , final double r0c2 , final double r0c3 , final double r1c0 , final double r1c1 , final double r1c2 , final double r1c3 , final double r2c0 , final double r2c1 , final double r2c2 , final double r2c3 , final double r3c0 , final double r3c1 , final double r3c2 , final double r3c3 ) // CHECKSTYLE : ON
{ } }


signature:
public class VectorByteBufferedFloating3s32 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedFloating3s32 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedFloating3s32 ( b , base , offset ) ;


signature:
public class Vector4FGenerator { /** * Create a generator initialized with a default component generator .
 * @ return A generator */
public static Generator < Vector4F > create ( ) { } }

implementation: return new Vector4FGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_FLOAT_LOWER , GeneratorConstants . BOUND_LARGE_FLOAT_UPPER ) ) ;


signature:
public class Vector4FGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 65536.0 , 65536.0 ] } .
 * @ return A generator */
public static Generator < Vector4F > createSmall ( ) { } }

implementation: return new Vector4FGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_SMALL_FLOAT_LOWER , GeneratorConstants . BOUND_SMALL_FLOAT_UPPER ) ) ;


signature:
public class Vector4FGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ return A generator */
public static Generator < Vector4F > createNormal ( ) { } }

implementation: return new Vector4FGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_FLOAT_LOWER , GeneratorConstants . BOUND_NORMAL_FLOAT_UPPER ) ) ;


signature:
public class MatrixByteBuffered2x2s16 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static MatrixByteBuffered2x2s16 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new MatrixByteBuffered2x2s16 ( b , base , offset ) ;


signature:
public class VectorByteBufferedFloating2s64 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedFloating2s64 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedFloating2s64 ( b , base , offset ) ;


signature:
public class VectorByteBufferedIntegral3s32 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedIntegral3s32 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedIntegral3s32 ( b , base , offset ) ;


signature:
public class VectorByteBufferedIntegral2s8 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedIntegral2s8 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedIntegral2s8 ( b , base , offset ) ;


signature:
public class Hunter { /** * Not cached search */
public R findBy ( ClassFileScanConfiguration scanConfig , SearchCriteria criteria ) { } }

implementation: scanConfig = scanConfig . createCopy ( ) ; criteria = criteria . createCopy ( ) ; C context = createContext ( scanConfig , criteria ) ; criteria . init ( this . classHelper , context . pathMemoryClassLoader , this . memberFinder , this . pathHelper ) ; scanConfig . init ( ) ; fileSystemHelper . scan ( scanConfig . toScanConfiguration ( context , this ) ) ; Collection < String > skippedClassesNames = context . getSkippedClassNames ( ) ; if ( ! skippedClassesNames . isEmpty ( ) ) { logWarn ( "Skipped classes count: {}" , skippedClassesNames . size ( ) ) ; } return resultSupplier . apply ( context ) ;


signature:
public class PVectorByteBufferedFloating3s32 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedFloating3s32 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedFloating3s32 < > ( b , base , offset ) ;


signature:
public class VectorByteBufferedIntegral3s64 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedIntegral3s64 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedIntegral3s64 ( b , base , offset ) ;


signature:
public class VectorByteBufferedFloating2s16 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedFloating2s16 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedFloating2s16 ( b , base , offset ) ;


signature:
public class VectorByteBufferedIntegral3s8 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedIntegral3s8 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedIntegral3s8 ( b , base , offset ) ;


signature:
public class CacherHunter { /** * Cached search */
public SearchResult < K , I > findBy ( PathSearchCriteria criteria ) { } }

implementation: criteria = criteria . createCopy ( ) ; C context = createContext ( ClassFileScanConfiguration . forPaths ( criteria . getPaths ( ) ) . maxParallelTasksForUnit ( criteria . maxParallelTasksForUnit ) , criteria ) ; criteria . init ( this . classHelper , context . pathMemoryClassLoader , this . memberFinder , this . pathHelper ) ; scan ( context ) ; Collection < String > skippedClassesNames = context . getSkippedClassNames ( ) ; if ( ! skippedClassesNames . isEmpty ( ) ) { logWarn ( "Skipped classes count: {}" , skippedClassesNames . size ( ) ) ; } return resultSupplier . apply ( context ) ;


signature:
public class Vector2DGenerator { /** * Create a generator initialized with a default component generator .
 * @ return A generator */
public static Generator < Vector2D > create ( ) { } }

implementation: return new Vector2DGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_DOUBLE_LOWER , GeneratorConstants . BOUND_LARGE_DOUBLE_UPPER ) ) ;


signature:
public class Vector2DGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 65536.0 , 65536.0 ] } .
 * @ return A generator */
public static Generator < Vector2D > createSmall ( ) { } }

implementation: return new Vector2DGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_SMALL_DOUBLE_LOWER , GeneratorConstants . BOUND_SMALL_DOUBLE_UPPER ) ) ;


signature:
public class Vector2DGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ return A generator */
public static Generator < Vector2D > createNormal ( ) { } }

implementation: return new Vector2DGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_DOUBLE_LOWER , GeneratorConstants . BOUND_NORMAL_DOUBLE_UPPER ) ) ;


signature:
public class MatrixByteBuffered4x4s16 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static MatrixByteBuffered4x4s16 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new MatrixByteBuffered4x4s16 ( b , base , offset ) ;


signature:
public class PMatrix2x2FGenerator { /** * Create a generator initialized with a default component generator .
 * @ param < A > A phantom type parameter ( possibly representing a source
 * coordinate system )
 * @ param < B > A phantom type parameter ( possibly representing a target
 * coordinate system )
 * @ return A generator */
public static < A , B > Generator < PMatrix2x2F < A , B > > create ( ) { } }

implementation: return new PMatrix2x2FGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_FLOAT_LOWER , GeneratorConstants . BOUND_LARGE_FLOAT_UPPER ) ) ;


signature:
public class PMatrix2x2FGenerator { /** * Create a generator initialized with a default component generator that only
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ param < A > A phantom type parameter ( possibly representing a source
 * coordinate system )
 * @ param < B > A phantom type parameter ( possibly representing a target
 * coordinate system )
 * @ return A generator */
public static < A , B > Generator < PMatrix2x2F < A , B > > createNormal ( ) { } }

implementation: return new PMatrix2x2FGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_FLOAT_LOWER , GeneratorConstants . BOUND_NORMAL_FLOAT_UPPER ) ) ;


signature:
public class Matrix4x4DGenerator { /** * Create a generator initialized with a default component generator .
 * @ return A generator */
public static Generator < Matrix4x4D > create ( ) { } }

implementation: return new Matrix4x4DGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_DOUBLE_LOWER , GeneratorConstants . BOUND_LARGE_DOUBLE_UPPER ) ) ;


signature:
public class Matrix4x4DGenerator { /** * Create a generator initialized with a default component generator that only
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ return A generator */
public static Generator < Matrix4x4D > createNormal ( ) { } }

implementation: return new Matrix4x4DGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_DOUBLE_LOWER , GeneratorConstants . BOUND_NORMAL_DOUBLE_UPPER ) ) ;


signature:
public class Matrix4x4DGenerator { /** * Create a generator initialized with a default component generator that only
 * produces orthogonal matrices .
 * @ return A generator */
public static Generator < Matrix4x4D > createOrthogonal ( ) { } }

implementation: return ( ) -> { final SecureRandom rng = new SecureRandom ( ) ; final double r0c0 = 1.0 ; final double r0c1 = 0.0 ; final double r0c2 = 0.0 ; final double r0c3 = rng . nextDouble ( ) ; final double r1c0 = 0.0 ; final double r1c1 = 1.0 ; final double r1c2 = 0.0 ; final double r1c3 = rng . nextDouble ( ) ; final double r2c0 = 0.0 ; final double r2c1 = 0.0 ; final double r2c2 = 1.0 ; final double r2c3 = rng . nextDouble ( ) ; final double r3c0 = 0.0 ; final double r3c1 = 0.0 ; final double r3c2 = 0.0 ; final double r3c3 = 1.0 ; return Matrix4x4D . of ( r0c0 , r0c1 , r0c2 , r0c3 , r1c0 , r1c1 , r1c2 , r1c3 , r2c0 , r2c1 , r2c2 , r2c3 , r3c0 , r3c1 , r3c2 , r3c3 ) ; } ;


signature:
public class DotProductsLong { /** * Calculate the dot product of
 * { @ code ( x0 , y0 , z0 ) } and { @ code ( x1 , y1 , z1 ) } .
 * @ param x0 The X component of the first vector
 * @ param y0 The Y component of the first vector
 * @ param z0 The Z component of the first vector
 * @ param x1 The X component of the second vector
 * @ param y1 The Y component of the second vector
 * @ param z1 The Z component of the second vector
 * @ return The dot product */
public static long dotProduct3 ( final long x0 , final long y0 , final long z0 , final long x1 , final long y1 , final long z1 ) { } }

implementation: final long x = x0 * x1 ; final long y = y0 * y1 ; final long z = z0 * z1 ; return x + y + z ;


signature:
public class DotProductsInt { /** * Calculate the dot product of { @ code ( x0 , y0 ) } and { @ code ( x1 , y1 ) } .
 * @ param x0 The X component of the first vector
 * @ param y0 The Y component of the first vector
 * @ param x1 The X component of the second vector
 * @ param y1 The Y component of the second vector
 * @ return The dot product */
public static int dotProduct2 ( final int x0 , final int y0 , final int x1 , final int y1 ) { } }

implementation: final int x = x0 * x1 ; final int y = y0 * y1 ; return x + y ;


signature:
public class MatrixByteBuffered4x4s32 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static MatrixByteBuffered4x4s32 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new MatrixByteBuffered4x4s32 ( b , base , offset ) ;


signature:
public class DotProductsDouble { /** * Calculate the dot product of
 * { @ code ( x0 , y0 , z0 , w0 ) } and { @ code ( x1 , y1 , z1 , w1 ) } .
 * @ param x0 The X component of the first vector
 * @ param y0 The Y component of the first vector
 * @ param z0 The Z component of the first vector
 * @ param w0 The W component of the first vector
 * @ param x1 The X component of the second vector
 * @ param y1 The Y component of the second vector
 * @ param z1 The Z component of the second vector
 * @ param w1 The W component of the second vector
 * @ return The dot product */
public static double dotProduct4 ( final double x0 , final double y0 , final double z0 , final double w0 , final double x1 , final double y1 , final double z1 , final double w1 ) { } }

implementation: final double x = x0 * x1 ; final double y = y0 * y1 ; final double z = z0 * z1 ; final double w = w0 * w1 ; return x + y + z + w ;


signature:
public class VectorByteBufferedIntegral4s64 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedIntegral4s64 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedIntegral4s64 ( b , base , offset ) ;


signature:
public class VectorByteBufferedFloating3s64 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedFloating3s64 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedFloating3s64 ( b , base , offset ) ;


signature:
public class PVectorByteBufferedIntegral3s8 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedIntegral3s8 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedIntegral3s8 < > ( b , base , offset ) ;


signature:
public class PVectorByteBufferedFloating2s16 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedFloating2s16 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedFloating2s16 < > ( b , base , offset ) ;


signature:
public class PVectorByteBufferedFloating4s64 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedFloating4s64 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedFloating4s64 < > ( b , base , offset ) ;


signature:
public class PMatrixByteBuffered3x3s16 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < A > A phantom type parameter ( possibly representing a source
 * coordinate system )
 * @ param < B > A phantom type parameter ( possibly representing a target
 * coordinate system )
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < A , B > PMatrixByteBuffered3x3s16 < A , B > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PMatrixByteBuffered3x3s16 < > ( b , base , offset ) ;


signature:
public class VectorByteBufferedFloating3s16 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedFloating3s16 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedFloating3s16 ( b , base , offset ) ;


signature:
public class VectorByteBufferedIntegral4s8 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedIntegral4s8 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedIntegral4s8 ( b , base , offset ) ;


signature:
public class Vector3FGenerator { /** * Create a generator initialized with a default component generator .
 * @ return A generator */
public static Generator < Vector3F > create ( ) { } }

implementation: return new Vector3FGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_FLOAT_LOWER , GeneratorConstants . BOUND_LARGE_FLOAT_UPPER ) ) ;


signature:
public class Vector3FGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 65536.0 , 65536.0 ] } .
 * @ return A generator */
public static Generator < Vector3F > createSmall ( ) { } }

implementation: return new Vector3FGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_SMALL_FLOAT_LOWER , GeneratorConstants . BOUND_SMALL_FLOAT_UPPER ) ) ;


signature:
public class Vector3FGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ return A generator */
public static Generator < Vector3F > createNormal ( ) { } }

implementation: return new Vector3FGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_FLOAT_LOWER , GeneratorConstants . BOUND_NORMAL_FLOAT_UPPER ) ) ;


signature:
public class VectorByteBufferedIntegral2s16 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedIntegral2s16 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedIntegral2s16 ( b , base , offset ) ;


signature:
public class PVector3FGenerator { /** * Create a generator initialized with a default component generator .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < PVector3F < T > > create ( ) { } }

implementation: return new PVector3FGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_FLOAT_LOWER , GeneratorConstants . BOUND_LARGE_FLOAT_UPPER ) ) ;


signature:
public class PVector3FGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 65536.0 , 65536.0 ] } .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < PVector3F < T > > createSmall ( ) { } }

implementation: return new PVector3FGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_SMALL_FLOAT_LOWER , GeneratorConstants . BOUND_SMALL_FLOAT_UPPER ) ) ;


signature:
public class PVector3FGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < PVector3F < T > > createNormal ( ) { } }

implementation: return new PVector3FGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_FLOAT_LOWER , GeneratorConstants . BOUND_NORMAL_FLOAT_UPPER ) ) ;


signature:
public class MatrixByteBuffered3x3s64 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static MatrixByteBuffered3x3s64 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new MatrixByteBuffered3x3s64 ( b , base , offset ) ;


signature:
public class PVectorByteBufferedIntegral3s64 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedIntegral3s64 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedIntegral3s64 < > ( b , base , offset ) ;


signature:
public class PVectorByteBufferedFloating4s32 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedFloating4s32 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedFloating4s32 < > ( b , base , offset ) ;


signature:
public class Vector4DGenerator { /** * Create a generator initialized with a default component generator .
 * @ return A generator */
public static Generator < Vector4D > create ( ) { } }

implementation: return new Vector4DGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_DOUBLE_LOWER , GeneratorConstants . BOUND_LARGE_DOUBLE_UPPER ) ) ;


signature:
public class Vector4DGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 65536.0 , 65536.0 ] } .
 * @ return A generator */
public static Generator < Vector4D > createSmall ( ) { } }

implementation: return new Vector4DGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_SMALL_DOUBLE_LOWER , GeneratorConstants . BOUND_SMALL_DOUBLE_UPPER ) ) ;


signature:
public class Vector4DGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ return A generator */
public static Generator < Vector4D > createNormal ( ) { } }

implementation: return new Vector4DGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_DOUBLE_LOWER , GeneratorConstants . BOUND_NORMAL_DOUBLE_UPPER ) ) ;


signature:
public class PVectorByteBufferedFloating3s16 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedFloating3s16 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedFloating3s16 < > ( b , base , offset ) ;


signature:
public class PMatrix3x3DGenerator { /** * Create a generator initialized with a default component generator .
 * @ param < A > A phantom type parameter ( possibly representing a source
 * coordinate system )
 * @ param < B > A phantom type parameter ( possibly representing a target
 * coordinate system )
 * @ return A generator */
public static < A , B > Generator < PMatrix3x3D < A , B > > create ( ) { } }

implementation: return new PMatrix3x3DGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_DOUBLE_LOWER , GeneratorConstants . BOUND_LARGE_DOUBLE_UPPER ) ) ;


signature:
public class PMatrix3x3DGenerator { /** * Create a generator initialized with a default component generator that only
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ param < A > A phantom type parameter ( possibly representing a source
 * coordinate system )
 * @ param < B > A phantom type parameter ( possibly representing a target
 * coordinate system )
 * @ return A generator */
public static < A , B > Generator < PMatrix3x3D < A , B > > createNormal ( ) { } }

implementation: return new PMatrix3x3DGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_DOUBLE_LOWER , GeneratorConstants . BOUND_NORMAL_DOUBLE_UPPER ) ) ;


signature:
public class PVector2FGenerator { /** * Create a generator initialized with a default component generator .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < PVector2F < T > > create ( ) { } }

implementation: return new PVector2FGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_FLOAT_LOWER , GeneratorConstants . BOUND_LARGE_FLOAT_UPPER ) ) ;


signature:
public class PVector2FGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 65536.0 , 65536.0 ] } .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < PVector2F < T > > createSmall ( ) { } }

implementation: return new PVector2FGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_SMALL_FLOAT_LOWER , GeneratorConstants . BOUND_SMALL_FLOAT_UPPER ) ) ;


signature:
public class PVector2FGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < PVector2F < T > > createNormal ( ) { } }

implementation: return new PVector2FGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_FLOAT_LOWER , GeneratorConstants . BOUND_NORMAL_FLOAT_UPPER ) ) ;


signature:
public class PMatrix2x2DGenerator { /** * Create a generator initialized with a default component generator .
 * @ param < A > A phantom type parameter ( possibly representing a source
 * coordinate system )
 * @ param < B > A phantom type parameter ( possibly representing a target
 * coordinate system )
 * @ return A generator */
public static < A , B > Generator < PMatrix2x2D < A , B > > create ( ) { } }

implementation: return new PMatrix2x2DGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_DOUBLE_LOWER , GeneratorConstants . BOUND_LARGE_DOUBLE_UPPER ) ) ;


signature:
public class PMatrix2x2DGenerator { /** * Create a generator initialized with a default component generator that only
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ param < A > A phantom type parameter ( possibly representing a source
 * coordinate system )
 * @ param < B > A phantom type parameter ( possibly representing a target
 * coordinate system )
 * @ return A generator */
public static < A , B > Generator < PMatrix2x2D < A , B > > createNormal ( ) { } }

implementation: return new PMatrix2x2DGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_DOUBLE_LOWER , GeneratorConstants . BOUND_NORMAL_DOUBLE_UPPER ) ) ;


signature:
public class Vector3DGenerator { /** * Create a generator initialized with a default component generator .
 * @ return A generator */
public static Generator < Vector3D > create ( ) { } }

implementation: return new Vector3DGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_DOUBLE_LOWER , GeneratorConstants . BOUND_LARGE_DOUBLE_UPPER ) ) ;


signature:
public class Vector3DGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 65536.0 , 65536.0 ] } .
 * @ return A generator */
public static Generator < Vector3D > createSmall ( ) { } }

implementation: return new Vector3DGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_SMALL_DOUBLE_LOWER , GeneratorConstants . BOUND_SMALL_DOUBLE_UPPER ) ) ;


signature:
public class Vector3DGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ return A generator */
public static Generator < Vector3D > createNormal ( ) { } }

implementation: return new Vector3DGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_DOUBLE_LOWER , GeneratorConstants . BOUND_NORMAL_DOUBLE_UPPER ) ) ;


signature:
public class PVector4DGenerator { /** * Create a generator initialized with a default component generator .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < PVector4D < T > > create ( ) { } }

implementation: return new PVector4DGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_DOUBLE_LOWER , GeneratorConstants . BOUND_LARGE_DOUBLE_UPPER ) ) ;


signature:
public class PVector4DGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - ( 2 ^ 16 ) , 2 ^ 16 ] } .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < PVector4D < T > > createSmall ( ) { } }

implementation: return new PVector4DGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_SMALL_DOUBLE_LOWER , GeneratorConstants . BOUND_SMALL_DOUBLE_UPPER ) ) ;


signature:
public class PVector4DGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < PVector4D < T > > createNormal ( ) { } }

implementation: return new PVector4DGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_DOUBLE_LOWER , GeneratorConstants . BOUND_NORMAL_DOUBLE_UPPER ) ) ;


signature:
public class PVectorByteBufferedIntegral4s64 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedIntegral4s64 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedIntegral4s64 < > ( b , base , offset ) ;


signature:
public class PVectorByteBufferedIntegral2s32 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedIntegral2s32 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedIntegral2s32 < > ( b , base , offset ) ;


signature:
public class MatrixByteBuffered2x2s64 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static MatrixByteBuffered2x2s64 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new MatrixByteBuffered2x2s64 ( b , base , offset ) ;


signature:
public class VectorByteBufferedIntegral2s32 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedIntegral2s32 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedIntegral2s32 ( b , base , offset ) ;


signature:
public class PVectorByteBufferedFloating3s64 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedFloating3s64 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedFloating3s64 < > ( b , base , offset ) ;


signature:
public class PVector2DGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - ( 2 ^ 16 ) , 2 ^ 16 ] } .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < PVector2D < T > > createSmall ( ) { } }

implementation: return new PVector2DGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_SMALL_DOUBLE_LOWER , GeneratorConstants . BOUND_SMALL_DOUBLE_UPPER ) ) ;


signature:
public class PVector2DGenerator { /** * Create a generator initialized with a default component generator .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < PVector2D < T > > create ( ) { } }

implementation: return new PVector2DGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_DOUBLE_LOWER , GeneratorConstants . BOUND_LARGE_DOUBLE_UPPER ) ) ;


signature:
public class PVector2DGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 1 , 1 ] } .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < PVector2D < T > > createNormal ( ) { } }

implementation: return new PVector2DGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_DOUBLE_LOWER , GeneratorConstants . BOUND_NORMAL_DOUBLE_UPPER ) ) ;


signature:
public class PMatrix4x4FGenerator { /** * Create a generator initialized with a default component generator .
 * @ param < A > A phantom type parameter ( possibly representing a source
 * coordinate system )
 * @ param < B > A phantom type parameter ( possibly representing a target
 * coordinate system )
 * @ return A generator */
public static < A , B > Generator < PMatrix4x4F < A , B > > create ( ) { } }

implementation: return new PMatrix4x4FGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_FLOAT_LOWER , GeneratorConstants . BOUND_LARGE_FLOAT_UPPER ) ) ;


signature:
public class PMatrix4x4FGenerator { /** * Create a generator initialized with a default component generator that only
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ param < A > A phantom type parameter ( possibly representing a source
 * coordinate system )
 * @ param < B > A phantom type parameter ( possibly representing a target
 * coordinate system )
 * @ return A generator */
public static < A , B > Generator < PMatrix4x4F < A , B > > createNormal ( ) { } }

implementation: return new PMatrix4x4FGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_FLOAT_LOWER , GeneratorConstants . BOUND_NORMAL_FLOAT_UPPER ) ) ;


signature:
public class PVectorByteBufferedIntegral4s32 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedIntegral4s32 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedIntegral4s32 < > ( b , base , offset ) ;


signature:
public class PVectorByteBufferedIntegral4s16 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedIntegral4s16 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedIntegral4s16 < > ( b , base , offset ) ;


signature:
public class MatrixDOps { /** * CHECKSTYLE : OFF */
static double determinant4x4 ( final double r0c0 , final double r0c1 , final double r0c2 , final double r0c3 , final double r1c0 , final double r1c1 , final double r1c2 , final double r1c3 , final double r2c0 , final double r2c1 , final double r2c2 , final double r2c3 , final double r3c0 , final double r3c1 , final double r3c2 , final double r3c3 ) // CHECKSTYLE : ON
{ } }

implementation: return Determinants . determinant4x4 ( r0c0 , r0c1 , r0c2 , r0c3 , r1c0 , r1c1 , r1c2 , r1c3 , r2c0 , r2c1 , r2c2 , r2c3 , r3c0 , r3c1 , r3c2 , r3c3 ) ;


signature:
public class VectorByteBufferedIntegral2s64 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedIntegral2s64 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedIntegral2s64 ( b , base , offset ) ;


signature:
public class MatrixByteBuffered2x2s32 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static MatrixByteBuffered2x2s32 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new MatrixByteBuffered2x2s32 ( b , base , offset ) ;


signature:
public class PVectorByteBufferedFloating2s64 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedFloating2s64 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedFloating2s64 < > ( b , base , offset ) ;


signature:
public class Matrix3x3FGenerator { /** * Create a generator initialized with a default component generator .
 * @ return A generator */
public static Generator < Matrix3x3F > create ( ) { } }

implementation: return new Matrix3x3FGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_FLOAT_LOWER , GeneratorConstants . BOUND_LARGE_FLOAT_UPPER ) ) ;


signature:
public class Matrix3x3FGenerator { /** * Create a generator initialized with a default component generator that only
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ return A generator */
public static Generator < Matrix3x3F > createNormal ( ) { } }

implementation: return new Matrix3x3FGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_FLOAT_LOWER , GeneratorConstants . BOUND_NORMAL_FLOAT_UPPER ) ) ;


signature:
public class VectorByteBufferedIntegral4s16 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedIntegral4s16 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedIntegral4s16 ( b , base , offset ) ;


signature:
public class PVectorByteBufferedIntegral3s32 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedIntegral3s32 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedIntegral3s32 < > ( b , base , offset ) ;


signature:
public class VectorByteBufferedFloating4s16 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedFloating4s16 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedFloating4s16 ( b , base , offset ) ;


signature:
public class PMatrix3x3FGenerator { /** * Create a generator initialized with a default component generator .
 * @ param < A > A phantom type parameter ( possibly representing a source
 * coordinate system )
 * @ param < B > A phantom type parameter ( possibly representing a target
 * coordinate system )
 * @ return A generator */
public static < A , B > Generator < PMatrix3x3F < A , B > > create ( ) { } }

implementation: return new PMatrix3x3FGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_FLOAT_LOWER , GeneratorConstants . BOUND_LARGE_FLOAT_UPPER ) ) ;


signature:
public class PMatrix3x3FGenerator { /** * Create a generator initialized with a default component generator that only
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ param < A > A phantom type parameter ( possibly representing a source
 * coordinate system )
 * @ param < B > A phantom type parameter ( possibly representing a target
 * coordinate system )
 * @ return A generator */
public static < A , B > Generator < PMatrix3x3F < A , B > > createNormal ( ) { } }

implementation: return new PMatrix3x3FGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_FLOAT_LOWER , GeneratorConstants . BOUND_NORMAL_FLOAT_UPPER ) ) ;


signature:
public class Matrix2x2DGenerator { /** * Create a generator initialized with a default component generator .
 * @ return A generator */
public static Generator < Matrix2x2D > create ( ) { } }

implementation: return new Matrix2x2DGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_DOUBLE_LOWER , GeneratorConstants . BOUND_LARGE_DOUBLE_UPPER ) ) ;


signature:
public class Matrix2x2DGenerator { /** * Create a generator initialized with a default component generator that only
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ return A generator */
public static Generator < Matrix2x2D > createNormal ( ) { } }

implementation: return new Matrix2x2DGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_DOUBLE_LOWER , GeneratorConstants . BOUND_NORMAL_DOUBLE_UPPER ) ) ;


signature:
public class MatrixByteBuffered4x4s64 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static MatrixByteBuffered4x4s64 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new MatrixByteBuffered4x4s64 ( b , base , offset ) ;


signature:
public class VectorByteBufferedIntegral3s16 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedIntegral3s16 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedIntegral3s16 ( b , base , offset ) ;


signature:
public class PVectorByteBufferedIntegral2s8 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedIntegral2s8 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedIntegral2s8 < > ( b , base , offset ) ;


signature:
public class VectorByteBufferedFloating4s64 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedFloating4s64 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedFloating4s64 ( b , base , offset ) ;


signature:
public class Orthonormalization { /** * Orthonormalize the given vectors .
 * @ param v0 Vector 0
 * @ param v1 Vector 1
 * @ param v2 Vector 2
 * @ return The set of vectors , orthonormalized */
public static Orthonormalized3D orthonormalize3D ( final Vector3D v0 , final Vector3D v1 , final Vector3D v2 ) { } }

implementation: final Vector3D rv0 = Vectors3D . normalize ( v0 ) ; final Vector3D rv1 ; final Vector3D rv2 ; { final double v0_dot_v1 = Vectors3D . dotProduct ( rv0 , v1 ) ; final Vector3D v0_s = Vectors3D . scale ( rv0 , v0_dot_v1 ) ; rv1 = Vectors3D . normalize ( Vectors3D . subtract ( v1 , v0_s ) ) ; } { final double v1_dot_v2 = Vectors3D . dotProduct ( rv1 , v2 ) ; final double v0_dot_v2 = Vectors3D . dotProduct ( rv0 , v2 ) ; final Vector3D v0_s = Vectors3D . scale ( rv0 , v0_dot_v2 ) ; final Vector3D v2_s = Vectors3D . scale ( rv1 , v1_dot_v2 ) ; final Vector3D vs = Vectors3D . add ( v0_s , v2_s ) ; rv2 = Vectors3D . normalize ( Vectors3D . subtract ( v2 , vs ) ) ; } return Orthonormalized3D . of ( rv0 , rv1 , rv2 ) ;


signature:
public class Orthonormalization { /** * Orthonormalize the given vectors .
 * @ param v0 Vector 0
 * @ param v1 Vector 1
 * @ param v2 Vector 2
 * @ return The set of vectors , orthonormalized */
public static Orthonormalized4D orthonormalize4D ( final Vector4D v0 , final Vector4D v1 , final Vector4D v2 ) { } }

implementation: final Vector4D rv0 = Vectors4D . normalize ( v0 ) ; final Vector4D rv1 ; final Vector4D rv2 ; { final double v0_dot_v1 = Vectors4D . dotProduct ( rv0 , v1 ) ; final Vector4D v0_s = Vectors4D . scale ( rv0 , v0_dot_v1 ) ; rv1 = Vectors4D . normalize ( Vectors4D . subtract ( v1 , v0_s ) ) ; } { final double v1_dot_v2 = Vectors4D . dotProduct ( rv1 , v2 ) ; final double v0_dot_v2 = Vectors4D . dotProduct ( rv0 , v2 ) ; final Vector4D v0_s = Vectors4D . scale ( rv0 , v0_dot_v2 ) ; final Vector4D v2_s = Vectors4D . scale ( rv1 , v1_dot_v2 ) ; final Vector4D vs = Vectors4D . add ( v0_s , v2_s ) ; rv2 = Vectors4D . normalize ( Vectors4D . subtract ( v2 , vs ) ) ; } return Orthonormalized4D . of ( rv0 , rv1 , rv2 ) ;


signature:
public class Vector2FGenerator { /** * Create a generator initialized with a default component generator .
 * @ return A generator */
public static Generator < Vector2F > create ( ) { } }

implementation: return new Vector2FGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_FLOAT_LOWER , GeneratorConstants . BOUND_LARGE_FLOAT_UPPER ) ) ;


signature:
public class Vector2FGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 65536.0 , 65536.0 ] } .
 * @ return A generator */
public static Generator < Vector2F > createSmall ( ) { } }

implementation: return new Vector2FGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_SMALL_FLOAT_LOWER , GeneratorConstants . BOUND_SMALL_FLOAT_UPPER ) ) ;


signature:
public class Vector2FGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ return A generator */
public static Generator < Vector2F > createNormal ( ) { } }

implementation: return new Vector2FGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_FLOAT_LOWER , GeneratorConstants . BOUND_NORMAL_FLOAT_UPPER ) ) ;


signature:
public class Matrix4x4FGenerator { /** * Create a generator initialized with a default component generator .
 * @ return A generator */
public static Generator < Matrix4x4F > create ( ) { } }

implementation: return new Matrix4x4FGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_FLOAT_LOWER , GeneratorConstants . BOUND_LARGE_FLOAT_UPPER ) ) ;


signature:
public class Matrix4x4FGenerator { /** * Create a generator initialized with a default component generator that only
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ return A generator */
public static Generator < Matrix4x4F > createNormal ( ) { } }

implementation: return new Matrix4x4FGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_FLOAT_LOWER , GeneratorConstants . BOUND_NORMAL_FLOAT_UPPER ) ) ;


signature:
public class MatrixByteBuffered3x3s16 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static MatrixByteBuffered3x3s16 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new MatrixByteBuffered3x3s16 ( b , base , offset ) ;


signature:
public class VectorByteBufferedFloating2s32 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedFloating2s32 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedFloating2s32 ( b , base , offset ) ;


signature:
public class Matrix2x2FGenerator { /** * Create a generator initialized with a default component generator .
 * @ return A generator */
public static Generator < Matrix2x2F > create ( ) { } }

implementation: return new Matrix2x2FGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_FLOAT_LOWER , GeneratorConstants . BOUND_LARGE_FLOAT_UPPER ) ) ;


signature:
public class Matrix2x2FGenerator { /** * Create a generator initialized with a default component generator that only
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ return A generator */
public static Generator < Matrix2x2F > createNormal ( ) { } }

implementation: return new Matrix2x2FGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_FLOAT_LOWER , GeneratorConstants . BOUND_NORMAL_FLOAT_UPPER ) ) ;


signature:
public class PVectorByteBufferedFloating4s16 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedFloating4s16 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedFloating4s16 < > ( b , base , offset ) ;


signature:
public class PVectorByteBufferedIntegral3s16 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedIntegral3s16 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedIntegral3s16 < > ( b , base , offset ) ;


signature:
public class PVectorByteBufferedFloating2s32 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedFloating2s32 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedFloating2s32 < > ( b , base , offset ) ;


signature:
public class VectorByteBufferedIntegral4s32 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedIntegral4s32 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedIntegral4s32 ( b , base , offset ) ;


signature:
public class Quaternion4FGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < Quaternion4F > create ( ) { } }

implementation: return new Quaternion4FGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_FLOAT_LOWER , GeneratorConstants . BOUND_NORMAL_FLOAT_UPPER ) ) ;


signature:
public class PVector3DGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - ( 2 ^ 16 ) , 2 ^ 16 ] } .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < PVector3D < T > > createSmall ( ) { } }

implementation: return new PVector3DGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_SMALL_DOUBLE_LOWER , GeneratorConstants . BOUND_SMALL_DOUBLE_UPPER ) ) ;


signature:
public class PVector3DGenerator { /** * Create a generator initialized with a default component generator .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < PVector3D < T > > create ( ) { } }

implementation: return new PVector3DGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_DOUBLE_LOWER , GeneratorConstants . BOUND_LARGE_DOUBLE_UPPER ) ) ;


signature:
public class PVector3DGenerator { /** * Create a generator initialized with a default component generator that
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ param < T > A phantom type parameter
 * @ return A generator */
public static < T > Generator < PVector3D < T > > createNormal ( ) { } }

implementation: return new PVector3DGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_DOUBLE_LOWER , GeneratorConstants . BOUND_NORMAL_DOUBLE_UPPER ) ) ;


signature:
public class MatrixByteBuffered3x3s32 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static MatrixByteBuffered3x3s32 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new MatrixByteBuffered3x3s32 ( b , base , offset ) ;


signature:
public class Matrix3x3DGenerator { /** * Create a generator initialized with a default component generator .
 * @ return A generator */
public static Generator < Matrix3x3D > create ( ) { } }

implementation: return new Matrix3x3DGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_DOUBLE_LOWER , GeneratorConstants . BOUND_LARGE_DOUBLE_UPPER ) ) ;


signature:
public class Matrix3x3DGenerator { /** * Create a generator initialized with a default component generator that only
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ return A generator */
public static Generator < Matrix3x3D > createNormal ( ) { } }

implementation: return new Matrix3x3DGenerator ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_DOUBLE_LOWER , GeneratorConstants . BOUND_NORMAL_DOUBLE_UPPER ) ) ;


signature:
public class VectorByteBufferedFloating4s32 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static VectorByteBufferedFloating4s32 createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new VectorByteBufferedFloating4s32 ( b , base , offset ) ;


signature:
public class PMatrix4x4DGenerator { /** * Create a generator initialized with a default component generator .
 * @ param < A > A phantom type parameter ( possibly representing a source
 * coordinate system )
 * @ param < B > A phantom type parameter ( possibly representing a target
 * coordinate system )
 * @ return A generator */
public static < A , B > Generator < PMatrix4x4D < A , B > > create ( ) { } }

implementation: return new PMatrix4x4DGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_LARGE_DOUBLE_LOWER , GeneratorConstants . BOUND_LARGE_DOUBLE_UPPER ) ) ;


signature:
public class PMatrix4x4DGenerator { /** * Create a generator initialized with a default component generator that only
 * produces values in the range { @ code [ - 1.0 , 1.0 ] } .
 * @ param < A > A phantom type parameter ( possibly representing a source
 * coordinate system )
 * @ param < B > A phantom type parameter ( possibly representing a target
 * coordinate system )
 * @ return A generator */
public static < A , B > Generator < PMatrix4x4D < A , B > > createNormal ( ) { } }

implementation: return new PMatrix4x4DGenerator < > ( PrimitiveGenerators . doubles ( GeneratorConstants . BOUND_NORMAL_DOUBLE_LOWER , GeneratorConstants . BOUND_NORMAL_DOUBLE_UPPER ) ) ;


signature:
public class PVectorByteBufferedIntegral4s8 { /** * < p > Return a new vector that is backed by the given byte buffer { @ code
 * b } < / p >
 * < p > The data for the instance will be taken from the data at the current
 * value of { @ code base . get ( ) + offset } , each time a field is requested or
 * set . < / p >
 * < p > No initialization of the data is performed . < / p >
 * @ param < T > A phantom type parameter
 * @ param b The byte buffer
 * @ param base The base address
 * @ param offset A constant offset
 * @ return A new buffered vector */
public static < T > PVectorByteBufferedIntegral4s8 < T > createWithBase ( final ByteBuffer b , final MutableLongType base , final int offset ) { } }

implementation: return new PVectorByteBufferedIntegral4s8 < > ( b , base , offset ) ;


signature:
public class Gateway { /** * Inits the .
 * @ param redisGatewayList the redis gateway list
 * @ param addressValidMap */
private void init ( List < GatewayAddress > redisGatewayList ) { } }

implementation: for ( GatewayAddress redisGateway : redisGatewayList ) { final GatewayServer server = new GatewayServer ( redisGateway , config . getPoolConfig ( ) , config . getTimeoutMillisec ( ) , config . getKeyspace ( ) , gcp ) ; final int count = server . preload ( 0 , config . getConnectPerDelayMillis ( ) , config . getPoolConfig ( ) ) ; server . setValid ( count > 0 ) ; this . servers . put ( redisGateway . getName ( ) , server ) ; try { this . gcp . addGw ( redisGateway . getId ( ) , redisGateway . getHost ( ) , redisGateway . getPort ( ) , config . getPhysicalConnectionCount ( ) , config . getPhysicalConnectionReconnectInterval ( ) ) . get ( config . getTimeoutMillisec ( ) , TimeUnit . MILLISECONDS ) ; } catch ( InterruptedException e ) { log . error ( "[GatewayServer] Failed to connect " , e ) ; } catch ( ExecutionException e ) { log . error ( "[GatewayServer] Failed to connect " , e ) ; } catch ( TimeoutException e ) { log . error ( "[GatewayServer] Failed to connect " , e ) ; } } buildIndex ( ) ; log . info ( "[Gateway] Initialized " + servers ) ;


signature:
public class RedisConnectionAsync { /** * Send command .
 * @ param cmd the cmd
 * @ param args the args
 * @ return the redis connection */
public void sendCommand ( final Command cmd , final byte [ ] ... args ) { } }

implementation: log . trace ( "[RedisConnection] Command={} {}" , cmd . name ( ) , toStringArgs ( args ) ) ; RedisProtocol . sendCommand ( outputStream , cmd , args ) ; try { outputStream . flush ( ) ; } catch ( IOException e ) { throw new JedisConnectionException ( e ) ; } final SettableFuture < byte [ ] > future = SettableFuture . create ( ) ; byte [ ] cmdBytes = new byte [ outputBuf . readableBytes ( ) ] ; outputBuf . readBytes ( cmdBytes ) ; outputBuf . discardSomeReadBytes ( ) ; vc . request ( cmdBytes , activeTimeout , new RequestCallback ( ) { @ Override public void onResponse ( byte [ ] response , StatusCode statusCode ) { switch ( statusCode ) { case OK : future . set ( response ) ; break ; case CONNECTION_ERROR : future . setException ( new GatewayException ( "Connection error" ) ) ; break ; case INTERNAL_ERROR : future . setException ( new GatewayException ( "Internal error" ) ) ; break ; case NO_AVAILABLE_CONNECTION : future . setException ( new GatewayException ( "no available connection" ) ) ; break ; case SHUTDOWN : future . setException ( new GatewayException ( "already closed" ) ) ; break ; case TIMEOUT : future . setException ( new GatewayException ( "Timeout" ) ) ; break ; } } } ) ; pipelinedFutures . add ( future ) ;


signature:
public class RedisConnectionAsync { /** * Gets the binary multi bulk reply .
 * @ return the binary multi bulk reply */
@ SuppressWarnings ( "unchecked" ) public static List < byte [ ] > getBinaryMultiBulkReply ( byte [ ] input ) { } }

implementation: return ( List < byte [ ] > ) RedisProtocol . read ( new RedisInputStream ( new ByteArrayInputStream ( input ) ) ) ;


signature:
public class RedisConnectionAsync { /** * Gets the object multi bulk reply .
 * @ return the object multi bulk reply */
@ SuppressWarnings ( "unchecked" ) public static List < Object > getObjectMultiBulkReply ( byte [ ] input ) { } }

implementation: return ( List < Object > ) RedisProtocol . read ( new RedisInputStream ( new ByteArrayInputStream ( input ) ) ) ;


signature:
public class RedisConnectionAsync { /** * Gets the integer multi bulk reply .
 * @ return the integer multi bulk reply */
@ SuppressWarnings ( "unchecked" ) public static List < Long > getIntegerMultiBulkReply ( byte [ ] input ) { } }

implementation: return ( List < Long > ) RedisProtocol . read ( new RedisInputStream ( new ByteArrayInputStream ( input ) ) ) ;


signature:
public class RedisConnectionAsync { /** * Gets the status code reply .
 * @ return the status code reply */
public static String getStatusCodeReply ( byte [ ] buf ) { } }

implementation: final byte [ ] resp = ( byte [ ] ) RedisProtocol . read ( new RedisInputStream ( new ByteArrayInputStream ( buf ) ) ) ; if ( null == resp ) { return null ; } else { return SafeEncoder . encode ( resp ) ; }


signature:
public class RedisConnectionAsync { /** * To byte arrays .
 * @ param keyspace the keyspace
 * @ param uid the uid
 * @ param serviceCode the service code
 * @ param key the key
 * @ param expireMillis the expire millis
 * @ param values the values
 * @ return the byte [ ] [ ] */
protected byte [ ] [ ] toByteArrays ( final byte [ ] keyspace , final byte [ ] uid , final byte [ ] serviceCode , final byte [ ] key , final long expireMillis , final byte [ ] [ ] values ) { } }

implementation: final byte [ ] [ ] allArgs = new byte [ values . length * 2 + 4 ] [ ] ; int index = 0 ; allArgs [ index ++ ] = keyspace ; allArgs [ index ++ ] = uid ; allArgs [ index ++ ] = serviceCode ; allArgs [ index ++ ] = key ; byte [ ] expireTime = RedisProtocol . toByteArray ( expireMillis ) ; for ( int i = 0 ; i < values . length ; i ++ ) { allArgs [ index ++ ] = values [ i ] ; allArgs [ index ++ ] = expireTime ; } return allArgs ;


signature:
public class DefaultBoundSessionOfHashSetOperations { /** * @ see BoundSessionOfHashSetOperations # get ( java . lang . Object ) */
public Set < HV > get ( HK key ) { } }

implementation: return ops . get ( getKey ( ) , getField ( ) , key ) ;


signature:
public class DefaultBoundSessionOfHashSetOperations { /** * @ see BoundSessionOfHashSetOperations # multiGet ( java . util . Collection ) */
public Map < HK , Set < HV > > multiGet ( Collection < HK > keys ) { } }

implementation: return ops . mulitGet ( getKey ( ) , getField ( ) , keys ) ;


signature:
public class DefaultBoundSessionOfHashSetOperations { /** * @ see BoundSessionOfHashSetOperations # add ( java . lang . Object , java . util . Collection ) */
public Long add ( HK key , Collection < HV > values ) { } }

implementation: return ops . multiAdd ( getKey ( ) , getField ( ) , key , values ) ;


signature:
public class DefaultBoundSessionOfHashSetOperations { /** * @ see BoundSessionOfHashSetOperations # add ( java . lang . Object , java . util . Collection , long , java . util . concurrent . TimeUnit ) */
public Long add ( HK key , Collection < HV > values , long timeout , TimeUnit unit ) { } }

implementation: return ops . multiAdd ( getKey ( ) , getField ( ) , key , values , timeout , unit ) ;


signature:
public class DefaultBoundSessionOfHashSetOperations { /** * @ see BoundSessionOfHashSetOperations # set ( java . lang . Object , java . lang . Object , long , java . util . concurrent . TimeUnit ) */
public Long set ( HK key , HV value , long timeout , TimeUnit unit ) { } }

implementation: return ops . set ( getKey ( ) , getField ( ) , key , value , timeout , unit ) ;


signature:
public class DefaultBoundSessionOfHashSetOperations { /** * @ see BoundSessionOfHashSetOperations # set ( java . lang . Object , java . util . Collection ) */
public Long set ( HK key , Collection < HV > values ) { } }

implementation: return ops . multiSet ( getKey ( ) , getField ( ) , key , values ) ;


signature:
public class DefaultBoundSessionOfHashSetOperations { /** * @ see BoundSessionOfHashSetOperations # set ( java . lang . Object , java . util . Collection , long , java . util . concurrent . TimeUnit ) */
public Long set ( HK key , Collection < HV > values , long timeout , TimeUnit unit ) { } }

implementation: return ops . multiSet ( getKey ( ) , getField ( ) , key , values , timeout , unit ) ;


signature:
public class DefaultBoundSessionOfHashSetOperations { /** * @ see BoundSessionOfHashSetOperations # del ( java . lang . Object , java . util . Collection ) */
public Long del ( HK key , Collection < HV > values ) { } }

implementation: return ops . multiDel ( getKey ( ) , getField ( ) , key , values ) ;