_SearchDisp (omero-blitz 5.5.12 API)

java.lang.Object
- Ice.ObjectImpl
- - omero.api._SearchDisp

All Implemented Interfaces:

Ice.Object, java.io.Serializable, java.lang.Cloneable, _SearchOperations, _SearchOperationsNC, _ServiceInterfaceOperations, _ServiceInterfaceOperationsNC, _StatefulServiceInterfaceOperations, _StatefulServiceInterfaceOperationsNC, Search, ServiceInterface, StatefulServiceInterface

Direct Known Subclasses:

_SearchTie
```
public abstract class _SearchDisp
extends Ice.ObjectImpl
implements Search
```
Central search interface, allowing Web2.0 style queries. Each Search instance keeps up with several queries and lazily-loads the results as hasNext, next and results are called. These queries are created by the by* methods. Each instance also has a number of settings which can all be changed from their defaults via accessors, e.g. setBatchSize or setCaseSensitive. The only methods which are required for the proper functioning of a Search instance are:
- onlyType, onlyTypes OR allTypes
- Any by* method to create a query
Use of the allTypes method is discouraged, since it is possibly very resource intensive, which is why any attempt to receive results without specifically setting types or allowing all is prohibited.
See Also:

IQuery, Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

static java.lang.String[] __ids

static long serialVersionUID
- Fields inherited from interface omero.api.Search
  ice_staticId

Fields
Modifier and Type	Field and Description
`static java.lang.String[]`	`__ids`
`static long`	`serialVersionUID`

Constructor Summary

Constructors
Constructor and Description

_SearchDisp()

Constructors
Constructor and Description
`_SearchDisp()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static Ice.DispatchStatus`	`___activeQueries(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___addOrderByAsc(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___addOrderByDesc(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___allTypes(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___and(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___byAnnotatedWith(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___byFullText(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___byGroupForTags(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___byHqlQuery(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___byLuceneQueryBuilder(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___bySimilarTerms(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___bySomeMustNone(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___byTagForGroups(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___clearQueries(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___currentMetadata(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___currentMetadataList(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___fetchAlso(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___fetchAnnotations(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___getBatchSize(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___hasNext(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___isAllowLeadingWildcard(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___isCaseSensitive(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___isMergedBatches(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___isReturnUnloaded(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___isUseProjections(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___next(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___not(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___notAnnotatedBy(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___notOwnedBy(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___onlyAnnotatedBetween(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___onlyAnnotatedBy(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___onlyAnnotatedWith(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___onlyCreatedBetween(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___onlyIds(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___onlyModifiedBetween(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___onlyOwnedBy(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___onlyType(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___onlyTypes(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___or(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___remove(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___resetDefaults(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___results(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___setAllowLeadingWildcard(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___setBatchSize(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___setCaseSensitive(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___setCaseSentivice(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___setMergedBatches(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___setReturnUnloaded(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___setUseProjections(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`static Ice.DispatchStatus`	`___unordered(Search __obj, IceInternal.Incoming __inS, Ice.Current __current)`
`Ice.DispatchStatus`	`__dispatch(IceInternal.Incoming in, Ice.Current __current)`
`protected void`	`__readImpl(IceInternal.BasicStream __is)`
`protected void`	`__writeImpl(IceInternal.BasicStream __os)`
`void`	`activate_async(AMD_StatefulServiceInterface_activate __cb)` Load a service implementation from disk if it was previously passivated.
`void`	`activeQueries_async(AMD_Search_activeQueries __cb)` Returns the number of active queries.
`void`	`addOrderByAsc_async(AMD_Search_addOrderByAsc __cb, java.lang.String path)` A path from the target entity which will be added to the current stack of order statements applied to the query.
`void`	`addOrderByDesc_async(AMD_Search_addOrderByDesc __cb, java.lang.String path)` A path from the target entity which will be added to the current stack of order statements applied to the query.
`void`	`allTypes_async(AMD_Search_allTypes __cb)` Permits all types to be returned.
`void`	`and_async(AMD_Search_and __cb)` Applies the next by* method to the previous by* method, so that a call `hasNext`, `next`, or `results` sees only the intersection of the two calls.
`void`	`byAnnotatedWith_async(AMD_Search_byAnnotatedWith __cb, java.util.List<Annotation> examples)` Finds entities annotated with an `Annotation` similar to the example.
`void`	`byFullText_async(AMD_Search_byFullText __cb, java.lang.String query)` Passes the query as is to the Lucene backend.
`void`	`byGroupForTags_async(AMD_Search_byGroupForTags __cb, java.lang.String group)` Returns transient (without ID) `TagAnnotation` instances which represent all the `TagAnnotation` tags in the given group.
`void`	`byHqlQuery_async(AMD_Search_byHqlQuery __cb, java.lang.String query, Parameters params)` Delegates to `omero.api.IQuery.findAllByQuery` method to take advantage of the `and`, `or`, and `not` methods, or queue-semantics.
`void`	`byLuceneQueryBuilder_async(AMD_Search_byLuceneQueryBuilder __cb, java.lang.String fields, java.lang.String from, java.lang.String to, java.lang.String dateType, java.lang.String query)` Builds a Lucene query and passes it to the Lucene backend.
`void`	`bySimilarTerms_async(AMD_Search_bySimilarTerms __cb, java.util.List<java.lang.String> terms)` Returns transient (without ID) `TextAnnotation` instances which represent terms which are similar to the given terms.
`void`	`bySomeMustNone_async(AMD_Search_bySomeMustNone __cb, java.util.List<java.lang.String> some, java.util.List<java.lang.String> must, java.util.List<java.lang.String> none)` Builds a Lucene query and passes it to `byFullText`.
`void`	`byTagForGroups_async(AMD_Search_byTagForGroups __cb, java.lang.String tag)` Creates a query which will return transient (without ID) `TagAnnotation` instances which represent all the `TagAnnotation` tag groups which the given tag belongs to.
`void`	`clearQueries_async(AMD_Search_clearQueries __cb)` Removes all active queries (leaving `resetDefaults` settings alone), such that `activeQueries` will return 0.
`void`	`close_async(AMD_StatefulServiceInterface_close __cb)` Frees all resources -- passivated or active -- for the given stateful service and removes its name from the object adapter.
`void`	`currentMetadata_async(AMD_Search_currentMetadata __cb)` Provides access to the extra query information (for example Lucene score and boost values) for a single call to `next`.
`void`	`currentMetadataList_async(AMD_Search_currentMetadataList __cb)` Provides access to the extra query information (for example Lucene score and boost values) for a single call to `results`.
`void`	`fetchAlso_async(AMD_Search_fetchAlso __cb, java.util.List<java.lang.String> fetches)` Adds a fetch clause for loading non-annotation fields of returned entities.
`void`	`fetchAnnotations_async(AMD_Search_fetchAnnotations __cb, java.util.List<java.lang.String> classes)` Queries the database for all `Annotation` annotations of the given types for all returned instances.
`void`	`getBatchSize_async(AMD_Search_getBatchSize __cb)` Returns the current batch size.
`void`	`getCurrentEventContext_async(AMD_StatefulServiceInterface_getCurrentEventContext __cb)` To free clients from tracking the mapping from session to stateful service, each stateful service can returns its own context information.
`void`	`hasNext_async(AMD_Search_hasNext __cb)` Returns `true` if another call to `next` is valid.
`protected void`	`ice_copyStateFrom(Ice.Object __obj)`
`java.lang.String`	`ice_id()`
`java.lang.String`	`ice_id(Ice.Current __current)`
`java.lang.String[]`	`ice_ids()`
`java.lang.String[]`	`ice_ids(Ice.Current __current)`
`boolean`	`ice_isA(java.lang.String s)`
`boolean`	`ice_isA(java.lang.String s, Ice.Current __current)`
`static java.lang.String`	`ice_staticId()`
`void`	`isAllowLeadingWildcard_async(AMD_Search_isAllowLeadingWildcard __cb)` Returns the current leading-wildcard setting.
`void`	`isCaseSensitive_async(AMD_Search_isCaseSensitive __cb)` Returns the current case sensitivity setting.
`void`	`isMergedBatches_async(AMD_Search_isMergedBatches __cb)` Returns the current merged-batches setting.
`void`	`isReturnUnloaded_async(AMD_Search_isReturnUnloaded __cb)` Returns the current return-unloaded setting.
`void`	`isUseProjections_async(AMD_Search_isUseProjections __cb)` Returns the current use-projection setting.
`void`	`next_async(AMD_Search_next __cb)` Returns the next entity from the current query.
`void`	`not_async(AMD_Search_not __cb)` Applies the next by* method to the previous by* method, so that a call `hasNext`, `next`, or `results` sees only the intersection of the two calls.
`void`	`notAnnotatedBy_async(AMD_Search_notAnnotatedBy __cb, Details d)` Restricts entities by who has not annotated them with an `Annotation` matching the other filters.
`void`	`notOwnedBy_async(AMD_Search_notOwnedBy __cb, Details d)` Uses the `Details.getOwner()` and `Details.getGroup()` information to restrict the entities which will be returned.
`void`	`onlyAnnotatedBetween_async(AMD_Search_onlyAnnotatedBetween __cb, RTime start, RTime stop)` Restricts entities by the time in which any annotation (which matches the other filters) was added them.
`void`	`onlyAnnotatedBy_async(AMD_Search_onlyAnnotatedBy __cb, Details d)` Restricts entities by who has annotated them with an `Annotation` matching the other filters.
`void`	`onlyAnnotatedWith_async(AMD_Search_onlyAnnotatedWith __cb, java.util.List<java.lang.String> classes)` Restricts entities to having an `Annotation` of all the given types.
`void`	`onlyCreatedBetween_async(AMD_Search_onlyCreatedBetween __cb, RTime start, RTime stop)` Restricts the time between which an entity may have been created.
`void`	`onlyIds_async(AMD_Search_onlyIds __cb, java.util.List<java.lang.Long> ids)` Restricts the set of ids which will be checked.
`void`	`onlyModifiedBetween_async(AMD_Search_onlyModifiedBetween __cb, RTime start, RTime stop)` Restricts the time between which an entity may have last been modified.
`void`	`onlyOwnedBy_async(AMD_Search_onlyOwnedBy __cb, Details d)` Uses the `Details.getOwner()` and `Details.getGroup()` information to restrict the entities which will be returned.
`void`	`onlyType_async(AMD_Search_onlyType __cb, java.lang.String klass)` Restricts the search to a single type.
`void`	`onlyTypes_async(AMD_Search_onlyTypes __cb, java.util.List<java.lang.String> classes)` Restricts searches to a set of types.
`void`	`or_async(AMD_Search_or __cb)` Applies the next by* method to the previous by* method, so that a call `hasNext`, `next` or `results` sees only the union of the two calls.
`void`	`passivate_async(AMD_StatefulServiceInterface_passivate __cb)` Causes the blitz server to store the service implementation to disk to free memory.
`void`	`remove_async(AMD_Search_remove __cb)` Unsupported operation.
`void`	`resetDefaults_async(AMD_Search_resetDefaults __cb)` Resets all settings (non-query state) to the original default values, as if the instance had just be created.
`void`	`results_async(AMD_Search_results __cb)` Returns up to `getBatchSize` batch size number of results along with the related query metadata.
`void`	`setAllowLeadingWildcard_async(AMD_Search_setAllowLeadingWildcard __cb, boolean allowLeadingWildcard)` Permits full-text queries with a leading query if true.
`void`	`setBatchSize_async(AMD_Search_setBatchSize __cb, int size)` Sets the maximum number of results that will be returned by one call to `results`.
`void`	`setCaseSensitive_async(AMD_Search_setCaseSensitive __cb, boolean caseSensitive)` Sets the case sensitivity on all queries where case-sensitivity is supported.
`void`	`setCaseSentivice_async(AMD_Search_setCaseSentivice __cb, boolean caseSensitive)` Deprecated. use setCaseSensitive instead
`void`	`setMergedBatches_async(AMD_Search_setMergedBatches __cb, boolean merge)` Set whether or not results from two separate queries can be returned in the same call to `results`.
`void`	`setReturnUnloaded_async(AMD_Search_setReturnUnloaded __cb, boolean returnUnloaded)` Determines if all results should be returned as unloaded objects.
`void`	`setUseProjections_async(AMD_Search_setUseProjections __cb, boolean useProjections)` Determines if Lucene queries should not hit the database.
`void`	`unordered_async(AMD_Search_unordered __cb)` Removes the current stack of order statements.

Methods inherited from class Ice.ObjectImpl
___ice_id, ___ice_ids, ___ice_isA, ___ice_ping, __checkMode, __read, __read, __readImpl, __write, __write, __writeImpl, clone, ice_dispatch, ice_dispatch, ice_operationAttributes, ice_ping, ice_ping, ice_postUnmarshal, ice_preMarshal

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface omero.api._SearchOperations
activeQueries_async, addOrderByAsc_async, addOrderByDesc_async, allTypes_async, and_async, byAnnotatedWith_async, byFullText_async, byGroupForTags_async, byHqlQuery_async, byLuceneQueryBuilder_async, bySimilarTerms_async, bySomeMustNone_async, byTagForGroups_async, clearQueries_async, currentMetadata_async, currentMetadataList_async, fetchAlso_async, fetchAnnotations_async, getBatchSize_async, hasNext_async, isAllowLeadingWildcard_async, isCaseSensitive_async, isMergedBatches_async, isReturnUnloaded_async, isUseProjections_async, next_async, not_async, notAnnotatedBy_async, notOwnedBy_async, onlyAnnotatedBetween_async, onlyAnnotatedBy_async, onlyAnnotatedWith_async, onlyCreatedBetween_async, onlyIds_async, onlyModifiedBetween_async, onlyOwnedBy_async, onlyType_async, onlyTypes_async, or_async, remove_async, resetDefaults_async, results_async, setAllowLeadingWildcard_async, setBatchSize_async, setCaseSensitive_async, setCaseSentivice_async, setMergedBatches_async, setReturnUnloaded_async, setUseProjections_async, unordered_async

Methods inherited from interface omero.api._StatefulServiceInterfaceOperations
activate_async, close_async, getCurrentEventContext_async, passivate_async

Methods inherited from interface Ice.Object
__read, __read, __write, __write, clone, ice_dispatch, ice_dispatch, ice_operationAttributes, ice_ping, ice_ping, ice_postUnmarshal, ice_preMarshal

Field Detail

__ids

public static final java.lang.String[] __ids

serialVersionUID
```
public static final long serialVersionUID
```
See Also:

Constant Field Values

Constructor Detail
- _SearchDisp
```
public _SearchDisp()
```

Method Detail

ice_copyStateFrom

protected void ice_copyStateFrom(Ice.Object __obj)
                          throws java.lang.CloneNotSupportedException

Throws:: java.lang.CloneNotSupportedException

ice_isA
```
public boolean ice_isA(java.lang.String s)
```
Specified by:

ice_isA in interface Ice.Object

Overrides:

ice_isA in class Ice.ObjectImpl

ice_isA

public boolean ice_isA(java.lang.String s,
                       Ice.Current __current)

Specified by:: ice_isA in interface Ice.Object
Overrides:: ice_isA in class Ice.ObjectImpl

ice_ids
```
public java.lang.String[] ice_ids()
```
Specified by:

ice_ids in interface Ice.Object

Overrides:

ice_ids in class Ice.ObjectImpl

ice_ids
```
public java.lang.String[] ice_ids(Ice.Current __current)
```
Specified by:

ice_ids in interface Ice.Object

Overrides:

ice_ids in class Ice.ObjectImpl

ice_id
```
public java.lang.String ice_id()
```
Specified by:

ice_id in interface Ice.Object

Overrides:

ice_id in class Ice.ObjectImpl

ice_id
```
public java.lang.String ice_id(Ice.Current __current)
```
Specified by:

ice_id in interface Ice.Object

Overrides:

ice_id in class Ice.ObjectImpl

ice_staticId

public static java.lang.String ice_staticId()

activeQueries_async
```
public final void activeQueries_async(AMD_Search_activeQueries __cb)
                               throws ServerError
```
Returns the number of active queries. This means that activeQueries gives the minimum number of remaining calls to results when batches are not merged.

Specified by:

activeQueries_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

addOrderByAsc_async
```
public final void addOrderByAsc_async(AMD_Search_addOrderByAsc __cb,
                                      java.lang.String path)
                               throws ServerError
```
A path from the target entity which will be added to the current stack of order statements applied to the query.

Specified by:

addOrderByAsc_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

path - Non-null.

Throws:

ServerError

addOrderByDesc_async
```
public final void addOrderByDesc_async(AMD_Search_addOrderByDesc __cb,
                                       java.lang.String path)
                                throws ServerError
```
A path from the target entity which will be added to the current stack of order statements applied to the query.

Specified by:

addOrderByDesc_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

path - Non-null.

Throws:

ServerError

allTypes_async
```
public final void allTypes_async(AMD_Search_allTypes __cb)
                          throws ServerError
```
Permits all types to be returned. For some types of queries, this carries a performance penalty as every database table must be hit.

Specified by:

allTypes_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

and_async
```
public final void and_async(AMD_Search_and __cb)
                     throws ServerError
```
Applies the next by* method to the previous by* method, so that a call hasNext, next, or results sees only the intersection of the two calls. For example,
```
 
 service.onlyType(Image.class);
 service.byFullText(&quot;foo&quot;);
 service.intersection();
 service.byAnnotatedWith(TagAnnotation.class);
 
 
```
will return only the Images with TagAnnotations.
Calling this method overrides a previous setting of or or not. If there is no active queries (i.e. activeQueries > 0), then an ApiUsageException will be thrown.
Specified by:

and_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

byAnnotatedWith_async
```
public final void byAnnotatedWith_async(AMD_Search_byAnnotatedWith __cb,
                                        java.util.List<Annotation> examples)
                                 throws ServerError
```
Finds entities annotated with an Annotation similar to the example. This does not use Hibernate's omero.api.IQuery.findByExample Query-By-Example} mechanism, since that cannot handle joins. The fields which are used are:
- the main content of the annotation : String, IObject.getId(), etc.
If the main content is null it is assumed to be a wildcard searched, and only the type of the annotation is searched. Currently, ListAnnotations are not supported.
Specified by:

byAnnotatedWith_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

examples - Not empty.

Throws:

ServerError

byFullText_async
```
public final void byFullText_async(AMD_Search_byFullText __cb,
                                   java.lang.String query)
                            throws ServerError
```
Passes the query as is to the Lucene backend.

Specified by:

byFullText_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

query - May not be null or of zero length.

Throws:

ServerError

byGroupForTags_async
```
public final void byGroupForTags_async(AMD_Search_byGroupForTags __cb,
                                       java.lang.String group)
                                throws ServerError
```
Returns transient (without ID) TagAnnotation instances which represent all the TagAnnotation tags in the given group. The entities are transient and without ownership since multiple users can own the same tag. This method will override settings for types.

Specified by:

byGroupForTags_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

group - Can be null or empty to return all tags.

Throws:

ServerError

byHqlQuery_async
```
public final void byHqlQuery_async(AMD_Search_byHqlQuery __cb,
                                   java.lang.String query,
                                   Parameters params)
                            throws ServerError
```
Delegates to omero.api.IQuery.findAllByQuery method to take advantage of the and, or, and not methods, or queue-semantics.

Specified by:

byHqlQuery_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

query - Not null.

Throws:

ServerError

byLuceneQueryBuilder_async
```
public final void byLuceneQueryBuilder_async(AMD_Search_byLuceneQueryBuilder __cb,
                                             java.lang.String fields,
                                             java.lang.String from,
                                             java.lang.String to,
                                             java.lang.String dateType,
                                             java.lang.String query)
                                      throws ServerError
```
Builds a Lucene query and passes it to the Lucene backend.

Specified by:

byLuceneQueryBuilder_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

fields - The fields (comma separated) to search in (name, description, ...)

from - The date range from, in the form YYYYMMDD (may be null)

to - The date range to (inclusive), in the form YYYYMMDD (may be null)

dateType - DATE_TYPE_ACQUISITION or DATE_TYPE_IMPORT

query - May not be null or of zero length.

Throws:

ServerError

bySimilarTerms_async
```
public final void bySimilarTerms_async(AMD_Search_bySimilarTerms __cb,
                                       java.util.List<java.lang.String> terms)
                                throws ServerError
```
Returns transient (without ID) TextAnnotation instances which represent terms which are similar to the given terms. For example, if the argument is cell, one return value might have as its textValue: cellular while another has cellularize. No filtering or fetching is performed.

Specified by:

bySimilarTerms_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

terms - Cannot be empty.

Throws:

ServerError

bySomeMustNone_async
```
public final void bySomeMustNone_async(AMD_Search_bySomeMustNone __cb,
                                       java.util.List<java.lang.String> some,
                                       java.util.List<java.lang.String> must,
                                       java.util.List<java.lang.String> none)
                                throws ServerError
```
Builds a Lucene query and passes it to byFullText.

Specified by:

bySomeMustNone_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

some - Some (at least one) of these terms must be present in the document. May be null.

must - All of these terms must be present in the document. May be null.

none - None of these terms may be present in the document. May be null.

Throws:

ServerError

byTagForGroups_async
```
public final void byTagForGroups_async(AMD_Search_byTagForGroups __cb,
                                       java.lang.String tag)
                                throws ServerError
```
Creates a query which will return transient (without ID) TagAnnotation instances which represent all the TagAnnotation tag groups which the given tag belongs to. The entities are transient and without ownership since multiple users can own the same tag group. This method will override settings for types.

Specified by:

byTagForGroups_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

tag - Can be null or empty to return all groups.

Throws:

ServerError

clearQueries_async
```
public final void clearQueries_async(AMD_Search_clearQueries __cb)
                              throws ServerError
```
Removes all active queries (leaving resetDefaults settings alone), such that activeQueries will return 0.

Specified by:

clearQueries_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

currentMetadata_async
```
public final void currentMetadata_async(AMD_Search_currentMetadata __cb)
                                 throws ServerError
```
Provides access to the extra query information (for example Lucene score and boost values) for a single call to next. This method may only be called once for any given call to next.

Specified by:

currentMetadata_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

currentMetadataList_async
```
public final void currentMetadataList_async(AMD_Search_currentMetadataList __cb)
                                     throws ServerError
```
Provides access to the extra query information (for example Lucene score and boost values) for a single call to results. This method may only be called once for any given call to results.

Specified by:

currentMetadataList_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

fetchAlso_async
```
public final void fetchAlso_async(AMD_Search_fetchAlso __cb,
                                  java.util.List<java.lang.String> fetches)
                           throws ServerError
```
Adds a fetch clause for loading non-annotation fields of returned entities. Each fetch is a hibernate clause in dot notation.

Specified by:

fetchAlso_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

fetches - Can be empty, which removes previous fetch setting.

Throws:

ServerError

fetchAnnotations_async
```
public final void fetchAnnotations_async(AMD_Search_fetchAnnotations __cb,
                                         java.util.List<java.lang.String> classes)
                                  throws ServerError
```
Queries the database for all Annotation annotations of the given types for all returned instances.

Specified by:

fetchAnnotations_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

classes - Can be empty, which removes previous fetch setting.

Throws:

ServerError

getBatchSize_async
```
public final void getBatchSize_async(AMD_Search_getBatchSize __cb)
                              throws ServerError
```
Returns the current batch size. If setBatchSize has not been called, the default value will be in effect.

Specified by:

getBatchSize_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

hasNext_async
```
public final void hasNext_async(AMD_Search_hasNext __cb)
                         throws ServerError
```
Returns true if another call to next is valid. A call to next may throw an exception for another reason, however.

Specified by:

hasNext_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

isAllowLeadingWildcard_async
```
public final void isAllowLeadingWildcard_async(AMD_Search_isAllowLeadingWildcard __cb)
                                        throws ServerError
```
Returns the current leading-wildcard setting. If false, byFullText and bySomeMustNone will throw an ApiUsageException, since leading-wildcard searches are quite slow. Use setAllowLeadingWildcard in order to permit this usage.

Specified by:

isAllowLeadingWildcard_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

isCaseSensitive_async
```
public final void isCaseSensitive_async(AMD_Search_isCaseSensitive __cb)
                                 throws ServerError
```
Returns the current case sensitivity setting. If setCaseSensitive has not been called, the default value will be in effect.

Specified by:

isCaseSensitive_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

isMergedBatches_async
```
public final void isMergedBatches_async(AMD_Search_isMergedBatches __cb)
                                 throws ServerError
```
Returns the current merged-batches setting. If setMergedBatches has not been called, the default value will be in effect.

Specified by:

isMergedBatches_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

isReturnUnloaded_async
```
public final void isReturnUnloaded_async(AMD_Search_isReturnUnloaded __cb)
                                  throws ServerError
```
Returns the current return-unloaded setting. If true, all returned entities will be unloaded. If setReturnUnloaded has not been called, the default value will be in effect.

Specified by:

isReturnUnloaded_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

isUseProjections_async
```
public final void isUseProjections_async(AMD_Search_isUseProjections __cb)
                                  throws ServerError
```
Returns the current use-projection setting. If true, the client must be careful with all results that are returned. See setUseProjections for more. If setUseProjections has not been called, the default value will be in effect.

Specified by:

isUseProjections_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

next_async
```
public final void next_async(AMD_Search_next __cb)
                      throws ServerError
```
Returns the next entity from the current query. If the previous call returned the last entity from a given query, the first entity from the next query will be returned and activeQueries decremented. Since this method only returns the entity itself, a single call to currentMetadata may follow this call to gather the extra metadata which is returned in the map via results.

Specified by:

next_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ApiUsageException - if {code hasNext} returns false.

ServerError

not_async
```
public final void not_async(AMD_Search_not __cb)
                     throws ServerError
```
Applies the next by* method to the previous by* method, so that a call hasNext, next, or results sees only the intersection of the two calls. For example,
```
 
 service.onlyType(Image.class);
 service.byFullText(&quot;foo&quot;);
 service.complement();
 service.byAnnotatedWith(TagAnnotation.class);
 
 
```
will return all the Images not annotated with TagAnnotation.
Calling this method overrides a previous setting of or or and. If there is no active queries (i.e. activeQueries > 0), then an ApiUsageException will be thrown.
Specified by:

not_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

notAnnotatedBy_async
```
public final void notAnnotatedBy_async(AMD_Search_notAnnotatedBy __cb,
                                       Details d)
                                throws ServerError
```
Restricts entities by who has not annotated them with an Annotation matching the other filters. As notOwnedBy, the Details.getOwner() and Details.getGroup() information is combined with an AND condition.

Specified by:

notAnnotatedBy_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

d - Can be null, in which case any previous restriction is removed.

Throws:

ServerError

notOwnedBy_async
```
public final void notOwnedBy_async(AMD_Search_notOwnedBy __cb,
                                   Details d)
                            throws ServerError
```
Uses the Details.getOwner() and Details.getGroup() information to restrict the entities which will be returned. If both are non-null, the two restrictions are joined by an AND.

Specified by:

notOwnedBy_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

d - Can be null, in which case the previous restriction is removed.

Throws:

ServerError

onlyAnnotatedBetween_async
```
public final void onlyAnnotatedBetween_async(AMD_Search_onlyAnnotatedBetween __cb,
                                             RTime start,
                                             RTime stop)
                                      throws ServerError
```
Restricts entities by the time in which any annotation (which matches the other filters) was added them. This matches the Details.getCreationEvent() creation event of the Annotation.

Specified by:

onlyAnnotatedBetween_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

start - Can be null, i.e. interval open to negative infinity.

stop - Can be null, i.e. interval open to positive infinity.

Throws:

ServerError

onlyAnnotatedBy_async
```
public final void onlyAnnotatedBy_async(AMD_Search_onlyAnnotatedBy __cb,
                                        Details d)
                                 throws ServerError
```
Restricts entities by who has annotated them with an Annotation matching the other filters. As onlyOwnedBy, the Details.getOwner() and Details.getGroup() information is combined with an AND condition.

Specified by:

onlyAnnotatedBy_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

d - Can be null, in which case any previous restriction is removed.

Throws:

ServerError

onlyAnnotatedWith_async
```
public final void onlyAnnotatedWith_async(AMD_Search_onlyAnnotatedWith __cb,
                                          java.util.List<java.lang.String> classes)
                                   throws ServerError
```
Restricts entities to having an Annotation of all the given types. This is useful in combination with the other onlyAnnotated* methods to say, e.g., only annotated with a file by user X. By default, this value is null and imposes no restriction. Passing an empty array implies an object that is not annotated at all. Note: If the semantics were OR, then a client would have to query each class individually, and compare all the various values, checking which ids are where. However, since this method defaults to AND, multiple calls (optionally with isMergedBatches and isReturnUnloaded) and combine the results. Duplicate ids are still possible so a set of some form should be used to collect the results.

Specified by:

onlyAnnotatedWith_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

classes - Can be empty, in which case restriction is removed.

Throws:

ServerError

onlyCreatedBetween_async
```
public final void onlyCreatedBetween_async(AMD_Search_onlyCreatedBetween __cb,
                                           RTime start,
                                           RTime stop)
                                    throws ServerError
```
Restricts the time between which an entity may have been created.

Specified by:

onlyCreatedBetween_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

start - Can be null, i.e. interval open to negative infinity.

stop - Can be null, i.e. interval opens to positive infinity.

Throws:

ServerError

onlyIds_async
```
public final void onlyIds_async(AMD_Search_onlyIds __cb,
                                java.util.List<java.lang.Long> ids)
                         throws ServerError
```
Restricts the set of ids which will be checked. This is useful for testing one of the given restrictions on a reduced set of objects.

Specified by:

onlyIds_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

ids - Can be null, in which case the previous restriction is removed.

Throws:

ServerError

onlyModifiedBetween_async
```
public final void onlyModifiedBetween_async(AMD_Search_onlyModifiedBetween __cb,
                                            RTime start,
                                            RTime stop)
                                     throws ServerError
```
Restricts the time between which an entity may have last been modified.

Specified by:

onlyModifiedBetween_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

start - Can be null, i.e. interval open to negative infinity.

stop - Can be null, i.e. interval open to positive infinity.

Throws:

ServerError

onlyOwnedBy_async
```
public final void onlyOwnedBy_async(AMD_Search_onlyOwnedBy __cb,
                                    Details d)
                             throws ServerError
```
Uses the Details.getOwner() and Details.getGroup() information to restrict the entities which will be returned. If both are non-null, the two restrictions are joined by an AND.

Specified by:

onlyOwnedBy_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

d - Can be null, in which case the previous restriction is removed.

Throws:

ServerError

onlyType_async
```
public final void onlyType_async(AMD_Search_onlyType __cb,
                                 java.lang.String klass)
                          throws ServerError
```
Restricts the search to a single type. All return values will match this type.

Specified by:

onlyType_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

onlyTypes_async
```
public final void onlyTypes_async(AMD_Search_onlyTypes __cb,
                                  java.util.List<java.lang.String> classes)
                           throws ServerError
```
Restricts searches to a set of types. The entities returned are guaranteed to be one of these types.

Specified by:

onlyTypes_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

or_async
```
public final void or_async(AMD_Search_or __cb)
                    throws ServerError
```
Applies the next by* method to the previous by* method, so that a call hasNext, next or results sees only the union of the two calls. For example,
```
 
 service.onlyType(Image.class);
 service.byFullText(&quot;foo&quot;);
 service.or();
 service.onlyType(Dataset.class);
 service.byFullText(&quot;foo&quot;);
 
 
```
will return both Images and Datasets together. Calling this method overrides a previous setting of and or not. If there is no active queries (i.e. activeQueries > 0), then an ApiUsageException will be thrown.
Specified by:

or_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

remove_async
```
public final void remove_async(AMD_Search_remove __cb)
                        throws ServerError
```
Unsupported operation.

Specified by:

remove_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

resetDefaults_async
```
public final void resetDefaults_async(AMD_Search_resetDefaults __cb)
                               throws ServerError
```
Resets all settings (non-query state) to the original default values, as if the instance had just be created.

Specified by:

resetDefaults_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

results_async
```
public final void results_async(AMD_Search_results __cb)
                         throws ServerError
```
Returns up to getBatchSize batch size number of results along with the related query metadata. If isMergedBatches batches are merged then the results from multiple queries may be returned together.

Specified by:

results_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ApiUsageException - if hasNext returns false.

ServerError

setAllowLeadingWildcard_async

public final void setAllowLeadingWildcard_async(AMD_Search_setAllowLeadingWildcard __cb,
                                                boolean allowLeadingWildcard)
                                         throws ServerError

Permits full-text queries with a leading query if true.

Specified by:: setAllowLeadingWildcard_async in interface _SearchOperationsNC
Parameters:: __cb - The callback object for the operation.
Throws:: ServerError

setBatchSize_async
```
public final void setBatchSize_async(AMD_Search_setBatchSize __cb,
                                     int size)
                              throws ServerError
```
Sets the maximum number of results that will be returned by one call to results. If batches are not merged, then results may often be less than the batch size. If batches are merged, then only the last call to results can be less than batch size. Note: some query types may not support batching at the query level, and all instances must then be loaded into memory simultaneously.

Specified by:

setBatchSize_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

size - maximum number of results per call to results

Throws:

ServerError

setCaseSensitive_async
```
public final void setCaseSensitive_async(AMD_Search_setCaseSensitive __cb,
                                         boolean caseSensitive)
                                  throws ServerError
```
Sets the case sensitivity on all queries where case-sensitivity is supported.

Specified by:

setCaseSensitive_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

setCaseSentivice_async
```
public final void setCaseSentivice_async(AMD_Search_setCaseSentivice __cb,
                                         boolean caseSensitive)
                                  throws ServerError
```
Deprecated. use setCaseSensitive instead

Sets the case sensitivity on all queries where case-sensitivity is supported.

Specified by:

setCaseSentivice_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

setMergedBatches_async
```
public final void setMergedBatches_async(AMD_Search_setMergedBatches __cb,
                                         boolean merge)
                                  throws ServerError
```
Set whether or not results from two separate queries can be returned in the same call to results.

Specified by:

setMergedBatches_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

setReturnUnloaded_async
```
public final void setReturnUnloaded_async(AMD_Search_setReturnUnloaded __cb,
                                          boolean returnUnloaded)
                                   throws ServerError
```
Determines if all results should be returned as unloaded objects. This is particularly useful for creating lists for further querying via IQuery. This value overrides the setUseProjections setting.

Specified by:

setReturnUnloaded_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

setUseProjections_async
```
public final void setUseProjections_async(AMD_Search_setUseProjections __cb,
                                          boolean useProjections)
                                   throws ServerError
```
Determines if Lucene queries should not hit the database. Instead all values which are stored in the index will be loaded into the object, which includes the id. However, the entity will not be marked unloaded and therefore it is especially important to not allow a projection-instance to be saved back to the server. This can result in DATA LOSS.

Specified by:

setUseProjections_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

unordered_async
```
public final void unordered_async(AMD_Search_unordered __cb)
                           throws ServerError
```
Removes the current stack of order statements.

Specified by:

unordered_async in interface _SearchOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

activate_async
```
public final void activate_async(AMD_StatefulServiceInterface_activate __cb)
                          throws ServerError
```
Load a service implementation from disk if it was previously passivated. It is unnecessary to call this method since activation happens automatically, but calling this may prevent a short lapse when the service is first accessed after passivation. It is safe to call this method at any time, even when the service is not passivated.

Specified by:

activate_async in interface _StatefulServiceInterfaceOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

close_async
```
public final void close_async(AMD_StatefulServiceInterface_close __cb)
                       throws ServerError
```
Frees all resources -- passivated or active -- for the given stateful service and removes its name from the object adapter. Any further method calls will fail with a Ice::NoSuchObjectException. Note: with JavaEE, the close method was called publicly, and internally this called destroy(). As of the OmeroBlitz migration, this functionality has been combined.

Specified by:

close_async in interface _StatefulServiceInterfaceOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

getCurrentEventContext_async
```
public final void getCurrentEventContext_async(AMD_StatefulServiceInterface_getCurrentEventContext __cb)
                                        throws ServerError
```
To free clients from tracking the mapping from session to stateful service, each stateful service can returns its own context information.

Specified by:

getCurrentEventContext_async in interface _StatefulServiceInterfaceOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

passivate_async
```
public final void passivate_async(AMD_StatefulServiceInterface_passivate __cb)
                           throws ServerError
```
Causes the blitz server to store the service implementation to disk to free memory. This is typically done automatically by the server when a pre-defined memory limit is reached, but can be used by the client if it clear that a stateful service will not be used for some time. Activation will happen automatically whether passivation was done manually or automatically.

Specified by:

passivate_async in interface _StatefulServiceInterfaceOperationsNC

Parameters:

__cb - The callback object for the operation.

Throws:

ServerError

___activeQueries

public static Ice.DispatchStatus ___activeQueries(Search __obj,
                                                  IceInternal.Incoming __inS,
                                                  Ice.Current __current)

___setBatchSize

public static Ice.DispatchStatus ___setBatchSize(Search __obj,
                                                 IceInternal.Incoming __inS,
                                                 Ice.Current __current)

___getBatchSize

public static Ice.DispatchStatus ___getBatchSize(Search __obj,
                                                 IceInternal.Incoming __inS,
                                                 Ice.Current __current)

___setMergedBatches

public static Ice.DispatchStatus ___setMergedBatches(Search __obj,
                                                     IceInternal.Incoming __inS,
                                                     Ice.Current __current)

___isMergedBatches

public static Ice.DispatchStatus ___isMergedBatches(Search __obj,
                                                    IceInternal.Incoming __inS,
                                                    Ice.Current __current)

___setCaseSentivice

public static Ice.DispatchStatus ___setCaseSentivice(Search __obj,
                                                     IceInternal.Incoming __inS,
                                                     Ice.Current __current)

___setCaseSensitive

public static Ice.DispatchStatus ___setCaseSensitive(Search __obj,
                                                     IceInternal.Incoming __inS,
                                                     Ice.Current __current)

___isCaseSensitive

public static Ice.DispatchStatus ___isCaseSensitive(Search __obj,
                                                    IceInternal.Incoming __inS,
                                                    Ice.Current __current)

___setUseProjections

public static Ice.DispatchStatus ___setUseProjections(Search __obj,
                                                      IceInternal.Incoming __inS,
                                                      Ice.Current __current)

___isUseProjections

public static Ice.DispatchStatus ___isUseProjections(Search __obj,
                                                     IceInternal.Incoming __inS,
                                                     Ice.Current __current)

___setReturnUnloaded

public static Ice.DispatchStatus ___setReturnUnloaded(Search __obj,
                                                      IceInternal.Incoming __inS,
                                                      Ice.Current __current)

___isReturnUnloaded

public static Ice.DispatchStatus ___isReturnUnloaded(Search __obj,
                                                     IceInternal.Incoming __inS,
                                                     Ice.Current __current)

___setAllowLeadingWildcard

public static Ice.DispatchStatus ___setAllowLeadingWildcard(Search __obj,
                                                            IceInternal.Incoming __inS,
                                                            Ice.Current __current)

___isAllowLeadingWildcard

public static Ice.DispatchStatus ___isAllowLeadingWildcard(Search __obj,
                                                           IceInternal.Incoming __inS,
                                                           Ice.Current __current)

___onlyType

public static Ice.DispatchStatus ___onlyType(Search __obj,
                                             IceInternal.Incoming __inS,
                                             Ice.Current __current)

___onlyTypes

public static Ice.DispatchStatus ___onlyTypes(Search __obj,
                                              IceInternal.Incoming __inS,
                                              Ice.Current __current)

___allTypes

public static Ice.DispatchStatus ___allTypes(Search __obj,
                                             IceInternal.Incoming __inS,
                                             Ice.Current __current)

___onlyIds

public static Ice.DispatchStatus ___onlyIds(Search __obj,
                                            IceInternal.Incoming __inS,
                                            Ice.Current __current)

___onlyOwnedBy

public static Ice.DispatchStatus ___onlyOwnedBy(Search __obj,
                                                IceInternal.Incoming __inS,
                                                Ice.Current __current)

___notOwnedBy

public static Ice.DispatchStatus ___notOwnedBy(Search __obj,
                                               IceInternal.Incoming __inS,
                                               Ice.Current __current)

___onlyCreatedBetween

public static Ice.DispatchStatus ___onlyCreatedBetween(Search __obj,
                                                       IceInternal.Incoming __inS,
                                                       Ice.Current __current)

___onlyModifiedBetween

public static Ice.DispatchStatus ___onlyModifiedBetween(Search __obj,
                                                        IceInternal.Incoming __inS,
                                                        Ice.Current __current)

___onlyAnnotatedBetween

public static Ice.DispatchStatus ___onlyAnnotatedBetween(Search __obj,
                                                         IceInternal.Incoming __inS,
                                                         Ice.Current __current)

___onlyAnnotatedBy

public static Ice.DispatchStatus ___onlyAnnotatedBy(Search __obj,
                                                    IceInternal.Incoming __inS,
                                                    Ice.Current __current)

___notAnnotatedBy

public static Ice.DispatchStatus ___notAnnotatedBy(Search __obj,
                                                   IceInternal.Incoming __inS,
                                                   Ice.Current __current)

___onlyAnnotatedWith

public static Ice.DispatchStatus ___onlyAnnotatedWith(Search __obj,
                                                      IceInternal.Incoming __inS,
                                                      Ice.Current __current)

___addOrderByAsc

public static Ice.DispatchStatus ___addOrderByAsc(Search __obj,
                                                  IceInternal.Incoming __inS,
                                                  Ice.Current __current)

___addOrderByDesc

public static Ice.DispatchStatus ___addOrderByDesc(Search __obj,
                                                   IceInternal.Incoming __inS,
                                                   Ice.Current __current)

___unordered

public static Ice.DispatchStatus ___unordered(Search __obj,
                                              IceInternal.Incoming __inS,
                                              Ice.Current __current)

___fetchAnnotations

public static Ice.DispatchStatus ___fetchAnnotations(Search __obj,
                                                     IceInternal.Incoming __inS,
                                                     Ice.Current __current)

___fetchAlso

public static Ice.DispatchStatus ___fetchAlso(Search __obj,
                                              IceInternal.Incoming __inS,
                                              Ice.Current __current)

___resetDefaults

public static Ice.DispatchStatus ___resetDefaults(Search __obj,
                                                  IceInternal.Incoming __inS,
                                                  Ice.Current __current)

___byGroupForTags

public static Ice.DispatchStatus ___byGroupForTags(Search __obj,
                                                   IceInternal.Incoming __inS,
                                                   Ice.Current __current)

___byTagForGroups

public static Ice.DispatchStatus ___byTagForGroups(Search __obj,
                                                   IceInternal.Incoming __inS,
                                                   Ice.Current __current)

___byFullText

public static Ice.DispatchStatus ___byFullText(Search __obj,
                                               IceInternal.Incoming __inS,
                                               Ice.Current __current)

___byLuceneQueryBuilder

public static Ice.DispatchStatus ___byLuceneQueryBuilder(Search __obj,
                                                         IceInternal.Incoming __inS,
                                                         Ice.Current __current)

___bySimilarTerms

public static Ice.DispatchStatus ___bySimilarTerms(Search __obj,
                                                   IceInternal.Incoming __inS,
                                                   Ice.Current __current)

___byHqlQuery

public static Ice.DispatchStatus ___byHqlQuery(Search __obj,
                                               IceInternal.Incoming __inS,
                                               Ice.Current __current)

___bySomeMustNone

public static Ice.DispatchStatus ___bySomeMustNone(Search __obj,
                                                   IceInternal.Incoming __inS,
                                                   Ice.Current __current)

___byAnnotatedWith

public static Ice.DispatchStatus ___byAnnotatedWith(Search __obj,
                                                    IceInternal.Incoming __inS,
                                                    Ice.Current __current)

___clearQueries

public static Ice.DispatchStatus ___clearQueries(Search __obj,
                                                 IceInternal.Incoming __inS,
                                                 Ice.Current __current)

___and

public static Ice.DispatchStatus ___and(Search __obj,
                                        IceInternal.Incoming __inS,
                                        Ice.Current __current)

___or

public static Ice.DispatchStatus ___or(Search __obj,
                                       IceInternal.Incoming __inS,
                                       Ice.Current __current)

___not

public static Ice.DispatchStatus ___not(Search __obj,
                                        IceInternal.Incoming __inS,
                                        Ice.Current __current)

___hasNext

public static Ice.DispatchStatus ___hasNext(Search __obj,
                                            IceInternal.Incoming __inS,
                                            Ice.Current __current)

___next

public static Ice.DispatchStatus ___next(Search __obj,
                                         IceInternal.Incoming __inS,
                                         Ice.Current __current)

___results

public static Ice.DispatchStatus ___results(Search __obj,
                                            IceInternal.Incoming __inS,
                                            Ice.Current __current)

___currentMetadata

public static Ice.DispatchStatus ___currentMetadata(Search __obj,
                                                    IceInternal.Incoming __inS,
                                                    Ice.Current __current)

___currentMetadataList

public static Ice.DispatchStatus ___currentMetadataList(Search __obj,
                                                        IceInternal.Incoming __inS,
                                                        Ice.Current __current)

___remove

public static Ice.DispatchStatus ___remove(Search __obj,
                                           IceInternal.Incoming __inS,
                                           Ice.Current __current)

__dispatch

public Ice.DispatchStatus __dispatch(IceInternal.Incoming in,
                                     Ice.Current __current)

Specified by:: __dispatch in interface Ice.Object
Overrides:: __dispatch in class Ice.ObjectImpl

__writeImpl

protected void __writeImpl(IceInternal.BasicStream __os)

Overrides:: __writeImpl in class Ice.ObjectImpl

__readImpl

protected void __readImpl(IceInternal.BasicStream __is)

Overrides:: __readImpl in class Ice.ObjectImpl

Class _SearchDisp

Field Summary

Fields inherited from interface omero.api.Search

Constructor Summary

Method Summary

Methods inherited from class Ice.ObjectImpl

Methods inherited from class java.lang.Object

Methods inherited from interface omero.api._SearchOperations

Methods inherited from interface omero.api._StatefulServiceInterfaceOperations

Methods inherited from interface Ice.Object

Field Detail

__ids

serialVersionUID

Constructor Detail

_SearchDisp

Method Detail

ice_copyStateFrom

ice_isA

ice_isA

ice_ids

ice_ids

ice_id

ice_id

ice_staticId

activeQueries_async

addOrderByAsc_async

addOrderByDesc_async

allTypes_async

and_async

byAnnotatedWith_async

byFullText_async

byGroupForTags_async

byHqlQuery_async

byLuceneQueryBuilder_async

bySimilarTerms_async

bySomeMustNone_async

byTagForGroups_async

clearQueries_async

currentMetadata_async

currentMetadataList_async

fetchAlso_async

fetchAnnotations_async

getBatchSize_async

hasNext_async

isAllowLeadingWildcard_async

isCaseSensitive_async

isMergedBatches_async

isReturnUnloaded_async

isUseProjections_async

next_async

not_async

notAnnotatedBy_async

notOwnedBy_async

onlyAnnotatedBetween_async

onlyAnnotatedBy_async

onlyAnnotatedWith_async

onlyCreatedBetween_async

onlyIds_async

onlyModifiedBetween_async

onlyOwnedBy_async

onlyType_async

onlyTypes_async

or_async

remove_async

resetDefaults_async

results_async

setAllowLeadingWildcard_async

setBatchSize_async

setCaseSensitive_async

setCaseSentivice_async

setMergedBatches_async

setReturnUnloaded_async

setUseProjections_async

unordered_async

activate_async

close_async

getCurrentEventContext_async

passivate_async

___activeQueries

___setBatchSize