<p>
A list of SNS topic names that receive status messages from the specified Directory ID.
</p>

@param eventTopics
A list of SNS topic names that receive status messages from the specified Directory ID.
4845
public void setEventTopics(java.util.Collection<EventTopic> eventTopics) {
        if (eventTopics == null) {
            this.eventTopics = null;
            return;
        }

        this.eventTopics = new com.amazonaws.internal.SdkInternalList<EventTopic>(eventTopics);
    }
273349
public void setTopicSpace(final String topicSpace) {
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled()) {
            SibTr.debug(this, TRACE, "setTopicSpace", topicSpace);
        }
        _topicSpace = topicSpace;
        dynamicallyCreateDestination();
    }
765865
@SuppressWarnings("unchecked")
    public Set<String> getTopics() {
        Map<String, List<PartitionInfo>> topicInfo = getTopicInfo();
        Set<String> topics = topicInfo != null ? topicInfo.keySet() : null;
        return topics != null ? Collections.unmodifiableSet(topics) : Collections.EMPTY_SET;
    }
672027
public void setEventDestinations(java.util.Collection<EventDestination> eventDestinations) {
        if (eventDestinations == null) {
            this.eventDestinations = null;
            return;
        }

        this.eventDestinations = new com.amazonaws.internal.SdkInternalList<EventDestination>(eventDestinations);
    }
1223025
public static Map<String, Message> messageTopics(Message message, String defaultTopic, String dynamicTopicConfigs) {
        List<CanalEntry.Entry> entries;
        if (message.isRaw()) {
            List<ByteString> rawEntries = message.getRawEntries();
            entries = new ArrayList<>(rawEntries.size());
            for (ByteString byteString : rawEntries) {
                CanalEntry.Entry entry;
                try {
                    entry = CanalEntry.Entry.parseFrom(byteString);
                } catch (InvalidProtocolBufferException e) {
                    throw new RuntimeException(e);
                }
                entries.add(entry);
            }
        } else {
            entries = message.getEntries();
        }
        Map<String, Message> messages = new HashMap<>();
        for (CanalEntry.Entry entry : entries) {
            if (entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONBEGIN
                || entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONEND) {
                continue;
            }

            String schemaName = entry.getHeader().getSchemaName();
            String tableName = entry.getHeader().getTableName();

            if (StringUtils.isEmpty(schemaName) || StringUtils.isEmpty(tableName)) {
                put2MapMessage(messages, message.getId(), defaultTopic, entry);
            } else {
                Set<String> topics = matchTopics(schemaName + "." + tableName, dynamicTopicConfigs);
                if (topics != null) {
                    for (String topic : topics) {
                        put2MapMessage(messages, message.getId(), topic, entry);
                    }
                } else {
                    topics = matchTopics(schemaName, dynamicTopicConfigs);
                    if (topics != null) {
                        for (String topic : topics) {
                            put2MapMessage(messages, message.getId(), topic, entry);
                        }
                    } else {
                        put2MapMessage(messages, message.getId(), defaultTopic, entry);
                    }
                }
            }
        }
        return messages;
    }
8
public TopicProducer<Object> createTopicJsonProducer(final String topic)
    {
        Preconditions.checkState(connectionFactory != null, "connection factory was never injected!");
        return new TopicProducer<Object>(connectionFactory, jmsConfig, topic, producerCallback);
    }
305964
public Observable<List<TopicTypeInfoInner>> listAsync() {
        return listWithServiceResponseAsync().map(new Func1<ServiceResponse<List<TopicTypeInfoInner>>, List<TopicTypeInfoInner>>() {
            @Override
            public List<TopicTypeInfoInner> call(ServiceResponse<List<TopicTypeInfoInner>> response) {
                return response.body();
            }
        });
    }
910202
public java.util.List<String> getEventCategories() {
        if (eventCategories == null) {
            eventCategories = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return eventCategories;
    }
366880
public String[] getTopics()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "getTopics");

    String[] topics = consumerDispatcherState.getTopics();
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())             
      SibTr.exit(tc, "getTopics", topics);
    return topics;
  }
287122
public void setEventTypeCodes(java.util.Collection<String> eventTypeCodes) {
        if (eventTypeCodes == null) {
            this.eventTypeCodes = null;
            return;
        }

        this.eventTypeCodes = new java.util.ArrayList<String>(eventTypeCodes);
    }
835528
void sendSubscriptionEvent(String topic, int nb) {
		Collection<Session> sessions = getSessionsForTopic(topic);
		if (!sessions.isEmpty()) {
			MessageToClient messageToClient = new MessageToClient();
			messageToClient.setId(topic);
			messageToClient.setType(MessageType.MESSAGE);
			messageToClient.setResponse(nb);
//			Collection<Session> sessionsClosed = new ArrayList<>(); // throws java.lang.StackOverflowError
			for (Session session : sessions) {
				if (session.isOpen()) {
					session.getAsyncRemote().sendObject(messageToClient);
//				} else {
//					sessionsClosed.add(session);
				}
			}
//			removeSessionsToTopic(sessionsClosed);
		}
	}
867419
public void setDeploymentStatusMessages(java.util.Collection<String> deploymentStatusMessages) {
        if (deploymentStatusMessages == null) {
            this.deploymentStatusMessages = null;
            return;
        }

        this.deploymentStatusMessages = new com.amazonaws.internal.SdkInternalList<String>(deploymentStatusMessages);
    }
932997
public void broadcastTextMessage(String topicName, String textMessage, int delaySeconds)
            throws NamingException, JMSException, ServiceLocatorException {
        if (mdwMessageProducer != null) {
            mdwMessageProducer.broadcastMessageToTopic(topicName, textMessage);
        }
        else {
            TopicConnectionFactory tFactory = null;
            TopicConnection tConnection = null;
            TopicSession tSession = null;
            TopicPublisher tPublisher = null;
            try {
                // if (logger.isDebugEnabled()) logger.debug("broadcast JMS
                // message: " +
                // textMessage);
                // cannot log above - causing recursive broadcasting
                tFactory = getTopicConnectionFactory(null);
                tConnection = tFactory.createTopicConnection();
                tSession = tConnection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
                Topic topic = getTopic(topicName);
                tPublisher = tSession.createPublisher(topic);

                // TODO: platform-independent delay
                // WLMessageProducer wlMessageProducer =
                // (WLMessageProducer)tPublisher;
                // long delayInMilliSec = 0;
                // if(pMinDelay > 0){
                // delayInMilliSec = delaySeconds*1000;
                // }
                // wlMessageProducer.setTimeToDeliver(delayInMilliSec);
                TextMessage message = tSession.createTextMessage();
                tConnection.start();

                message.setText(textMessage);
                tPublisher.publish(message, DeliveryMode.PERSISTENT,
                        TextMessage.DEFAULT_DELIVERY_MODE, TextMessage.DEFAULT_TIME_TO_LIVE);
                // }catch(ServiceLocatorException ex){
                // ex.printStackTrace();
                // never log exception here!!! infinite loop when publishing log
                // messages
                // throw new JMSException(ex.getMessage());
            }
            finally {
                closeResources(tConnection, tSession, tPublisher);

            }
        }
    }
769668
public TopicProducer<String> createTopicTextMessageProducer(final String topic)
    {
        Preconditions.checkState(connectionFactory != null, "connection factory was never injected!");
        return new TopicProducer<String>(connectionFactory, jmsConfig, topic, new TextMessageProducerCallback());
    }
478039
final PublishResponse publish(
      ProjectTopicName topic, List<PubsubMessage> messages) {

    PublishRequest request =
        PublishRequest.newBuilder()
            .setTopic(topic == null ? null : topic.toString())
            .addAllMessages(messages)
            .build();
    return publish(request);
  }
1153658
public void webEvent(final WebEvent webEvent) {

		if (LOG.isDebugEnabled()) {
			LOG.debug("Sending web event " + webEvent + " for bundle "
					+ webEvent.getBundleName());
		}

		synchronized (listeners) {
			callListeners(webEvent);
			states.put(webEvent.getBundleId(), webEvent);
		}

		final String topic;
		switch (webEvent.getType()) {
			case WebEvent.DEPLOYING:
				topic = WebTopic.DEPLOYING.toString();
				break;
			case WebEvent.DEPLOYED:
				topic = WebTopic.DEPLOYED.toString();
				break;
			case WebEvent.UNDEPLOYING:
				topic = WebTopic.UNDEPLOYING.toString();
				break;
			case WebEvent.UNDEPLOYED:
				topic = WebTopic.UNDEPLOYED.toString();
				break;
			case WebEvent.FAILED:
				topic = WebTopic.FAILED.toString();
				break;
			case WebEvent.WAITING:
				// topic = WebTopic.WAITING.toString();
				// A Waiting Event is not supported by the specification
				// therefore it is mapped to FAILED, because of collision.
				topic = WebTopic.FAILED.toString();
				break;
			default:
				topic = WebTopic.FAILED.toString();
		}

		try {
			executors.submit(new Runnable() {
				public void run() {
					Dictionary<String, Object> properties = new Hashtable<>();
					properties.put("bundle.symbolicName", webEvent
							.getBundleName());
					properties.put("bundle.id", webEvent.getBundleId());
					String bundleVersionObject = webEvent.getBundleVersion();
					Version bundleVersion;
					if (bundleVersionObject != null) {
						bundleVersion = new Version(
								(String) bundleVersionObject);
					} else {
						bundleVersion = new Version("0.0.0");
					}
					properties.put("bundle.version", bundleVersion);
					properties.put("context.path",
							webEvent.getContextPath());
					properties.put("timestamp", webEvent.getTimestamp());
					properties.put("extender.bundle.id", webEvent
							.getExtenderBundleId());
					properties.put("extender.bundle.symbolicName", webEvent
							.getExtenderBundleName());
					String extenderBundleVersionObject = webEvent
							.getExtenderBundleVersion();
					Version extenderVersion;
					if (extenderBundleVersionObject != null) {
						extenderVersion = new Version(
								(String) extenderBundleVersionObject);
					} else {
						extenderVersion = new Version("0.0.0");
					}
					properties.put("extender.bundle.version",
							extenderVersion);

					if (webEvent.getCause() != null) {
						properties.put("exception", webEvent.getCause());
					}

					if (webEvent.getCollisionIds() != null) {
						properties.put("collision",
								webEvent.getContextPath());
						properties.put("collision.bundles",
								webEvent.getCollisionIds());
					}

					Event event = new Event(topic, properties);
					EventAdmin adminService = getEventAdmin();
					if (adminService != null) {
						adminService.postEvent(event);
					}

				}
			});
		} catch (RejectedExecutionException ree) {
			LOG.warn("Executor shut down", ree);
		}

		try {
			executors.submit(new Runnable() {
				public void run() {
					LogService logService = getLogService();
					if (logService != null) {
						logService.log(LogService.LOG_DEBUG, topic);
					} else {
						if (webEvent.getCause() != null) {
							LOG.error(webEvent.toString());
						} else {
							LOG.debug(topic);
						}
					}
				}
			});
		} catch (RejectedExecutionException ree) {
			LOG.warn("Executor shut down", ree);
		}

	}
961664
public void setConnectionNotificationIds(java.util.Collection<String> connectionNotificationIds) {
        if (connectionNotificationIds == null) {
            this.connectionNotificationIds = null;
            return;
        }

        this.connectionNotificationIds = new com.amazonaws.internal.SdkInternalList<String>(connectionNotificationIds);
    }