Thread engineThread = new Thread(
new Runnable() {
public void run() {
+ Transmitter<HedgefishCommand> engineTransmitter = engine.transmitter();
try {
- Transmitter<HedgefishCommand> engineTransmitter = engine.transmitter();
while (engineTransmitter.isActive()) {
if (engineTransmitter.hasCommand()) {
HedgefishCommand command = engineTransmitter.transmitCommand();
CommandDirection.FROM_ENGINE,
null
);
+ engineTransmitter.close();
isRunning = false;
}
}
isActive = false;
}
+ @Override
+ public void close() {
+ queue.clear();
+ }
+
}
private static final String ENGINE_BIN_DIR = Paths.get("bin").toAbsolutePath().toString();
-
public static void main(String... args) throws Exception {
EngineRunner engineRunner = new ExternalEngineRunner(
AcceptorRunner acceptorRunner = new ConsoleAcceptorRunner(); // new AcceptorStubRunner();
Acceptor acceptor = acceptorRunner.init();
- //AcceptorStub acceptor = new AcceptorStub();
CommandExecutor commandExecutor = SyncCommandExecutor.Factory.create(engine, acceptor);
- //acceptor.init(commandExecutor);
engineRunner.run(commandExecutor);
acceptorRunner.run(commandExecutor);
- //acceptor.start();
}
}
*/
public class ConsoleAcceptor implements Acceptor {
- private class ConsoleReceiver implements Receiver<String> {
+ private class ConsoleTransmitter implements Transmitter<String> {
private Scanner scanner;
private boolean isActive;
- ConsoleReceiver(InputStream input) {
+ ConsoleTransmitter(InputStream input) {
scanner = new Scanner(input);
isActive = true;
}
}
@Override
- public String receiveCommand() {
+ public String transmitCommand() {
return scanner.nextLine();
}
@Override
+ public void addCommand(String command) {
+ // not supported for console acceptor
+ }
+
+ @Override
public void stop() {
isActive = false;
}
}
}
- private ConsoleReceiver receiver;
+ private ConsoleTransmitter transmitter;
private PrintWriter writer;
ConsoleAcceptor(InputStream input, OutputStream output) {
- receiver = new ConsoleReceiver(input);
+ transmitter = new ConsoleTransmitter(input);
writer = new PrintWriter(output, true);
}
- public Receiver<String> receiver() {
- return receiver;
+ public Transmitter<String> transmitter() {
+ return transmitter;
}
@Override
@Override
public void terminate(String params) {
- receiver.stop();
+ transmitter.stop();
}
private void console(String name, String params) {
Thread engineThread = new Thread(
new Runnable() {
public void run() {
- Receiver<String> acceptorReceiver = acceptor.receiver();
+ Transmitter<String> acceptorTransmitter = acceptor.transmitter();
try {
- while (acceptorReceiver.isActive()) {
- if (acceptorReceiver.hasCommand()) {
- String command = acceptorReceiver.receiveCommand();
+ while (acceptorTransmitter.isActive()) {
+ if (acceptorTransmitter.hasCommand()) {
+ String command = acceptorTransmitter.transmitCommand();
if (command.isEmpty()) continue;
CommandParams commandParams = new CommandParams(command);
commandExecutor.exec(
commandParams.getParams()
);
if (UCIConstants.QUIT.equals(commandParams.getName()))
- acceptorReceiver.stop();
+ acceptorTransmitter.stop();
}
}
} finally {
- acceptorReceiver.close();
+ acceptorTransmitter.close();
isRunning = false;
}
}
package org.hedgecode.chess.uci;
-import java.io.BufferedWriter;
-import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
/**
* External UCI Engine.
public class ExternalEngine implements Engine {
private static final String COMMAND_FORMAT = "%s %s";
- private static final String CRLF = System.getProperty("line.separator");
- private BufferedWriter engineWriter;
+ private Transmitter<String> transmitter;
+ private PrintWriter engineWriter;
- ExternalEngine(BufferedWriter writer) {
- engineWriter = writer;
+ ExternalEngine(InputStream input, OutputStream output) {
+ transmitter = new ExternalEngineTransmitter(input);
+ engineWriter = new PrintWriter(output, true);
+ }
+
+ public Transmitter<String> transmitter() {
+ return transmitter;
}
private void write(String command) {
- try {
- engineWriter.write(command);
- engineWriter.write(CRLF);
- engineWriter.flush();
- } catch (IOException ignored) {
- }
+ engineWriter.println(command);
}
private String format(String name, String params) {
package org.hedgecode.chess.uci;
-import java.io.BufferedReader;
-import java.io.BufferedWriter;
import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.OutputStream;
-import java.io.OutputStreamWriter;
import java.util.List;
-import java.util.Scanner;
import org.hedgecode.chess.uci.annotation.CommandDirection;
import org.hedgecode.chess.uci.command.CommandParams;
private Process process;
private ProcessBuilder processBuilder;
- private BufferedReader reader;
- private BufferedWriter writer;
+ private ExternalEngine engine;
private boolean isInit = false;
} catch (IOException e) {
throw new EngineException("uci.engine.external.start", e.getLocalizedMessage());
}
- reader = new BufferedReader(
- new InputStreamReader(
- process.getInputStream()
- )
- );
- writer = new BufferedWriter(
- new OutputStreamWriter(
- process.getOutputStream()
- )
+
+ engine = new ExternalEngine(
+ process.getInputStream(),
+ process.getOutputStream()
);
isInit = true;
- return new ExternalEngine(
- writer
- );
+ return engine;
}
@Override
Thread engineThread = new Thread(
new Runnable() {
public void run() {
+ Transmitter<String> engineTransmitter = engine.transmitter();
try {
- Scanner scanner = new Scanner(reader);
- while (scanner.hasNextLine()) {
- String command = scanner.nextLine();
+ while (engineTransmitter.hasCommand()) {
+ String command = engineTransmitter.transmitCommand();
if (command.isEmpty()) continue;
CommandParams commandParams = new CommandParams(command);
commandExecutor.exec(
);
}
} finally {
- try {
- writer.close();
- reader.close();
- } catch (IOException ignored) {
- }
commandExecutor.exec(
UCIConstants.TERMINATE,
CommandDirection.FROM_ENGINE,
null
);
+ engineTransmitter.stop();
+ engineTransmitter.close();
+ if (process.isAlive()) process.destroy();
+ isInit = false;
}
}
}
engineThread.start();
}
- public void run() throws IOException, InterruptedException {
- //Map<String, String> environment = processBuilder.environment();
- Process process = processBuilder.start();
- InputStream is = process.getInputStream();
- BufferedReader br = new BufferedReader(new InputStreamReader(is));
- OutputStream os = process.getOutputStream();
- BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
-
- Thread engineThread = new Thread(
- new Runnable() {
- public void run() {
- Scanner scanner = new Scanner(br); //
- while (scanner.hasNextLine()) {
- System.out.println(scanner.nextLine());
- }
-/*
- String line;
- try {
- while ((line = br.readLine()) != null) {
- System.out.println(line);
- bw.write("isready");
- }
- } catch (IOException e) {
- e.printStackTrace();
- }
-*/
- System.out.println("Engine terminated.");
- }
- }
- );
- engineThread.start();
-
- bw.write("uci\n");
- bw.flush();
- bw.write("isready\n");
- bw.flush();
- bw.write("quit\n");
- bw.flush();
-
- //process.waitFor();
-
- }
-
-
- public static void main(String... args) throws Exception {
-/*
- String[] strings = " uci test one more test".trim().split("\\s+", 2);
- for (String string : strings)
- System.out.println(string);
-*/
-
- new ExternalEngineRunner("stockfish.exe").run();
- }
-
}
--- /dev/null
+/*
+ * Copyright (c) 2018. Developed by Hedgecode.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.hedgecode.chess.uci;
+
+import java.io.InputStream;
+import java.util.Scanner;
+
+/**
+ *
+ *
+ * @author Dmitry Samoshin aka gotty
+ */
+public class ExternalEngineTransmitter implements Transmitter<String> {
+
+ private Scanner scanner;
+ private boolean isActive;
+
+ ExternalEngineTransmitter(InputStream input) {
+ scanner = new Scanner(input);
+ isActive = true;
+ }
+
+ @Override
+ public boolean isActive() {
+ return isActive;
+ }
+
+ @Override
+ public boolean hasCommand() {
+ return isActive && scanner.hasNextLine();
+ }
+
+ @Override
+ public String transmitCommand() {
+ return scanner.nextLine();
+ }
+
+ @Override
+ public void addCommand(String command) {
+ // not supported for external engine
+ }
+
+ @Override
+ public void stop() {
+ isActive = false;
+ }
+
+ @Override
+ public void close() {
+ scanner.close();
+ }
+
+}
+++ /dev/null
-/*
- * Copyright (c) 2018. Developed by Hedgecode.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.hedgecode.chess.uci;
-
-/**
- *
- *
- * @author Dmitry Samoshin aka gotty
- */
-public interface Receiver<T> {
-
- boolean isActive();
-
- boolean hasCommand();
-
- T receiveCommand();
-
- void stop();
-
- void close();
-
-}
void stop();
+ void close();
+
}
git.hedgecode.org / chesshog.git / commitdiff