Java ProxyFactory类代码示例

import battlecode.server.proxy.ProxyFactory; //导入依赖的package包/类
public static Server createPipeServer(Config options,
                                      String saveFile) throws IOException {

    Controller controller = ControllerFactory
            .createTCPController(System.in, options);

    List<Proxy> proxies = new LinkedList<Proxy>();

    if (saveFile != null)
        proxies.add(ProxyFactory.createProxyFromFile(saveFile));

    proxies.add(ProxyFactory.createProxy(System.out));

    // since we're sending the match file to System.out, don't send log
    // messages there
    System.setOut(System.err);

    Server server = new Server(options, Server.Mode.TCP, controller,
            proxies.toArray(new Proxy[proxies.size()]));
    controller.addObserver(server);
    return server;
}
 

import battlecode.server.proxy.ProxyFactory; //导入依赖的package包/类
public void dumpFile() {
    try {
        Proxy output = ProxyFactory.createProxyFromFile(filename + ".analyzed");
        output.open();
        for (GameData game : games) {
            game.renormalize();
            for (Object data : game.getOutput()) {
                output.writeObject(data);
            }
        }
        output.close();
    } catch (IOException e) {
        e.printStackTrace();
        System.exit(-2);
    }
}
 

import battlecode.server.proxy.ProxyFactory; //导入依赖的package包/类
/**
 * Initializes a new server.
 *
 * @param options the configuration to use
 * @param interactive whether to wait for notifications to control the
 *                    match run state
 * @param proxyFactories the factories to use to create proxies for each
 *                       game (decoupled enough for you?)
 */
public Server(Config options, boolean interactive, ProxyFactory... proxyFactories) {
    this.gameQueue = new LinkedBlockingQueue<>();
    this.proxyFactories = proxyFactories;

    this.interactive = interactive;

    this.options = options;
    this.state = State.NOT_READY;
}
 

import battlecode.server.proxy.ProxyFactory; //导入依赖的package包/类
public static Server createHeadlessServer(Config options, String saveFile)
        throws IOException {

    Controller controller = ControllerFactory
            .createHeadlessController(options);

    Proxy[] proxies = new Proxy[]{ProxyFactory
            .createProxyFromFile(saveFile)};

    Server server = new Server(options, Server.Mode.HEADLESS, controller,
            proxies);
    controller.addObserver(server);

    return server;
}
 

import battlecode.server.proxy.ProxyFactory; //导入依赖的package包/类
public static Server createLocalServer(Config options, Proxy proxy,
                                       String saveFile) throws IOException {

    Controller controller = ControllerFactory.createLocalController(options, proxy);

    List<Proxy> proxies = new LinkedList<Proxy>();
    if (saveFile != null)
        proxies.add(ProxyFactory.createProxyFromFile(saveFile));

    proxies.add(proxy);

    Server server = new Server(options, Server.Mode.LOCAL, controller,
            proxies.toArray(new Proxy[0]));

    controller.addObserver(server);

    return server;
}
 

import battlecode.server.proxy.ProxyFactory; //导入依赖的package包/类
public static Server createRemoteServer(Config options, int port,
                                        String saveFile) throws IOException {

    RPCServer rpcServer;
    Thread rpcThread;

    final MatchInputFinder finder = new MatchInputFinder();

    // Start a new RPC server for handling match input requests.
    rpcServer = new RPCServer() {
        public Object handler(Object arg) {
            if ("find-match-inputs".equals(arg))
                return finder.findMatchInputsLocally();
            return null;
        }
    };

    // Run it in a new thread.
    rpcThread = new Thread(rpcServer);
    rpcThread.setDaemon(true);
    rpcThread.start();

    // Start a server socket listening on the default port.
    ServerSocket serverSocket = new ServerSocket(port);
    Socket clientSocket = serverSocket.accept();
    // serverSocket.close(); (?)

    Controller controller = ControllerFactory
            .createTCPController(clientSocket.getInputStream(), options);

    List<Proxy> proxies = new LinkedList<Proxy>();

    if (saveFile != null)
        proxies.add(ProxyFactory.createProxyFromFile(saveFile));

    proxies.add(ProxyFactory.createProxy(clientSocket.getOutputStream()));

    Server server = new Server(options, Server.Mode.TCP, controller,
            proxies.toArray(new Proxy[proxies.size()]));
    controller.addObserver(server);
    return server;
}