DataReader.java

Go to the documentation of this file.

/* Copyright 2010, Object Management Group, Inc.
 * Copyright 2010, PrismTech, Inc.
 * Copyright 2010, Real-Time Innovations, Inc.
 * All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.omg.dds.sub;

import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

import org.omg.dds.core.DDSObject;
import org.omg.dds.core.DomainEntity;
import org.omg.dds.core.Duration;
import org.omg.dds.core.InstanceHandle;
import org.omg.dds.core.StatusCondition;
import org.omg.dds.core.status.LivelinessChangedStatus;
import org.omg.dds.core.status.RequestedDeadlineMissedStatus;
import org.omg.dds.core.status.RequestedIncompatibleQosStatus;
import org.omg.dds.core.status.SampleLostStatus;
import org.omg.dds.core.status.SampleRejectedStatus;
import org.omg.dds.core.status.SubscriptionMatchedStatus;
import org.omg.dds.topic.PublicationBuiltinTopicData;
import org.omg.dds.topic.TopicDescription;


public interface DataReader<TYPE>
extends DomainEntity<DataReaderListener<TYPE>, DataReaderQos>
{
    public <OTHER> DataReader<OTHER> cast();

    public ReadCondition<TYPE> createReadCondition(
            Subscriber.DataState states);

    public QueryCondition<TYPE> createQueryCondition(
            String queryExpression,
            List<String> queryParameters);

    public QueryCondition<TYPE> createQueryCondition(
            String queryExpression,
            String... queryParameters);

    public QueryCondition<TYPE> createQueryCondition(
            Subscriber.DataState states,
            String queryExpression,
            List<String> queryParameters);

    public QueryCondition<TYPE> createQueryCondition(
            Subscriber.DataState states,
            String queryExpression,
            String... queryParameters);

    public void closeContainedEntities();

    public TopicDescription<TYPE> getTopicDescription();

    public SampleRejectedStatus getSampleRejectedStatus();

    public LivelinessChangedStatus getLivelinessChangedStatus();

    public RequestedDeadlineMissedStatus getRequestedDeadlineMissedStatus();

    public RequestedIncompatibleQosStatus getRequestedIncompatibleQosStatus();

    public SubscriptionMatchedStatus getSubscriptionMatchedStatus();

    public SampleLostStatus getSampleLostStatus();

    public void waitForHistoricalData(Duration maxWait)
            throws TimeoutException;

    public void waitForHistoricalData(long maxWait, TimeUnit unit)
            throws TimeoutException;

    public Set<InstanceHandle> getMatchedPublications();

    public PublicationBuiltinTopicData getMatchedPublicationData(
            InstanceHandle publicationHandle);


    // --- Type-specific interface: ------------------------------------------

    public Sample.Iterator<TYPE> read();

    public Sample.Iterator<TYPE> read(Selector<TYPE> query);

    public Sample.Iterator<TYPE> read(int maxSamples);

    public List<Sample<TYPE>> read(List<Sample<TYPE>> samples);

    public List<Sample<TYPE>> read(
            List<Sample<TYPE>> samples,
            Selector<TYPE> selector);

    public Sample.Iterator<TYPE> take();

    public Sample.Iterator<TYPE> take(int maxSamples);

    public Sample.Iterator<TYPE> take(Selector<TYPE> query);

    public List<Sample<TYPE>> take(List<Sample<TYPE>> samples);

    public List<Sample<TYPE>> take(
            List<Sample<TYPE>> samples,
            Selector<TYPE> query);

    public boolean readNextSample(Sample<TYPE> sample);

    public boolean takeNextSample(Sample<TYPE> sample);

    public TYPE getKeyValue(
            TYPE keyHolder,
            InstanceHandle handle);

    public TYPE getKeyValue(InstanceHandle handle);

    public InstanceHandle lookupInstance(TYPE keyHolder);


    // --- From Entity: ------------------------------------------------------
    @Override
    public StatusCondition<DataReader<TYPE>> getStatusCondition();

    @Override
    public Subscriber getParent();

    public Selector<TYPE> select();

    public static interface Selector<T> extends DDSObject {

        // --- Setters ----------------------------------------------

        public Selector<T> instance(InstanceHandle handle);
        public Selector<T> nextInstance(boolean retrieveNextInstance);

        public Selector<T> dataState(Subscriber.DataState state);

        public Selector<T> Content(String queryExpression, List<String> queryParameters);

        public Selector<T> Content(String queryExpression, String... queryParameters);
        public Selector<T> maxSamples(int max);

        // --- Getters ----------------------------------------------

        public InstanceHandle getInstance();
        public boolean retrieveNextInstance();
        public Subscriber.DataState getDataState();
        public String getQueryExpression();
        public List<String> getQueryParameters();
        public int getMaxSamples();
        public ReadCondition<T> getCondition();

        // --- read/take operations ----------------------------------

        public Sample.Iterator<T> read();
        public List<Sample<T>> read(List<Sample<T>> samples);
        public Sample.Iterator<T> take();
        public List<Sample<T>> take(List<Sample<T>> samples);
    }
}