io.dangernoodle.slack.client.rtm.SlackObserverRegistry Maven / Gradle / Ivy
The newest version!
package io.dangernoodle.slack.client.rtm;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.Vector;
import java.util.concurrent.ConcurrentHashMap;
import io.dangernoodle.slack.events.SlackErrorEvent;
import io.dangernoodle.slack.events.SlackEvent;
import io.dangernoodle.slack.events.SlackEventType;
import io.dangernoodle.slack.events.SlackHelloEvent;
import io.dangernoodle.slack.events.SlackMessageEvent;
import io.dangernoodle.slack.events.SlackMessageEventType;
import io.dangernoodle.slack.events.SlackPongEvent;
import io.dangernoodle.slack.events.SlackReplyToEvent;
import io.dangernoodle.slack.events.SlackUnknownEvent;
import io.dangernoodle.slack.events.channel.SlackChannelCreatedEvent;
import io.dangernoodle.slack.events.channel.SlackChannelDeletedEvent;
import io.dangernoodle.slack.events.channel.SlackChannelJoinedEvent;
import io.dangernoodle.slack.events.channel.SlackChannelLeftEvent;
import io.dangernoodle.slack.events.channel.SlackChannelRenameEvent;
import io.dangernoodle.slack.events.user.SlackUserChangeEvent;
import io.dangernoodle.slack.events.user.SlackUserTypingEvent;
/**
* Registry for SlackEventObservers
*
* @since 0.1.0
*/
public class SlackObserverRegistry
{
private final Map>> messageObservers;
private final Map>> observers;
public SlackObserverRegistry()
{
this.observers = new ConcurrentHashMap<>(8, 0.9f, 1);
this.messageObservers = new ConcurrentHashMap<>(8, 0.9f, 1);
}
/**
* @param observer asdf
* @since 0.1.0
*/
public void addChannelCreatedObserver(SlackEventObserver observer)
{
addObserver(SlackEventType.CHANNEL_CREATED, observer);
}
/**
* @since 0.1.0
*/
public void addChannelDeletedObserver(SlackEventObserver observer)
{
addObserver(SlackEventType.CHANNEL_DELETED, observer);
}
/**
* @since 0.1.0
*/
public void addChannelJoinedObserver(SlackEventObserver observer)
{
addObserver(SlackEventType.CHANNEL_JOINED, observer);
}
/**
* @since 0.1.0
*/
public void addChannelLeftObserver(SlackEventObserver observer)
{
addObserver(SlackEventType.CHANNEL_LEFT, observer);
}
/**
* @since 0.1.0
*/
public void addChannelRenameObserver(SlackEventObserver observer)
{
addObserver(SlackEventType.CHANNEL_RENAME, observer);
}
/**
* @since 0.1.0
*/
public void addErrorObserver(SlackEventObserver observer)
{
addObserver(SlackEventType.ERROR, observer);
}
/**
* @since 0.1.0
*/
public void addGroupJoinedObserver(SlackEventObserver observer)
{
addObserver(SlackEventType.GROUP_JOINED, observer);
}
/**
* @since 0.1.0
*/
public void addGroupLeftObserver(SlackEventObserver observer)
{
addObserver(SlackEventType.GROUP_LEFT, observer);
}
/**
* @since 0.1.0
*/
public void addGroupRenameObserver(SlackEventObserver observer)
{
addObserver(SlackEventType.GROUP_RENAME, observer);
}
/**
* @since 0.1.0
*/
public void addHelloObserver(SlackEventObserver observer)
{
addObserver(SlackEventType.HELLO, observer);
}
/**
* @since 0.1.0
*/
public void addMessageChangedObserver(SlackEventObserver observer)
{
addObserver(SlackMessageEventType.MESSAGE_CHANGED, observer);
}
/**
* @since 0.1.0
*/
public void addMessageDeletedObserver(SlackEventObserver observer)
{
addObserver(SlackMessageEventType.MESSAGE_DELETED, observer);
}
/**
* @since 0.1.0
*/
public void addMessagePostedObserver(SlackEventObserver observer)
{
addObserver(SlackEventType.MESSAGE, observer);
}
/**
* @since 0.1.0
*/
public void addPongObserver(SlackEventObserver observer)
{
addObserver(SlackEventType.PONG, observer);
}
/**
* @since 0.1.0
*/
public void addReplyToObserver(SlackEventObserver observer)
{
addObserver(SlackEventType.REPLY_TO, observer);
}
/**
* @since 0.1.0
*/
public void addUnknownMessageObserver(SlackEventObserver observer)
{
addObserver(SlackMessageEventType.UNKNOWN, observer);
}
/**
* @since 0.1.0
*/
public void addUnknownObserver(SlackEventObserver observer)
{
addObserver(SlackEventType.UNKNOWN, observer);
}
/**
* @since 0.1.0
*/
public void addUserChangeObserver(SlackEventObserver observer)
{
addObserver(SlackEventType.USER_CHANGE, observer);
}
/**
* @since 0.1.0
*/
public void addUserTypingObserver(SlackEventObserver observer)
{
addObserver(SlackEventType.USER_TYPING, observer);
}
/**
* @since 0.1.0
*/
public void removeChannelCreatedObserver(SlackEventObserver observer)
{
removeObserver(SlackEventType.CHANNEL_CREATED, observer);
}
/**
* @since 0.1.0
*/
public void removeChannelDeletedObserver(SlackEventObserver observer)
{
removeObserver(SlackEventType.CHANNEL_DELETED, observer);
}
/**
* @since 0.1.0
*/
public void removeChannelJoinedObserver(SlackEventObserver observer)
{
removeObserver(SlackEventType.CHANNEL_JOINED, observer);
}
/**
* @since 0.1.0
*/
public void removeChannelLeftObserver(SlackEventObserver observer)
{
removeObserver(SlackEventType.CHANNEL_LEFT, observer);
}
/**
* @since 0.1.0
*/
public void removeChannelRenameObservers(SlackEventObserver observer)
{
removeObserver(SlackEventType.CHANNEL_RENAME, observer);
}
/**
* @since 0.1.0
*/
public void removeErrorObserver(SlackEventObserver observer)
{
removeObserver(SlackEventType.ERROR, observer);
}
/**
* @since 0.1.0
*/
public void removeGroupJoinedObserver(SlackEventObserver observer)
{
removeObserver(SlackEventType.GROUP_JOINED, observer);
}
/**
* @since 0.1.0
*/
public void removeGroupLeftObserver(SlackEventObserver observer)
{
removeObserver(SlackEventType.GROUP_LEFT, observer);
}
/**
* @since 0.1.0
*/
public void removeGrouplJoinedObserver(SlackEventObserver observer)
{
removeObserver(SlackEventType.GROUP_JOINED, observer);
}
/**
* @since 0.1.0
*/
public void removeGroupRenameObservers(SlackEventObserver observer)
{
removeObserver(SlackEventType.GROUP_RENAME, observer);
}
/**
* @since 0.1.0
*/
public void removeHelloObservers(SlackEventObserver observer)
{
removeObserver(SlackEventType.HELLO, observer);
}
/**
* @since 0.1.0
*/
public void removeMessageChangedObserver(SlackEventObserver observer)
{
removeObserver(SlackMessageEventType.MESSAGE_CHANGED, observer);
}
/**
* @since 0.1.0
*/
public void removeMessageDeletedObserver(SlackEventObserver observer)
{
removeObserver(SlackMessageEventType.MESSAGE_DELETED, observer);
}
/**
* @since 0.1.0
*/
public void removeMessagePostedObserver(SlackEventObserver observer)
{
removeObserver(SlackEventType.MESSAGE, observer);
}
/**
* @since 0.1.0
*/
public void removePongObserver(SlackEventObserver observer)
{
removeObserver(SlackEventType.PONG, observer);
}
/**
* @since 0.1.0
*/
public void removeReplyToObserver(SlackEventObserver observer)
{
removeObserver(SlackEventType.REPLY_TO, observer);
}
/**
* @since 0.1.0
*/
public void removeUnknownMessageObserver(SlackEventObserver observer)
{
removeObserver(SlackMessageEventType.UNKNOWN, observer);
}
/**
* @since 0.1.0
*/
public void removeUnknownObserver(SlackEventObserver observer)
{
removeObserver(SlackEventType.UNKNOWN, observer);
}
/**
* @since 0.1.0
*/
public void removeUserChangeObserver(SlackEventObserver observer)
{
removeObserver(SlackEventType.USER_CHANGE, observer);
}
/**
* @since 0.1.0
*/
public void removeUserTypingObserver(SlackEventObserver observer)
{
removeObserver(SlackEventType.USER_TYPING, observer);
}
/**
* @since 0.1.0
*/
@SuppressWarnings("unchecked")
> Collection findObservers(T eventType)
{
Collection collection = Collections.emptyList();
if (observers.containsKey(eventType))
{
collection = (Collection) observers.get(eventType);
}
else if (messageObservers.containsKey(eventType))
{
collection = (Collection) messageObservers.get(eventType);
}
// always return a copy in case an event is firing the same time a handle is removed
return new ArrayList<>(collection);
}
boolean isObserverRegistered(E eventType, SlackEventObserver observer)
{
if (observers.containsKey(eventType))
{
return observers.get(eventType).contains(observer);
}
if (messageObservers.containsKey(eventType))
{
return messageObservers.get(eventType).contains(observer);
}
return false;
}
private void addObserver(SlackEventType eventType, SlackEventObserver observer)
{
observers.computeIfAbsent(eventType, k -> new Vector<>()).add(observer);
}
/*
* the 'SlackMessageEvent' class doesn't really lend well to the idea of a 'SlackUnknownMessageEvent', so for now
* let it be a more relaxed bound
*/
private void addObserver(SlackMessageEventType eventType, SlackEventObserver observer)
{
messageObservers.computeIfAbsent(eventType, k -> new Vector<>()).add(observer);
}
private void removeObserver(E eventType, SlackEventObserver observer)
{
if (observers.containsKey(eventType))
{
observers.get(eventType).remove(observer);
}
if (messageObservers.containsKey(eventType))
{
messageObservers.get(eventType).remove(observer);
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy