io.jsync.sockjs.impl.SockJSSocketBase Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of jsync.io Show documentation

jsync.io is a non-blocking, event-driven networking framework for Java

There is a newer version: 1.10.13

/*
 * Copyright (c) 2011-2013 The original author or authors
 * ------------------------------------------------------
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * and Apache License v2.0 which accompanies this distribution.
 *
 *     The Eclipse Public License is available at
 *     http://www.eclipse.org/legal/epl-v10.html
 *
 *     The Apache License v2.0 is available at
 *     http://www.opensource.org/licenses/apache2.0.php
 *
 * You may elect to redistribute this code under either of these licenses.
 */

package io.jsync.sockjs.impl;

import io.jsync.Async;
import io.jsync.Handler;
import io.jsync.buffer.Buffer;
import io.jsync.eventbus.Message;
import io.jsync.sockjs.SockJSSocket;

import java.util.UUID;

public abstract class SockJSSocketBase implements SockJSSocket {

    protected final Async async;
    private final Handler> writeHandler;
    /**
     * When a {@code SockJSSocket} is created it automatically registers an event handler with the event bus, the ID of that
     * handler is given by {@code writeHandlerID}.
     * Given this ID, a different event loop can send a buffer to that event handler using the event bus and
     * that buffer will be received by this instance in its own event loop and written to the underlying socket. This
     * allows you to write data to other sockets which are owned by different event loops.
     */
    private final String writeHandlerID;

    protected SockJSSocketBase(Async async) {
        this.async = async;
        this.writeHandler = new Handler>() {
            public void handle(Message buff) {
                write(buff.body());
            }
        };
        this.writeHandlerID = UUID.randomUUID().toString();
        async.eventBus().registerLocalHandler(writeHandlerID, writeHandler);
    }

    @Override
    public String writeHandlerID() {
        return writeHandlerID;
    }

    @Override
    public void close() {
        async.eventBus().unregisterHandler(writeHandlerID, writeHandler);
    }
}