DoubleBufferConsumer target
double[] elements
DoubleArrayList list
int capacity
int size
DoubleBuffer2DConsumer target
double[] xElements
double[] yElements
DoubleArrayList xList
DoubleArrayList yList
int capacity
int size
DoubleBuffer3DConsumer target
double[] xElements
double[] yElements
double[] zElements
DoubleArrayList xList
DoubleArrayList yList
DoubleArrayList zList
int capacity
int size
IntBufferConsumer target
int[] elements
IntArrayList list
int capacity
int size
IntBuffer2DConsumer target
int[] xElements
int[] yElements
IntArrayList xList
IntArrayList yList
int capacity
int size
IntBuffer3DConsumer target
int[] xElements
int[] yElements
int[] zElements
IntArrayList xList
IntArrayList yList
IntArrayList zList
int capacity
int size
ObjectBufferConsumer target
Object[] elements
ObjectArrayList list
int capacity
int size
long[] distinctValues
MinMaxNumberList elements
Object[] elements
int size
int distinct
int lowWaterMark
int highWaterMark
double minLoadFactor
double maxLoadFactor
int[] table
Object[] values
byte[] state
int freeEntries
long[] table
Object[] values
byte[] state
int freeEntries
String alignment
String format
int minColumnWidth
String columnSeparator
String rowSeparator
String sliceSeparator
boolean printShape
int columns
int rows
int rowStride
int columnStride
int rowZero
int columnZero
int slices
int rows
int columns
int sliceStride
int rowStride
int columnStride
int sliceZero
int rowZero
int columnZero
double[] elements
Object[] elements
Object[] elements
Object[] elements
IntArrayList indexes
DoubleArrayList values
int[] starts
AbstractIntDoubleMap elements
AbstractIntDoubleMap elements
int dummy
AbstractIntDoubleMap elements
AbstractIntObjectMap elements
AbstractIntObjectMap elements
AbstractIntObjectMap elements
Property property
DoubleMatrix2D L
int n
boolean isSymmetricPositiveDefinite
int n
boolean issymmetric
double[] d
double[] e
double[][] V
double[][] H
double[] ort
LUDecompositionQuick quick
DoubleMatrix2D LU
int pivsign
int[] piv
boolean isNonSingular
Algebra algebra
DoubleMatrix2D QR
int m
int n
DoubleMatrix1D Rdiag
double[][] U
double[][] V
double[] s
int m
int n
RandomEngine randomGenerator
RandomEngine randomGenerator
double alpha
double beta
double PDF_CONST
double a_last
double b_last
double a_
double b_
double t
double fa
double fb
double p1
double p2
double c
double ml
double mu
double p_last
double q_last
double a
double b
double s
double m
double D
double Dl
double x1
double x2
double x4
double x5
double f1
double f2
double f4
double f5
double ll
double lr
double z2
double z4
double p3
double p4
int n
double p
int n_last
int n_prev
double par
double np
double p0
double q
double p_last
double p_prev
int b
int m
int nm
double pq
double rc
double ss
double xm
double xl
double xr
double ll
double lr
double c
double p1
double p2
double p3
double p4
double ch
double log_p
double log_q
double log_n
Uniform uniform
int my_N
int my_s
int my_n
int N_last
int M_last
int n_last
int N_Mn
int m
int mp
int b
double Mp
double np
double fm
int k2
int k4
int k1
int k5
double dl
double dr
double r1
double r2
double r4
double r5
double ll
double lr
double c_pm
double f1
double f2
double f4
double f5
double p1
double p2
double p3
double p4
double p5
double p6
double mean
double my_old
double p
double q
double p0
double[] pp
int llll
double my_last
double ll
int k2
int k4
int k1
int k5
double dl
double dr
double r1
double r2
double r4
double r5
double lr
double l_my
double c_pm
double f1
double f2
double f4
double f5
double p1
double p2
double p3
double p4
double p5
double p6
int m
long my_n
long my_N
long my_low
RandomEngine my_RandomGenerator
RandomSampler sampler
long[] buffer
int bufferPosition
long skip
long n
int skip
int nextTriggerPos
int nextSkip
int weight
Uniform generator
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionBOp[] args
 Note: This field is reported out as a List so we can make it
 thread safe and, if desired, immutable. However, it is internally a
 simple array. Subclasses can implement mutation operations which return
 deep copies in which the argument values have been modified using
 BOpBase._set(int, BOp).
 
 If we allowed mutation of the arguments (outside of the object creation
 pattern) then caching of the arguments (or annotations) by classes such
 as EQ will cause CoreBaseBOp.clone() to fail because (a) it will do
 a field-by-field copy on the concrete implementation class; and (b) it
 will not consistently update the cached references. In order to "fix"
 this problem, any classes which cache arguments or annotations would have
 to explicitly overrides CoreBaseBOp.clone() in order to set those fields
 based on the arguments on the cloned BOpBase class.
 
 Note: This must be at least "effectively" final per the effectively
 immutable contract for BOps.
Map<K,V> annotations
 Note: This must be at least "effectively" final per the effectively
 immutable contract for BOps.
Object value
IBindingSet delegate
UUID queryId
UUID of the IRunningQuery which generated the named
 solution set. This is where you need to look to find the data.
 
 Note: The value null has two different interpretations
 depending on which constructor form was used.  
 
IQueryAttributes. When queryId is
 null, the code will look at the
 IQueryAttributes for the current running query
 (this form is the new usage and makes it possible to scope an attribute
 to an instance of a query when the same query plan is executed more than
 once, as it is for the sub-queries issued by the property path operator).
 Otherwise it will resolve the identified query and use its
 IQueryAttributes (this 2nd form is the historical
 usage and makes it possible to reference an attribute on a parent query).
 String namespace
null if the
 named solution set is attached to an IRunningQuery.long timestamp
 Note: This MUST be ignored if NamedSolutionSetRef.namespace is null.
String localName
IVariable<E>[] joinVars
private Object readResolve() throws ObjectStreamException
ObjectStreamExceptionboolean anonymous
String name
IPredicate<E> pred
IKeyOrder<E> keyOrder
int limit
Object[] sample
HashSet<E> members
ConcurrentHashMap here.public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionprivate Object readResolve() throws ObjectStreamException
ObjectStreamExceptionLinkedHashMap<K,V> current
int hash
DiskCostModel diskCostModel
DiskCostModel diskCostModel
int ngraphs
int limit
int nsamples
long rangeCount
double cost
CAT elapsed
CAT opCount
CAT chunksIn
CAT unitsIn
CAT chunksOut
CAT unitsOut
CAT typeErrors
Note: SPARQL type errors in aggregations often cause bindings or solutions to fail without causing any runtime exception which can be observed at the query level. This counter provides a means to observe those errors.
CAT mutationCount
Note: This mutation counts should reflect the #of tuples written on a relation rather than on an index. The per-index tuple mutation count MAY also be reported, but it should be reported by extending this class and declaring additional mutation counters.
 Note: Operations which fix point some closure depend on the correctness
 of the BOpStats.mutationCount for their termination condition.
 
 Note: Mutation operations MUST NOT overwrite existing tuples with
 identical state. This is important for two reasons. First, fix point
 operations depend on the BOpStats.mutationCount being ZERO (0) in a given
 round if nothing was changed in order to terminate the closure. Second,
 due to the general MVCC and copy-on-write architecture, index writes
 drive IO. If the tuple state would not be changed, then the index write
 SHOULD NOT be performed.
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionIQueryClient queryController
UUID queryControllerId
UUID for the query controller.UUID queryId
int bopId
BOp.int partitionId
BOp.int solutionCount
IBindingSet[][] bindingSetChunks
IQueryClient queryController
UUID queryControllerId
UUID for the query controller.UUID queryId
int bopId
BOp.int partitionId
BOp.SolutionSetStream ssstr
MemStore mmgr
long byteCount
SolutionSetStream for
 the IChunkMessage.boolean released
UUID queryId
IQueryClient clientProxy
PipelineOp query
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionStaticAnalysisStat resolveValuesStat
StaticAnalysisStat parserStat
StaticAnalysisStat optimizerLoopStat
StaticAnalysisStat rangeCountStat
Map<K,V> optimizerStats
IQueryClient queryController
UUID queryControllerId
UUID queryId
int bopId
int partitionId
boolean lastInvocation
IQueryClient queryController
UUID queryControllerId
UUID queryId
int bopId
int partitionId
int solutionCount
int nbytes
com.bigdata.bop.fed.NIOChunkMessage.A[] allocations
DirectBufferPoolAllocator.IAllocations if the chunk did not get formatted onto a single
 DirectBufferPoolAllocator.IAllocation.InetSocketAddress addr
ResourceService.List<E> materialized
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionCAT accessPathDups
CAT accessPathCount
Note: Some join operators can coalesce duplicate access paths. Such operators may reported fewer access paths here.
Note: Hash join operators typically run the access path exactly once (if they are written to use the native heap and their memory budget is exceeded then they may run the access path more than once).
CAT accessPathRangeCount
CAT accessPathChunksIn
IAccessPath.CAT accessPathUnitsIn
IAccessPath.CAT solutionSetSize
CAT inputSolutions
 Note: This counter is highly correlated with BOpStats.unitsIn but
 is incremented only when we begin evaluation of the IAccessPath
 associated with a specific input solution.
 
 When PipelineJoin.Annotations.COALESCE_DUPLICATE_ACCESS_PATHS is
 true, multiple input binding sets can be mapped onto the
 same IAccessPath and this counter will be incremented by the #of
 such input binding sets.
CAT outputSolutions
PipelineJoinStats.getJoinHitRatio(). Of
 necessity, updates to PipelineJoinStats.inputSolutions slightly lead updates to
 PipelineJoinStats.inputSolutions.
 
 Note: This counter is highly correlated with BOpStats.unitsOut.
IPredicate<E> pred
IPredicate associated with the Vertex. This basically
 provides the information necessary to select an appropriate access path.Throwable firstCause
int nominalCapacity
LinkedHashMap<K,V> lru
IndexMetadata metadata
IKeyBuilder keyBuilder
int[] filterKeyOrder
ICheckpointProtocol index
NativeDistinctFilter.DistinctFilterImpl.lru overflows at least once.
 
 Note: Maybe either a BTree or an HTree. The code has
 paths for both.
AtomicBoolean open
true until closed.boolean isBTree
MemStore store
CAT toldTriples
LinkedHashMap<K,V> aggExpr
IValueExpression<E>[] select2
IConstraint[] having2
IValueExpression<E>[] select
IValueExpression<E>[] groupBy
IConstraint[] having
LinkedHashSet<E> groupByVars
LinkedHashSet<E> selectVars
LinkedHashSet<E> columnVars
boolean anyDistinct
boolean selectDependency
boolean nestedAggregates
boolean simpleHaving
AtomicLong nseen
AtomicLong naccepted
IValueExpression<E> expr
boolean asc
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
BloomFilter.addr is set to 0L, the
 BloomFilter.dirty flag is cleared, and BloomFilter.enabled flag is set. It's
 necessary to override serialization otherwise java will default the
 BloomFilter.enabled flag to false when an object is
 de-serialized - whoops!IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionint n
double p
double maxP
BTree once the bloom filter can be expected to realize this error
 rate).int maxN
BTree will
 automatically disable its bloom filter once this many elements have been
 inserted. In practice, this is only a constraint on scale-up indices. For
 scale-out indices the maximum applies only the mutable BTree
 absorbing writes destined for a specific index partition and the
 IndexSegments will have "perfect fit" bloom filters.int m
int height
long nodeCount
long leafCount
long entryCount
IBTreeUtilizationReport utilReport
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionITupleCursor<E> src
#filter(ITupleCursor).ITupleSerializer<K,V> tupleSer
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionint initialCapacity
CollatorEnum collator
Locale locale
Locale.Object strength
null, which means
 no override).DecompositionEnum decompositionMode
null, which means
 no override).public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic final void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic final void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic final void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic final void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic final void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic final void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic final void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic final void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic final void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic final void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic final void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic final void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionString metricName
boolean asc
long token
UUID problemServiceId
long timeoutNanos
IHANotifyReleaseTimeResponse consensusReleaseTime
boolean isGatherService
boolean isJoinedService
boolean isRootBlock0
byte[] rootBlock
long timeout
TimeUnit unit
UUID storeUUID
UUID storeUUID
byte[] digest
long token
long timestampOnLeader
UUID leaderId
long newCommitCounter
long newCommitTime
UUID serviceId
long commitCounter
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionUUID serviceUUID
long pinnedCommitTime
long pinnedCommitCounter
long timestamp
boolean isMock
long newCommitCounter
long newCommitTime
long quorumToken
UUID storeUUID
long addr
UUID serviceId
UUID storeUUID
boolean isNonBlocking
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput arg0) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput arg0) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionprivate void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionprivate void writeObject(ObjectOutputStream s) throws IOException
Object) in the proper order, followed by a nullIOExceptionint capacity
ReentrantLock lock
Condition notEmpty
Condition notFull
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionprivate void writeObject(ObjectOutputStream s) throws IOException
Object) in the proper order,
 followed by a nullIOExceptionint capacity
AtomicInteger count
ReentrantLock takeLock
Condition notEmpty
ReentrantLock putLock
Condition notFull
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionUUID uuid
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionW3CQueryLanguageException.LanguageFamily languageFamily
W3CQueryLanguageException.ErrorCategory errorCategory
int errorCode
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
Values but not
 BigdataValues since the AbstractTripleStore reference is
 not available and we can not obtain the appropriate
 BigdataValueFactory instance without it. This should not matter
 since the only access to the Values is via BaseVocabulary.get(Value)
 and BaseVocabulary.getConstant(Value).IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionRandom rand
IV<V extends BigdataValue,T> from
IV<V extends BigdataValue,T> to
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
BigdataValue
 .IOExceptionClassNotFoundExceptionprivate void writeObject(ObjectOutputStream out) throws IOException
BigdataValue.IOExceptionhttps://sourceforge.net/apps/trac/bigdata/ticket/337AbstractLiteralIV<V extends BigdataLiteral,T> delegate
IV<V extends BigdataValue,T> extensionIV
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
BigdataValue
 .IOExceptionClassNotFoundExceptionprivate void writeObject(ObjectOutputStream out) throws IOException
BigdataValue.IOExceptionString id
private Object writeReplace() throws ObjectStreamException
ObjectStreamExceptionISPO spo
UUID id
String label
String language
FullyInlineTypedLiteralIV.datatype).org.openrdf.model.URI datatype
FullyInlineTypedLiteralIV.language).byte termCode
ITermIndexCodesboolean temp
true iff the IV represents a temporary
 IV reference. Temporary IVs are somewhat special.
 They are used while preparing query/update without access to the triple store.
 Temporary IVs have to be recreated while executing update,
 as new terms may need adding to Term2ID and ID2Term indexes.(SPARQL Parsers should not be db mode aware)
 Introduced while fixing issue, 
(Problems with Fulltext Index)IPv4Address value
InlineLiteralIV<V extends BigdataLiteral,T>[] ivs
AbstractLiteralIV<V extends BigdataLiteral,T> delegate
IV<V extends BigdataValue,T> datatype
IV<V extends BigdataValue,T> delegate
UUID value
BigDecimal value
int hash
BigInteger value
Number number
AbstractInlineIV<V extends BigdataValue,T> namespaceIV
AbstractLiteralIV<V extends BigdataLiteral,T> delegateIV
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic final void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic final void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic final void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic final void writeExternal(ObjectOutput out) throws IOException
IOExceptionString query
String languageCode
boolean prefixMatch
double minCosine
double maxCosine
int minRank
int maxRank
boolean matchAllTerms
boolean matchExact
long timeout
TimeUnit unit
String matchRegex
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic final void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic final void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
Values but not
 BigdataValues since the AbstractTripleStore reference is
 not available and we can not obtain the appropriate
 BigdataValueFactory instance without it. This should not matter
 since the only access to the Values is via BaseVocabulary.get(Value)
 and BaseVocabulary.getConstant(Value).IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionString label
String language
BigdataURI datatype
BigdataResource s
BigdataURI p
BigdataValue o
BigdataResource c
IV<V extends BigdataValue,T> sid
StatementEnum type
boolean userFlag
int hash
String uriString
int indexOf
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionprivate void writeObject(ObjectOutputStream out) throws IOException
BigdataValueFactory singleton reference for
 that namespace when the value is deserialized.IOExceptionIV<V extends BigdataValue,T> iv
IVariable<E> h
SPOKeyOrder keyOrder
IRuleTaskFactory taskFactory
IJoinNexus joinNexus
IBuffer<E> buffer
IRule<E> rule
IVariable<E> h
SPOKeyOrder keyOrder
Axioms axioms
IV<V extends BigdataValue,T> rdfType
IV<V extends BigdataValue,T> rdfsResource
boolean forwardChainRdfTypeRdfsResource
String focusStore
RuleContextEnum ruleContext
boolean justify
boolean backchain
boolean isOwlSameAsUsed
UUID queryId
Token currentToken
int[][] expectedTokenSequences
String[] tokenImage
String eol
int kind
int beginLine
int beginColumn
int endLine
int endColumn
String image
Token next
Token specialToken
RESTServlet m_restServlet
.../namespace/NAMESPACE/sparql.String prefix
Context - Path / LBS
 Note: This is set by HALoadBalancerServlet.init(). It must not be null.
 The load balancer relies on the prefix to rewrite the Request-URI: (a)
 when it is disabled (the request will be forwarded to a local service;
 and (b) when the request is proxied to a remote service.
AtomicReference<V> policyRef
IHALoadBalancerPolicy and null iff
 the load balancer is disabled. If the LBS is not enabled, then it will
 strip its prefix from the URL requestURI and do a servlet forward to the
 resulting requestURI. This allows the webapp to start even if the LBS is
 not correctly configured.AtomicReference<V> rewriterRef
IHARequestURIRewriter that rewrites the original Request-URI
 into a Request-URI for the target service to which the request will be
 proxied.CAT nforward
CAT nproxy
CAT nerror
#rewriteURI(HttpServletRequest)
 trapped an error.
 Note: Such requests wind up being forwarded to the local service.
RESTServlet m_restServlet
.../namespace/NAMESPACE/sparql.QueryServlet m_queryServlet
InsertServlet m_insertServlet
DeleteServlet m_deleteServlet
UpdateServlet m_updateServlet
WorkbenchServlet m_workbenchServlet
BlueprintsServletProxy m_blueprintsServlet
MapgraphServletProxy m_mapgraphServlet
DescribeCacheServlet m_describeServlet
AtomicReference<V> localForwardThresholdRef
AtomicReference<V> scoringRuleRef
IHostMetrics.long hostDiscoveryInitialDelay
long hostDiscoveryDelay
Random rand
AtomicReference<V> hostTableRef
HostTable data.ScheduledFuture<V> scheduledFuture
Future of a task that periodically queries the ganglia peer
 for its up to date host counters for each discovered host.AtomicReference<V> contextPath
ServletContext.getContextPath() is cached in
 AbstractLBSPolicy.init(ServletConfig, IIndexManager).AtomicReference<V> journalRef
AtomicReference<V> serviceIDRef
UUID of the HAJournalServer.AtomicReference<V> serviceTableRef
AtomicLong nextService
ConcurrentHashMap<K,V> hostMetricsMap
UUID as the key. This means that we can not monitor the GC load
 associated with a specific JVM instance. [Another problem is that the
 metrics that we are collecting have the hostname as a prefix. The service
 metrics do not. This will cause problems in the path prefix in the
 CounterSet when we try to resolve the performance counter name.
 We could work around that by using a regex pattern to match the counters
 of interest, ignoring where they appear in the CounterSet
 hierarchy.]AtomicInteger nextValue
counters
 servlet.AtomicReference<V> gangliaServiceRef
long nsolutions
Set<E> usedVars
Set<E> alwaysBound
Set<E> notAlwaysBound
Set<E> materialized
IVCache
 association set whenever the variable is bound in a solution.Map<K,V> constants
INeedsMaterialization.Requirement requirement
Set<E> varsToMaterialize
String lex
long timestamp
IGroupNode<E extends IGroupMemberNode> parent
IGroupNode<E extends IGroupMemberNode> parent
int maxParallel
Collection<E> graphs
long estimatedRangeCount
GeoSpatialLiteralExtension<V extends BigdataValue> litExt
GeoSpatialDatatypeConfiguration datatypeConfig
int objectPos
Integer contextPos
BigdataURI context
GeoSpatialCounters geoSpatialCounters
double spatialPointLat
double spatialPointLon
Double distanceInMeters
int idxOfLat
int idxOfLon
boolean latLonIndicesValid
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
Values but not
 BigdataValues since the AbstractTripleStore reference is
 not available and we can not obtain the appropriate
 BigdataValueFactory instance without it. This should not matter
 since the only access to the Values is via BaseVocabulary.get(Value)
 and BaseVocabulary.getConstant(Value).IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionprivate void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionprivate void writeObject(ObjectOutputStream out) throws IOException
IOExceptionprivate Object readResolve() throws ObjectStreamException
ObjectStreamExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionprivate void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionprivate void writeObject(ObjectOutputStream out) throws IOException
IOExceptionprivate Object readResolve() throws ObjectStreamException
ObjectStreamExceptionprivate void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionprivate void writeObject(ObjectOutputStream out) throws IOException
IOExceptionprivate Object readResolve() throws ObjectStreamException
ObjectStreamExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic final void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic final void writeExternal(ObjectOutput out) throws IOException
IOExceptionprivate void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionprivate void writeObject(ObjectOutputStream out) throws IOException
IOExceptionprivate Object readResolve() throws ObjectStreamException
ObjectStreamExceptionIV<V extends BigdataValue,T> s
IV<V extends BigdataValue,T> p
IV<V extends BigdataValue,T> o
IV<V extends BigdataValue,T> c
IV<V extends BigdataValue,T> sid
Note: this is not final since we create it only on demand.
byte flags
int hashCode
public final void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic final void writeExternal(ObjectOutput out) throws IOException
IOExceptionprivate Object readResolve() throws ObjectStreamException
 Note: implementing Externalizable drops the serialized size from
 61 bytes per instance to 56 bytes per instance. On the other hand, if the
 class embedding the SPOKeyOrder serializes the SPOKeyOrder.index as
 a byte, it only take a single byte to serialize each
 instance.
 
 Note: Serialization breaks with the introduction of quads as the
 name field is no longer serialized and the SPOKeyOrder.index()
 is serialized as a byte field.
ObjectStreamExceptionbyte index
Collection<E> starConstraints
IVariableOrConstant<E> p
IVariableOrConstant<E> o
boolean optional
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
Values but not
 BigdataValues since the AbstractTripleStore reference is
 not available and we can not obtain the appropriate
 BigdataValueFactory instance without it. This should not matter
 since the only access to the Values is via BaseVocabulary.get(Value)
 and BaseVocabulary.getConstant(Value).IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
Values but not
 BigdataValues since the AbstractTripleStore reference is
 not available and we can not obtain the appropriate
 BigdataValueFactory instance without it. This should not matter
 since the only access to the Values is via BaseVocabulary.get(Value)
 and BaseVocabulary.getConstant(Value).IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
Values but not
 BigdataValues since the AbstractTripleStore reference is
 not available and we can not obtain the appropriate
 BigdataValueFactory instance without it. This should not matter
 since the only access to the Values is via BaseVocabulary.get(Value)
 and BaseVocabulary.getConstant(Value).IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
Values but not
 BigdataValues since the AbstractTripleStore reference is
 not available and we can not obtain the appropriate
 BigdataValueFactory instance without it. This should not matter
 since the only access to the Values is via BaseVocabulary.get(Value)
 and BaseVocabulary.getConstant(Value).IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
Values but not
 BigdataValues since the AbstractTripleStore reference is
 not available and we can not obtain the appropriate
 BigdataValueFactory instance without it. This should not matter
 since the only access to the Values is via BaseVocabulary.get(Value)
 and BaseVocabulary.getConstant(Value).IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
Values but not
 BigdataValues since the AbstractTripleStore reference is
 not available and we can not obtain the appropriate
 BigdataValueFactory instance without it. This should not matter
 since the only access to the Values is via BaseVocabulary.get(Value)
 and BaseVocabulary.getConstant(Value).IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
Values but not
 BigdataValues since the AbstractTripleStore reference is
 not available and we can not obtain the appropriate
 BigdataValueFactory instance without it. This should not matter
 since the only access to the Values is via BaseVocabulary.get(Value)
 and BaseVocabulary.getConstant(Value).IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
Values but not
 BigdataValues since the AbstractTripleStore reference is
 not available and we can not obtain the appropriate
 BigdataValueFactory instance without it. This should not matter
 since the only access to the Values is via BaseVocabulary.get(Value)
 and BaseVocabulary.getConstant(Value).IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
Values but not
 BigdataValues since the AbstractTripleStore reference is
 not available and we can not obtain the appropriate
 BigdataValueFactory instance without it. This should not matter
 since the only access to the Values is via BaseVocabulary.get(Value)
 and BaseVocabulary.getConstant(Value).IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
Values but not
 BigdataValues since the AbstractTripleStore reference is
 not available and we can not obtain the appropriate
 BigdataValueFactory instance without it. This should not matter
 since the only access to the Values is via BaseVocabulary.get(Value)
 and BaseVocabulary.getConstant(Value).IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
Values but not
 BigdataValues since the AbstractTripleStore reference is
 not available and we can not obtain the appropriate
 BigdataValueFactory instance without it. This should not matter
 since the only access to the Values is via BaseVocabulary.get(Value)
 and BaseVocabulary.getConstant(Value).IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
Values but not
 BigdataValues since the AbstractTripleStore reference is
 not available and we can not obtain the appropriate
 BigdataValueFactory instance without it. This should not matter
 since the only access to the Values is via BaseVocabulary.get(Value)
 and BaseVocabulary.getConstant(Value).IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
Values but not
 BigdataValues since the AbstractTripleStore reference is
 not available and we can not obtain the appropriate
 BigdataValueFactory instance without it. This should not matter
 since the only access to the Values is via BaseVocabulary.get(Value)
 and BaseVocabulary.getConstant(Value).IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
Values but not
 BigdataValues since the AbstractTripleStore reference is
 not available and we can not obtain the appropriate
 BigdataValueFactory instance without it. This should not matter
 since the only access to the Values is via BaseVocabulary.get(Value)
 and BaseVocabulary.getConstant(Value).IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionIElementFilter<E> test
SameVariableConstraint<E> sameVariableConstraint
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionint lastIndex
ThickAsynchronousIterator.next() and -1
 if NO elements have been visited.Object[] a
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionint lastIndex
ThickCloseableIterator.next() and -1
 if NO elements have been visited.Object[] a
int len
String name
boolean parallel
boolean closure
IQueryOptions queryOptions
List<E> steps
boolean distinct
boolean stable
ISortOrder<E>[] orderBy
ISlice slice
String name
IPredicate<E> head
IPredicate<E>[] tail
null if the body of the rule
 is empty.IQueryOptions queryOptions
IConstraint[] constraints
IRuleTaskFactory taskFactory
IBindingSet constants
Set<E> vars
Set<E> requiredVars
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionprivate void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionActionEnum action
long writeTimestamp
long readTimestamp
Properties properties
int solutionFlags
IElementFilter<E> solutionFilter
IEvaluationPlanFactory evaluationPlanFactory
IRuleTaskFactory defaultRuleTaskFactory
ActionEnum action
IJoinNexusFactory joinNexusFactory
IIndexManager indexManager
IStep step
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionActionEnum action
IStep step
IJoinNexusFactory joinNexusFactory
ProgramTask will be
 submitted (via RMI or not) to a DataService. A new
 IJoinNexus is instantiated in the execution context on the
 DataService from this field.IBlockingBuffer<E> buffer
IBlockingBuffer on which the ISolutions will be
 written.IRuleTaskFactory delegate
Object e
IRule<E> rule
IBindingSet bindingSet
IElementFilter<E> delegate
private void writeObject(ObjectOutputStream out) throws IOException
DataService then that
 would cause the DistributedJoinMasterTask.getSolutionBuffer() to be created on the
 remote service and all query results would be forced through that
 remote JVM before being streamed back to the client.
 
 This is not a problem when the rule is a mutation operation since
 the individual join tasks will each allocate their own buffer that
 writes on the target IMutableRelation.
UnsupportedOperationException - if the operation is a query.IOExceptionIJoinMaster masterProxy
DistributedJoinMasterTask.IBuffer<E> solutionBufferProxy
 Note: The query buffer is always an IBlockingBuffer. The
 client has the IAsynchronousIterator that drains the
 BlockingBuffer. The master is local to the client so that
 data from the distributed join tasks flows directly to the client.
 
 Note: The reason why we do not use a RemoteBuffer for
 mutation is that it would cause all data to flow through the master!
 Instead each JoinTask for the last join dimension uses its
 own buffer to aggregate and write on the target
 IMutableRelation.
long startTime
JoinStats object is created. That corresponds either to the start
 of the distributed JoinMasterTask execution (aggregated level) or
 to the start of some specific JoinTask (detail level).int partitionId
int orderIndex
int fanIn
int fanOut
int partitionCount
long bindingSetChunksIn
JoinTasks.long bindingSetsIn
JoinTasks.long accessPathCount
IAccessPaths read. This will differ from
 #bindingSetIn iff the same IBindingSet is read from
 more than one source and the JoinTask is able to recognize
 the duplication and collapse it by removing the duplicate(s).long accessPathDups
IAccessPaths that were eliminated by a
 JoinTask. Duplicate IAccessPaths arise when the
 source JoinTask(s) generate the bindings on the
 IPredicate for a join dimension. Duplicates are detected by a
 JoinTask when it generates chunk of distinct
 JoinTask.AccessPathTasks from a chunk of IBindingSets read
 from its source(s) JoinTasks.
 
 Note: While the IPredicates for those tasks may have the
 same bindings, the source IBindingSets typically (always?)
 have variety not represented in the bound IPredicate and
 therefore are combined under a single JoinTask.AccessPathTask. This
 reduces redundant reads on an IAccessPath while producing
 exactly the same output IBindingSets that would have been
 produced if we did not identify the duplicate IAccessPaths.
long chunkCount
long elementCount
long bindingSetsOut
IBindingSets written onto the next join dimension
 (aka the #of solutions written iff this is the last join dimension).
 
 Note: An IBindingSet can be written onto more than one index
 partition for the next join dimension, so one generated
 IBindingSet MAY result in N GTE ONE "binding sets out". This
 occurs when the IAccessPath required to read on the next
 IPredicate in the evaluation order spans more than one index
 partition.
long bindingSetChunksOut
IBindingSet chunks written onto the next join
 dimension (aka the #of solutions written iff this is the last join
 dimension in the evaluation order).AtomicLong mutationCount
JoinTask(s)
 for the last join dimension of a mutation operation that were not
 already present in the target relation. This value is always zero
 (0L) for query.
 
 Note: The mutationCount MUST be obtained from IBuffer.flush()
 for the buffer on which the JoinTask(s) for the last join
 dimension write their solutions. For mutation, this buffer is
 obligated to report the #of elements whose state was changed in the
 target relation. Failure to correctly obey this contract can result
 in non-termination of fix point closure operations.
RuleStats.mutationCountString scaleOutIndexName
IRule<E> rule
IJoinNexusFactory joinNexusFactory
int[] order
int orderIndex
int partitionId
UUID masterUUID
IJoinMaster masterProxy
IAsynchronousIterator<E> sourceItrProxy
IKeyOrder<E>[] keyOrders
IVariable<E>[][] requiredVars
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionIndexMetadata sourceIndexMetadata
UUID sourceDataServiceUUID
int targetIndexPartitionId
SegmentMetadata historyIndexSegmentMetadata
SegmentMetadata bufferedWritesIndexSegmentMetadata
InetSocketAddress addr
AtomicLong synchronousOverflowCounter
AtomicLong synchronousOverflowMillis
AtomicLong asynchronousOverflowStartMillis
AtomicLong asynchronousOverflowCounter
AtomicLong asynchronousOverflowMillis
AtomicLong asynchronousOverflowFailedCounter
AsynchronousOverflowTaskAtomicLong asynchronousOverflowTaskFailedCounter
AtomicLong asynchronousOverflowTaskCancelledCounter
AtomicLong indexPartitionBuildCounter
AtomicLong indexPartitionMergeCounter
AtomicLong indexPartitionSplitCounter
AtomicLong indexPartitionTailSplitCounter
AtomicLong indexPartitionJoinCounter
AtomicLong indexPartitionMoveCounter
AtomicLong indexPartitionReceiveCounter
long firstCommitTime
long lastCommitTime
long givenReleaseTime
ITransactionService.long indexRetentionTime
Long.MAX_VALUE if there are NO
 read-historical indices in the cache.long choosenReleaseTime
long commitTimeToPreserve
long resourcesInUseCount
PurgeResult.commitTimeToPreserve until the
 PurgeResult.lastCommitTime.long journalBeforeCount
long journalAfterCount
long segmentBeforeCount
long segmentAfterCount
long bytesBeforeCount
long bytesAfterCount
long elapsedScanCommitIndicesTime
CommitRecordIndex for each historical journal in order to
 identify the set of resources "in use" resources.long elapsedDeleteResourcesTime
long elapsedPurgeResourcesTime
PurgeResult.elapsedScanCommitIndicesTime and the
 PurgeResult.elapsedDeleteResourcesTime.String name
StaleLocatorReason reason
int m_fileSize
int m_nextAllocation
int m_committedNextAllocation
long m_minReleaseAge
long m_lastDeferredReleaseTime
long m_storageStatsAddr
int m_allocsSize
int m_metaBitsAddr
int m_metaBitsSize
Throwable m_cause
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic final void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic final void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionUUID eventUUID
String hostname
Class<T> serviceIface
String serviceName
UUID serviceUUID
UUID for the service which generated that event.EventResource resource
Event.serviceUUID will also be reported.Object majorEventType
Object minorEventType
Map<K,V> details
long startTime
long endTime
boolean complete
true iff the event event has been generated.public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionString indexName
String partitionId
String file
long ts
String namespace
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionString query
String params
String endpoint
Integer searchTimeout
String searchField
String scoreField
String snippetField
IBindingSet incomingBindings
FTS.SearchResultType searchResultType
GeoSpatialDatatypeFieldConfiguration.ValueType valueType
Long minValue
long multiplier
GeoSpatialDatatypeFieldConfiguration.ServiceMapping serviceMapping
String customServiceMapping
byte[] searchMinZOrder
byte[] searchMaxZOrder
int zOrderComponentPos
GeoSpatialLiteralExtension<V extends BigdataValue> litExt
ZOrderRangeScanUtil rangeScanUtil
GeoSpatialCounters geoSpatialCounters
RemoteAsynchronousIterator<E> remoteIterator
 Note: This is a Remote interface. All methods on this interface
 are RMI calls and both declare and can throw IOException.
int capacity
ClientAsynchronousIterator.localBuffer.RemoteBuffer<E> buffer
RemoteFuture<T> proxy
RemoteRunnableBuffer<E,V> buffer
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionObject outcome
boolean cancelled
ExecutionException cause
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionSchema schema
long fromTime
long toTime
INameFilter nameFilter
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionString name
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
AbstractKeyArrayIndexProcedure.IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionObject state
IKeyOrder<E> keyOrder
null. When
 null the filtered iterator is assumed to be
 unordered. This assumption is made since chunk-at-a-time
 transforms can change the natural order of the chunk in many, many
 different ways, e.g., by changing the type of the elements in the chunk.int chunkSize
Object state
String name
long timestamp
int hashCode
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
Values but not
 BigdataValues since the AbstractTripleStore reference is
 not available and we can not obtain the appropriate
 BigdataValueFactory instance without it. This should not matter
 since the only access to the Values is via BaseVocabulary.get(Value)
 and BaseVocabulary.getConstant(Value).IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionObject m_state
Object m_exclude
Iterator<E> m_xtra
Comparator<T> m_comparator
BitVector bitVector
int width
long fullMask
AbstractBitVector.LongBigListView.width bits set to one.BitVector bitVector
long from
long to
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionprivate void writeObject(ObjectOutputStream s) throws IOException
IOExceptionlong length
LongArrayBitVector bitVector
BitVector[] codeWord
it.unimi.dsi.fastutil.chars.Char2IntOpenHashMap char2symbol
boolean prefixFree
long[] lastCodeWordPlusOne
int[] lengthIncrement
CanonicalFast64CodeWordDecoder.lastCodeWordPlusOne specifying the increment in length between codeword lengths 
 (without repetitions). In particular, the first entry
 is the length of the first block of same-length codewords, the second entry is the difference in length
 between the second and the first block of same-length codewords, and so on.int[] howManyUpToBlock
CanonicalFast64CodeWordDecoder.lastCodeWordPlusOne specifying how many codewords we have up to a certain block (included).int[] symbol
BitVector[] codeWord
long[] longCodeWord
CodeWordCoder.codeWord containing the codewords as longs (right aligned).int[] length
Fast64CodeWordCoder.longCodeWord, of codewords length.int size
BitVector[] codeWord
Fast64CodeWordCoder coder
CanonicalFast64CodeWordDecoder decoder
int size
TreeDecoder.Node root
CodeWordCoder coder
TreeDecoder decoder
TreeDecoder.Node root
int n
TreeDecoder.Node left
TreeDecoder.Node right
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionint n
int ratio
CustomByteArrayFrontCodedList.BackingBuffer bb
boolean hasDups
trueiff duplicate keys are allowed.private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionint bufferSize
buffer.length).it.unimi.dsi.fastutil.chars.CharSet wordConstituents
Character.isLetterOrDigit(int).FastBufferedReader fastBufferedReader
private Object readResolve()
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
Mutable strings produced by this method are always compact; this seems reasonable, as stored strings are unlikely going to be changed.
Because of limitations of ObjectInputStream, this method must
 read one character at a time, and does not try to do any read-ahead (in
 particular, it does not create any object). On non-buffered data inputs
 it might be very slow.
IOExceptionClassNotFoundExceptionprivate void writeObject(ObjectOutputStream s) throws IOException
The serialised version of a mutable string is made of its length followed by its characters (in UTF-16 format). Note that the compactness state is forgotten.
Because of limitations of ObjectOutputStream, this method must
 write one character at a time, and does not try to do any caching (in
 particular, it does not create any object). On non-buffered data outputs
 it might be very slow.
IOExceptionLongBigList l
long from
long to
int size
long m
int d
long[] bits
int[][] weight
int[] init
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
IOExceptionit.unimi.dsi.fastutil.bytes.ByteArrayFrontCodedList byteFrontCodedList
ByteArrayFrontCodedList, or null.it.unimi.dsi.fastutil.chars.CharArrayFrontCodedList charFrontCodedList
CharArrayFrontCodedList, or null.boolean utf8
ImmutableBinaryTrie.Node root
int size
TransformationStrategy<T> transformationStrategy
ImmutableBinaryTrie.Node left
ImmutableBinaryTrie.Node right
long[] path
null if there is no compaction at this node).int pathLength
int word
word-th word.private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionprivate void writeObject(ObjectOutputStream s) throws IOException
IOExceptionImmutableBinaryTrie<T> intervalApproximator
long blockSize
Decoder decoder
char[] symbol2char
it.unimi.dsi.fastutil.chars.Char2IntOpenHashMap char2symbol
int size
int[] blockStart
ImmutableExternalPrefixMap.size.int[] blockOffset
ImmutableExternalPrefixMap.blockStart giving the offset in blocks in the dump file
 of the corresponding word in ImmutableExternalPrefixMap.blockStart. If there are no overflows, this will just
 be an initial segment of the natural numbers, but overflows cause jumps.boolean selfContained
long dumpStreamLength
long m
int d
LongArrayBitVector bits
int[] a
int[] b
int lastDocument
int lastPosition
it.unimi.dsi.fastutil.io.FastByteArrayOutputStream fbaos
OutputBitStream obs
it.unimi.dsi.fastutil.objects.Object2LongFunction<K> function
it.unimi.dsi.fastutil.objects.ObjectList<K> list
int size
LiterallySignedStringMap.list.FrontCodedStringList frontCodedStringList
int[] permutation
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionprivate void writeObject(ObjectOutputStream s) throws IOException
IOExceptionit.unimi.dsi.fastutil.objects.Object2LongFunction<K> function
LongBigList signatures
int width
int shift
ShiftAddXorSignedStringMap.width nonzero bits.long mask
ShiftAddXorSignedStringMap.width nonzero bits.PrefixMap<S extends CharSequence> map
it.unimi.dsi.fastutil.objects.Object2ObjectFunction<K,V> prefixMap
it.unimi.dsi.fastutil.objects.Object2ObjectFunction<K,V> rangeMap
StringMap<S extends CharSequence> stringMap
it.unimi.dsi.fastutil.objects.ObjectList<K> list
it.unimi.dsi.util.TernaryIntervalSearchTree.Node root
int size
boolean modified
TernaryIntervalSearchTree.add(CharSequence) modified the tree.String m_source
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
IOExceptionClassNotFoundExceptionprivate void writeObject(ObjectOutputStream s) throws IOException
IOExceptionint segmentMask
int segmentShift
org.infinispan.util.concurrent.BufferedConcurrentHashMap.Segment<K,V>[] segments
Copyright © 2006–2019 SYSTAP, LLC DBA Blazegraph. All rights reserved.