org.ros.internal.node.topic.TopicParticipantManager.java Source code

Introduction

Here is the source code for org.ros.internal.node.topic.TopicParticipantManager.java

Source

/*
 * Copyright (C) 2011 Google Inc.
 *
 * 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.ros.internal.node.topic;

import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;

import org.ros.namespace.GraphName;
import org.ros.node.topic.Publisher;
import org.ros.node.topic.Subscriber;

import java.util.Collection;
import java.util.Map;

/**
 * Manages a collection of {@link Publisher}s and {@link Subscriber}s.
 *
 * @author kwc@willowgarage.com (Ken Conley)
 * @author damonkohler@google.com (Damon Kohler)
 */
public class TopicParticipantManager {

    /**
     * A mapping from topic name to {@link Subscriber}.
     */
    private final Map<GraphName, DefaultSubscriber<?>> subscribers;

    /**
     * A mapping from topic name to {@link Publisher}.
     */
    private final Map<GraphName, DefaultPublisher<?>> publishers;

    /**
     * A mapping from {@link Subscriber} to its connected
     * {@link PublisherIdentifier}s.
     */
    private final Multimap<DefaultSubscriber<?>, PublisherIdentifier> subscriberConnections;

    /**
     * A mapping from {@link Publisher} to its connected
     * {@link SubscriberIdentifier}s.
     */
    private final Multimap<DefaultPublisher<?>, SubscriberIdentifier> publisherConnections;

    // TODO(damonkohler): Change to ListenerGroup.
    private TopicParticipantManagerListener listener;

    public TopicParticipantManager() {
        publishers = Maps.newConcurrentMap();
        subscribers = Maps.newConcurrentMap();
        subscriberConnections = HashMultimap.create();
        publisherConnections = HashMultimap.create();
    }

    public void setListener(TopicParticipantManagerListener listener) {
        this.listener = listener;
    }

    public boolean hasSubscriber(GraphName topicName) {
        return subscribers.containsKey(topicName);
    }

    public boolean hasPublisher(GraphName topicName) {
        return publishers.containsKey(topicName);
    }

    public DefaultPublisher<?> getPublisher(GraphName topicName) {
        return publishers.get(topicName);
    }

    public DefaultSubscriber<?> getSubscriber(GraphName topicName) {
        return subscribers.get(topicName);
    }

    public void addPublisher(DefaultPublisher<?> publisher) {
        publishers.put(publisher.getTopicName(), publisher);
        if (listener != null) {
            listener.onPublisherAdded(publisher);
        }
    }

    public void removePublisher(DefaultPublisher<?> publisher) {
        publishers.remove(publisher.getTopicName());
        if (listener != null) {
            listener.onPublisherRemoved(publisher);
        }
    }

    public void addSubscriber(DefaultSubscriber<?> subscriber) {
        subscribers.put(subscriber.getTopicName(), subscriber);
        if (listener != null) {
            listener.onSubscriberAdded(subscriber);
        }
    }

    public void removeSubscriber(DefaultSubscriber<?> subscriber) {
        subscribers.remove(subscriber.getTopicName());
        if (listener != null) {
            listener.onSubscriberRemoved(subscriber);
        }
    }

    public void addSubscriberConnection(DefaultSubscriber<?> subscriber, PublisherIdentifier publisherIdentifier) {
        subscriberConnections.put(subscriber, publisherIdentifier);
    }

    public void removeSubscriberConnection(DefaultSubscriber<?> subscriber,
            PublisherIdentifier publisherIdentifier) {
        subscriberConnections.remove(subscriber, publisherIdentifier);
    }

    public void addPublisherConnection(DefaultPublisher<?> publisher, SubscriberIdentifier subscriberIdentifier) {
        publisherConnections.put(publisher, subscriberIdentifier);
    }

    public void removePublisherConnection(DefaultPublisher<?> publisher,
            SubscriberIdentifier subscriberIdentifier) {
        publisherConnections.remove(publisher, subscriberIdentifier);
    }

    public Collection<DefaultSubscriber<?>> getSubscribers() {
        return ImmutableList.copyOf(subscribers.values());
    }

    public Collection<PublisherIdentifier> getSubscriberConnections(DefaultSubscriber<?> subscriber) {
        return ImmutableList.copyOf(subscriberConnections.get(subscriber));
    }

    public Collection<DefaultPublisher<?>> getPublishers() {
        return ImmutableList.copyOf(publishers.values());
    }

    public Collection<SubscriberIdentifier> getPublisherConnections(DefaultPublisher<?> publisher) {
        return ImmutableList.copyOf(publisherConnections.get(publisher));
    }
}