DefaultServerEndpointConfig.java

package ameba.websocket.internal;

import ameba.websocket.WebSocket;
import ameba.websocket.WebSocketEndpointProvider;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.glassfish.jersey.internal.inject.InjectionManager;
import org.glassfish.jersey.internal.inject.Injections;

import javax.websocket.Decoder;
import javax.websocket.Encoder;
import javax.websocket.Extension;
import javax.websocket.HandshakeResponse;
import javax.websocket.server.HandshakeRequest;
import javax.websocket.server.ServerEndpointConfig;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * <p>DefaultServerEndpointConfig class.</p>
 *
 * @author icode
 * @since 0.1.6e
 *
 */
public class DefaultServerEndpointConfig implements ServerEndpointConfig {

    private String path;
    private List<String> subprotocols;
    private List<Extension> extensions = Lists.newArrayList();
    private List<Class<? extends Encoder>> encoders;
    private List<Class<? extends Decoder>> decoders;
    private Map<String, Object> userProperties = Maps.newConcurrentMap();
    private ServerEndpointConfig.Configurator serverEndpointConfigurator;

    /**
     * <p>Constructor for DefaultServerEndpointConfig.</p>
     *
     * @param manager a manager
     * @param endpointClass  a {@link java.lang.Class} endpoint class.
     * @param webSocketConf  a {@link ameba.websocket.WebSocket} object.
     */
    public DefaultServerEndpointConfig(final InjectionManager manager,
                                       Class endpointClass,
                                       final WebSocket webSocketConf) {
        path = webSocketConf.path();
        subprotocols = Arrays.asList(webSocketConf.subprotocols());
        encoders = Lists.newArrayList(webSocketConf.encoders());
        decoders = Lists.newArrayList(webSocketConf.decoders());
        for (Class<? extends Extension> extensionClass : webSocketConf.extensions()) {
            extensions.add(Injections.getOrCreate(manager, extensionClass));
        }
        final WebSocketEndpointProvider provider = manager.getInstance(WebSocketEndpointProvider.class);

        final EndpointMeta endpointMeta = provider.parseMeta(endpointClass, webSocketConf);

        final ServerEndpointConfig.Configurator cfgr =
                Injections.getOrCreate(manager, webSocketConf.configurator());
        serverEndpointConfigurator = new ServerEndpointConfig.Configurator() {

            @Override
            public String getNegotiatedSubprotocol(List<String> supported, List<String> requested) {
                return cfgr.getNegotiatedSubprotocol(supported, requested);
            }

            @Override
            public List<Extension> getNegotiatedExtensions(List<Extension> installed, List<Extension> requested) {
                return cfgr.getNegotiatedExtensions(installed, requested);
            }

            @Override
            public boolean checkOrigin(String originHeaderValue) {
                return cfgr.checkOrigin(originHeaderValue);
            }

            @Override
            public void modifyHandshake(ServerEndpointConfig sec,
                                        HandshakeRequest request, HandshakeResponse response) {
                cfgr.modifyHandshake(sec, request, response);
            }

            @Override
            public <T> T getEndpointInstance(Class<T> eClass) throws InstantiationException {
                if (EndpointDelegate.class.equals(eClass)) {
                    return eClass.cast(new EndpointDelegate(endpointMeta));
                }
                return cfgr.getEndpointInstance(eClass);
            }
        };
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Class<?> getEndpointClass() {
        return EndpointDelegate.class;
    }

    /** {@inheritDoc} */
    @Override
    public String getPath() {
        return path;
    }

    /** {@inheritDoc} */
    @Override
    public List<String> getSubprotocols() {
        return subprotocols;
    }

    /** {@inheritDoc} */
    @Override
    public List<Extension> getExtensions() {
        return extensions;
    }

    /** {@inheritDoc} */
    @Override
    public ServerEndpointConfig.Configurator getConfigurator() {
        return serverEndpointConfigurator;
    }

    /** {@inheritDoc} */
    @Override
    public List<Class<? extends Encoder>> getEncoders() {
        return encoders;
    }

    /** {@inheritDoc} */
    @Override
    public List<Class<? extends Decoder>> getDecoders() {
        return decoders;
    }

    /** {@inheritDoc} */
    @Override
    public Map<String, Object> getUserProperties() {
        return userProperties;
    }
}