org.pircbotx.UserChannelMap.java Source code

Introduction

Here is the source code for org.pircbotx.UserChannelMap.java

Source

/**
 * Copyright (C) 2010-2014 Leon Blakey <lord.quackstar at gmail.com>
 *
 * This file is part of PircBotX.
 *
 * PircBotX is free software: you can redistribute it and/or modify it under the
 * terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 *
 * PircBotX is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * PircBotX. If not, see <http://www.gnu.org/licenses/>.
 */
package org.pircbotx;

import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableMultimap;
import com.google.common.collect.ImmutableSortedSet;
import com.google.common.collect.Multimap;
import java.util.Map;
import lombok.AccessLevel;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.pircbotx.snapshot.ChannelSnapshot;
import org.pircbotx.snapshot.UserChannelMapSnapshot;
import org.pircbotx.snapshot.UserSnapshot;

/**
 * A many to many map of users to channels.
 */
@RequiredArgsConstructor(access = AccessLevel.PROTECTED)
@Slf4j
public class UserChannelMap<U extends User, C extends Channel> {
    protected final Multimap<U, C> userToChannelMap;
    protected final Multimap<C, U> channelToUserMap;

    /**
     * Create with HashMultimaps.
     */
    public UserChannelMap() {
        channelToUserMap = HashMultimap.create();
        userToChannelMap = HashMultimap.create();
    }

    public void addUserToChannel(U user, C channel) {
        userToChannelMap.put(user, channel);
        channelToUserMap.put(channel, user);
    }

    public void removeUserFromChannel(U user, C channel) {
        userToChannelMap.remove(user, channel);
        channelToUserMap.remove(channel, user);
    }

    public void removeUser(U user) {
        //Remove the user from each channel
        for (Channel curChannel : userToChannelMap.removeAll(user))
            channelToUserMap.remove(curChannel, user);
    }

    public void removeChannel(C channel) {
        //Remove the channel from each user
        for (User curUser : channelToUserMap.removeAll(channel))
            //This will automatically remove the user if they have no more channels
            userToChannelMap.remove(curUser, channel);
    }

    public ImmutableSortedSet<U> getUsers(C channel) {
        return ImmutableSortedSet.copyOf(channelToUserMap.get(channel));
    }

    public ImmutableSortedSet<C> getChannels(U user) {
        return ImmutableSortedSet.copyOf(userToChannelMap.get(user));
    }

    public boolean containsEntry(U user, C channel) {
        boolean channelToUserContains = channelToUserMap.containsEntry(channel, user);
        boolean userToChannelContains = userToChannelMap.containsEntry(user, channel);
        if (channelToUserContains != userToChannelContains)
            throw new RuntimeException(
                    "Map inconsistent! User: " + user + " | Channel: " + channel + " | channelToUserMap: "
                            + channelToUserContains + " | userToChannelMap: " + userToChannelContains);
        return channelToUserContains;
    }

    public boolean containsUser(User user) {
        boolean channelToUserContains = channelToUserMap.containsValue(user);
        boolean userToChannelContains = userToChannelMap.containsKey(user);
        if (channelToUserContains != userToChannelContains)
            throw new RuntimeException("Map inconsistent! User: " + user + " | channelToUserMap: "
                    + channelToUserContains + " | userToChannelMap: " + userToChannelContains);
        return channelToUserContains;
    }

    public void clear() {
        userToChannelMap.clear();
        channelToUserMap.clear();
    }

    public UserChannelMapSnapshot createSnapshot(Map<U, UserSnapshot> userSnapshots,
            Map<C, ChannelSnapshot> channelSnapshots) {
        //Create new multimaps replacing each user and channel with their respective snapshots
        ImmutableMultimap.Builder<UserSnapshot, ChannelSnapshot> userToChannelSnapshotBuilder = ImmutableMultimap
                .builder();
        for (Map.Entry<U, C> curEntry : userToChannelMap.entries())
            userToChannelSnapshotBuilder.put(userSnapshots.get(curEntry.getKey()),
                    channelSnapshots.get(curEntry.getValue()));
        ImmutableMultimap.Builder<ChannelSnapshot, UserSnapshot> channelToUserSnapshotBuilder = ImmutableMultimap
                .builder();
        for (Map.Entry<C, U> curEntry : channelToUserMap.entries())
            channelToUserSnapshotBuilder.put(channelSnapshots.get(curEntry.getKey()),
                    userSnapshots.get(curEntry.getValue()));

        //Return a snapshot of the map
        return new UserChannelMapSnapshot(userToChannelSnapshotBuilder.build(),
                channelToUserSnapshotBuilder.build());
    }
}