Java 类cpw.mods.fml.common.network.simpleimpl.IMessageHandler 实例源码

/**
 * Registers an {@link AbstractMessage} to the appropriate side(s)
 */
private static final <T extends AbstractMessage<T> & IMessageHandler<T, IMessage>> void registerMessage(Class<T> clazz) {
    if (AbstractMessage.AbstractClientMessage.class.isAssignableFrom(clazz)) {
        PacketDispatcher.dispatcher.registerMessage(clazz, clazz, packetId++, Side.CLIENT);
    } else if (AbstractMessage.AbstractServerMessage.class.isAssignableFrom(clazz)) {
        PacketDispatcher.dispatcher.registerMessage(clazz, clazz, packetId++, Side.SERVER);
    } else {
        PacketDispatcher.dispatcher.registerMessage(clazz, clazz, packetId, Side.CLIENT);
        PacketDispatcher.dispatcher.registerMessage(clazz, clazz, packetId++, Side.SERVER);
    }
}

private <REQ extends IMessage> void register(Class<?> handler, Class<REQ> msg, Side side) {
    Class<? extends IMessageHandler<REQ, IMessage>> messageHandler = (Class<? extends IMessageHandler<REQ, IMessage>>) handler;
    SimpleNetworkWrapper wrapper = (SimpleNetworkWrapper) helper.getModField();
    int id = helper.getNextIDForMod();
    //System.out.println(msg + " -> " + id);
    wrapper.registerMessage(messageHandler, msg, id, side);
}

public static void registerPacket(CustomPacket packet) {
    if (FMLCommonHandler.instance().getEffectiveSide() == Side.CLIENT) {
        wrapper.registerMessage((Class<? extends IMessageHandler<CustomPacket, IMessage>>) packet.getClass(), (Class<CustomPacket>) packet.getClass(), counter++, Side.CLIENT);
    }
    else {
        wrapper.registerMessage((Class<? extends IMessageHandler<CustomPacket, IMessage>>) packet.getClass(), (Class<CustomPacket>) packet.getClass(), counter++, Side.SERVER);
    }
}

/**
 * Register a packet
 * @param packet the packet to register
 * @param side the side to register the packet for
 * @param id the id of the packet
 */
@SuppressWarnings("unchecked")
public static void register(Class<? extends IPacket> packet, Side side, int id)
{
    Class<? extends Object> clazz = packet;
    INSTANCE.registerMessage((Class<? extends IMessageHandler<IMessage, IMessage>>)clazz, (Class<IMessage>)clazz, id, side);
}

/**
 * This method assumes that the same class is used for both the message and the message handler
 */
@SuppressWarnings("unchecked")
private static <REQ extends IMessage, REPLY extends IMessage> void registerMessage(Class<?> clazz, PacketSide side) {
    if (side == PacketSide.CLIENT || side == PacketSide.BOTH) CHANNEL.registerMessage((Class<? extends IMessageHandler<REQ, REPLY>>) clazz, (Class<REQ>) clazz, descriminator, Side.CLIENT);
    if (side == PacketSide.SERVER || side == PacketSide.BOTH) CHANNEL.registerMessage((Class<? extends IMessageHandler<REQ, REPLY>>) clazz, (Class<REQ>) clazz, descriminator, Side.SERVER);
    descriminator++;
}

private <REQ extends IMessage, REPLY extends IMessage> void registerUniversalMessage( 
        Class<? extends IMessageHandler<REQ, REPLY>> messageHandler, Class<REQ> requestMessageType) {
    network.registerMessage(messageHandler, requestMessageType, discriminator, Side.CLIENT);
    discriminator++;
    network.registerMessage(messageHandler, requestMessageType, discriminator, Side.SERVER);
    discriminator++;
}

private void regMessage(Class<? extends IMessage> message, Side side, Side otherSide) {
    if(otherSide != null) {
        regMessage(message, otherSide);
    }
    if(messageID > 255) {
        System.out.println("Warning: Over 255 messages registered, need another channel");
    } else {
        Class<? extends IMessageHandler<IMessage, IMessage>> messageHandlerClass = (Class<? extends IMessageHandler<IMessage, IMessage>>) message.getDeclaredClasses()[0];
        ZombieTC.network.registerMessage(messageHandlerClass, (Class<IMessage>)message, messageID, side);
        messageID++;
    }
}

public static <REQ extends IMessage, REPLY extends IMessage> void registerMessage(Class<? extends IMessageHandler<REQ, REPLY>> messageHandler, Class<REQ> requestMessageType, Side receivingSide)
{
    INSTANCE.registerMessage(messageHandler, requestMessageType, counter, receivingSide);
    counter++;
}

/** Register a message type with this message handler on this side using the ID. */
public <T extends IMessage & IMessageHandler<T, IMessage>> void register(int id, Side receivingSide, Class<T> messageClass) {
    registerMessage(messageClass, messageClass, id, receivingSide);
}

private <REQ extends IMessage, REPLY extends IMessage> void registerClientMessage( 
        Class<? extends IMessageHandler<REQ, REPLY>> messageHandler, Class<REQ> requestMessageType) {
    network.registerMessage(messageHandler, requestMessageType, discriminator, Side.CLIENT);
    discriminator++;
}

private <REQ extends IMessage, REPLY extends IMessage> void registerServerMessage( 
        Class<? extends IMessageHandler<REQ, REPLY>> messageHandler, Class<REQ> requestMessageType) {
    network.registerMessage(messageHandler, requestMessageType, discriminator, Side.SERVER);
    discriminator++;
}

/**
 * Register a message; Automatic side detection
 * 
 * @param handlerClass
 * @param messageClass
 */
protected final <REQ extends IMessage, REPLY extends IMessage> void registerMessage( Class<? extends IMessageHandler<REQ, REPLY>> handlerClass, Class<REQ> messageClass )
{
  Side side = AbstractClientMessageHandler.class.isAssignableFrom( handlerClass ) ? Side.CLIENT : Side.SERVER;
  dispatcher.registerMessage( handlerClass, messageClass, _mPacketId++, side );
}

/**
 * @param clazz  Class with all the message goodness, must extend MessageAbstract.
 * @param target Side that the message is being sent to.
 */
public <REQ extends IMessage, REPLY extends IMessage> void registerMessage(Class<? extends MessageAbstract<REQ, REPLY>> clazz, Side target) {
    network.registerMessage((Class<? extends IMessageHandler<REQ, REPLY>>) clazz, (Class<REQ>) clazz, discriminator++, target);
}

/**
 * @param clazz  Class with all the message goodness, must extend MessageAbstract.
 * @param target Side that the message is being sent to.
 */
public <REQ extends IMessage, REPLY extends IMessage> void registerMessage(Class<? extends MessageAbstract<REQ, REPLY>> clazz, Side target) {
    network.registerMessage((Class<? extends IMessageHandler<REQ, REPLY>>) clazz, (Class<REQ>) clazz, discriminator++, target);
}