com.kuka.geometry.connections
Interface ITrafoQueryProcessor<T extends IQueryConnection<T>>

Type Parameters:

T - the type of sensor connection that the implementing class can handle

public interface ITrafoQueryProcessor<T extends IQueryConnection<T>>

This interface is meant to be implemented by components that can communicate with real world sensors to find out the current sensor values, and from these values calculate spatial transformations that can be used to express a connection between frames.

The implementation must be thread safe and must react to thread interrupts.

See Also:

Thread.interrupted(), InterruptedException, IQueryConnection

Method Summary

Future<Map<QueryType,List<ITransformation>>>

processQuery(Collection<QueryType> queryTypes, List<T> connections, Object queryContext) Query the sensors asynchronously, and for each given connection and query type return a corresponding ITransformation.

Method Detail

processQuery

Future<Map<QueryType,List<ITransformation>>> processQuery(Collection<QueryType> queryTypes,
                                                          List<T> connections,
                                                          Object queryContext)

Query the sensors asynchronously, and for each given connection and query type return a corresponding ITransformation.

This method is designed so that it can query multiple connections using multiple query types with one call, so that the implementation can provide sensor values from the same time instant (for example: field bus cycle).

Implementations can support multiple query types, so that one can distinguish between theoretical and real measured sensor values, for example. Furthermore the implementation shall be able to handle null as QueryType, and process the query using an implementation specific default behavior.

This method must be thread safe and should not block execution, i.e. it should return immediately.

Parameters:

queryTypes - a collection of QueryTypes to execute. The collection may contain null values. For each distinct value, a query is executed, and a corresponding result will be returned in a map. If the implementation cannot compute a ITransformation for the given query type, it shall throw a suitable exception.

connections - a list of IQueryConnection for which the sensor(s) should be evaluated. Each list entry will be mapped to a corresponding entry in the returned list.

queryContext - an arbitrary object that can be used by the query processor. Can be null.

Returns:

a Future resulting in a map, containing a list of ITransformation for each distinct value of the given query types. The lists each contain exactly the same number of entries as the connections parameter. Each entry is non-null and corresponds to the entry of the connection parameter with the same list index. The list and its entries must be safe for the caller to use in any way, so the result should be immutable or otherwise no longer be used by the query processor.