From 4eb06599e2220db67c531bdc85da539c5cac7cfb Mon Sep 17 00:00:00 2001 From: MaximZaitsev Date: Fri, 8 Jul 2016 15:39:51 +0300 Subject: [PATCH] car emulator and corrected srv --- server/.gitignore | 1 + server/carEmulator/carEmulator.iml | 1 + server/carEmulator/src/CarEmulatorMain.kt | 79 ++ server/carEmulator/src/Main.kt | 7 - server/carEmulator/src/ThisCar.kt | 95 ++ server/carEmulator/src/client/Client.kt | 40 + .../carEmulator/src/client/ClientHandler.kt | 62 + .../src/client/ClientInitializer.kt | 19 + .../carEmulator/src/proto/car/ConnectP.java | 1013 ++++++++++++++ .../carEmulator/src/proto/car/LocationP.java | 540 ++++++++ .../carEmulator/src/proto/car/RouteDoneP.java | 496 +++++++ server/carEmulator/src/proto/car/RouteP.java | 1168 +++++++++++++++++ .../src/server/Handler.kt} | 56 +- server/carEmulator/src/server/Initializer.kt | 29 + server/src/Main.kt | 23 - server/src/ServerMain.kt | 116 ++ server/src/car/client/Client.kt | 40 + server/src/car/client/ClientHandler.kt | 60 + server/src/car/client/ClientInitializer.kt | 19 + server/src/car/server/Handler.kt | 95 ++ server/src/car/server/Initializer.kt | 31 + server/src/objects/Car.kt | 18 +- server/src/objects/Environment.kt | 19 + server/src/server/Server.kt | 44 - server/src/web/server/Handler.kt | 45 + .../server/Initializer.kt} | 11 +- 26 files changed, 4016 insertions(+), 111 deletions(-) create mode 100644 server/carEmulator/src/CarEmulatorMain.kt delete mode 100644 server/carEmulator/src/Main.kt create mode 100644 server/carEmulator/src/ThisCar.kt create mode 100644 server/carEmulator/src/client/Client.kt create mode 100644 server/carEmulator/src/client/ClientHandler.kt create mode 100644 server/carEmulator/src/client/ClientInitializer.kt create mode 100644 server/carEmulator/src/proto/car/ConnectP.java create mode 100644 server/carEmulator/src/proto/car/LocationP.java create mode 100644 server/carEmulator/src/proto/car/RouteDoneP.java create mode 100644 server/carEmulator/src/proto/car/RouteP.java rename server/{src/server/ServerHandler.kt => carEmulator/src/server/Handler.kt} (58%) create mode 100644 server/carEmulator/src/server/Initializer.kt delete mode 100644 server/src/Main.kt create mode 100644 server/src/ServerMain.kt create mode 100644 server/src/car/client/Client.kt create mode 100644 server/src/car/client/ClientHandler.kt create mode 100644 server/src/car/client/ClientInitializer.kt create mode 100644 server/src/car/server/Handler.kt create mode 100644 server/src/car/server/Initializer.kt delete mode 100644 server/src/server/Server.kt create mode 100644 server/src/web/server/Handler.kt rename server/src/{server/ServerInitializer.kt => web/server/Initializer.kt} (76%) diff --git a/server/.gitignore b/server/.gitignore index d2c8ad3ba66..fa32461bd48 100644 --- a/server/.gitignore +++ b/server/.gitignore @@ -1,2 +1,3 @@ .idea/workspace.xml +.idea/uiDesigner.xml out diff --git a/server/carEmulator/carEmulator.iml b/server/carEmulator/carEmulator.iml index dc2bad21409..a1e5a5a5b41 100644 --- a/server/carEmulator/carEmulator.iml +++ b/server/carEmulator/carEmulator.iml @@ -9,5 +9,6 @@ + \ No newline at end of file diff --git a/server/carEmulator/src/CarEmulatorMain.kt b/server/carEmulator/src/CarEmulatorMain.kt new file mode 100644 index 00000000000..ac1fdae496b --- /dev/null +++ b/server/carEmulator/src/CarEmulatorMain.kt @@ -0,0 +1,79 @@ +import client.Client +import io.netty.bootstrap.ServerBootstrap +import io.netty.buffer.Unpooled +import io.netty.channel.nio.NioEventLoopGroup +import io.netty.channel.socket.nio.NioServerSocketChannel +import io.netty.handler.codec.http.* +import proto.car.ConnectP +import proto.car.RouteDoneP +import server.Initializer +import java.util.* +import kotlin.concurrent.thread + +/** + * Created by user on 7/6/16. + */ + + +val serverHost = "127.0.0.1" +val serverPort = 7925 +val carHost = "127.0.0.1" + +val getLocationUrl = "getLocation" +val routeDoneUrl = "routeDone" +val setRouteUrl = "route" +val connectUrl = "connect" + +fun main(args: Array) { + val port = Random().nextInt(10000) + 10000 + println("car started on port $port") + + val serverCarThread = thread { + val bossGroup = NioEventLoopGroup(1) + val workerGroup = NioEventLoopGroup() + val b = ServerBootstrap() + b.group(bossGroup, workerGroup) + .channel(NioServerSocketChannel().javaClass) + .childHandler(Initializer()) + + try { + val channel = b.bind(port).sync().channel() + channel.closeFuture().sync() + } catch (e: InterruptedException) { + println("car server stoped!") + e.printStackTrace() + } finally { + bossGroup.shutdownGracefully() + workerGroup.shutdownGracefully() + } + } + //connect + val connect = ConnectP.ConnectionRequest.newBuilder().setIp(carHost).setPort(port).build() + val request = DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, connectUrl, Unpooled.copiedBuffer(connect.toByteArray())) + request.headers().set(HttpHeaderNames.HOST, serverHost) + request.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE) + request.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, request.content().readableBytes()) + + Client.sendRequest(request, serverHost, serverPort) + + val car = ThisCar.instance + var lastTime: Long = System.currentTimeMillis() + while (true) { + val deltaTimeMs = (System.currentTimeMillis() - lastTime) + if (deltaTimeMs > 50) { + if (!car.pathDone) { + println(car) + } + var pathDone = car.move(deltaTimeMs.toDouble()/ 1000) + if (pathDone) { + val routeDone = RouteDoneP.RouteDone.newBuilder().setUid(car.id).build() + val pathDoneRequest = DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, setRouteUrl, Unpooled.copiedBuffer(routeDone.toByteArray())) + pathDoneRequest.headers().set(HttpHeaderNames.HOST, serverHost) + pathDoneRequest.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE) + pathDoneRequest.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, pathDoneRequest.content().readableBytes()) + Client.sendRequest(pathDoneRequest, serverHost, serverPort) + } + lastTime = System.currentTimeMillis() + } + } +} diff --git a/server/carEmulator/src/Main.kt b/server/carEmulator/src/Main.kt deleted file mode 100644 index bcb73dc4216..00000000000 --- a/server/carEmulator/src/Main.kt +++ /dev/null @@ -1,7 +0,0 @@ -/** - * Created by user on 7/6/16. - */ - -fun main(args: Array) { - println("test") -} diff --git a/server/carEmulator/src/ThisCar.kt b/server/carEmulator/src/ThisCar.kt new file mode 100644 index 00000000000..574efe31581 --- /dev/null +++ b/server/carEmulator/src/ThisCar.kt @@ -0,0 +1,95 @@ +import client.Client +import io.netty.buffer.Unpooled +import io.netty.handler.codec.http.* +import proto.car.RouteDoneP +import proto.car.RouteP.Route.WayPoint + +/** + * Created by user on 7/8/16. + */ +class ThisCar private constructor() { + + var id = "" + + + //metr + var x: Double = 0.toDouble() + var y: Double = 0.toDouble() + + //Degree + var angle: Double = 0.toDouble();//0 - положительное направление по OX + + val velocityMove: Double = 0.1//metr/sec + val velocityRotation: Double = 10.toDouble()//Degree/sec + + val wayPoints: MutableList = mutableListOf() + var nextWayPointIndex = 0 + var pathDone = true + + var distanceToNext: Double = 0.toDouble() + var angleToNext: Double = 0.toDouble() + var anglePositive = true//true - поворот по часовой, false - против + + companion object { + + val instance = ThisCar() + } + + + @Synchronized + fun move(deltaTime: Double) :Boolean { + if (pathDone) { + //маршрут не задан и сервер "в курсе", что маршрут пройден + return false; + } + if (distanceToNext > 0 || angleToNext > 0) { + if (angleToNext > 0) { + //поворачиваемся + val angleDelta: Double = velocityRotation * deltaTime + + angle += (if (anglePositive) 1 else -1) * angleDelta + angleToNext -= angleDelta + if (angleToNext < 0) { + angleToNext = 0.toDouble() + } + } else { + //машинка повернута в нужную сторону, можно ехать + var xDelta = deltaTime * velocityMove * Math.cos(angle * Math.PI / 180) + var yDelta = deltaTime * velocityMove * Math.sin(angle * Math.PI / 180) + x += xDelta + y += yDelta + distanceToNext -= deltaTime * velocityMove + if (distanceToNext < 0) { + distanceToNext = 0.toDouble() + } + } + } else if (nextWayPointIndex == wayPoints.size) { + pathDone = true + return true; + } else { + val wayPoint = wayPoints.get(nextWayPointIndex) + angleToNext = Math.abs(wayPoint.angleDelta) + distanceToNext = Math.abs(wayPoint.distance)//задний ход пока отключаем:) + anglePositive = (wayPoint.angleDelta > 0) + nextWayPointIndex++ + } + return false; + + + } + + @Synchronized + fun setPath(wayPoints: List) { + println("in set path") + this.pathDone = false + distanceToNext = 0.toDouble() + angleToNext = 0.toDouble() + nextWayPointIndex = 0 + this.wayPoints.clear() + this.wayPoints.addAll(wayPoints) + } + + override fun toString(): String { + return "x:$x; y:$y; angle:$angle" + } +} diff --git a/server/carEmulator/src/client/Client.kt b/server/carEmulator/src/client/Client.kt new file mode 100644 index 00000000000..7f766062aba --- /dev/null +++ b/server/carEmulator/src/client/Client.kt @@ -0,0 +1,40 @@ +package client + +import io.netty.bootstrap.Bootstrap +import io.netty.channel.ChannelInitializer +import io.netty.channel.nio.NioEventLoopGroup +import io.netty.channel.socket.SocketChannel +import io.netty.channel.socket.nio.NioSocketChannel +import io.netty.handler.codec.http.HttpRequest +import io.netty.util.AttributeKey + +/** + * Created by user on 7/8/16. + */ +object Client { + + val bootstrap: Bootstrap = makeBootstrap() + + private fun makeBootstrap(): Bootstrap { + val group = NioEventLoopGroup(); + val b = Bootstrap(); + b.group(group).channel(NioSocketChannel().javaClass).handler(ClientInitializer()) + .attr(AttributeKey.newInstance("url"), "") + .attr(AttributeKey.newInstance("uid"), "") + return b + } + + fun sendRequest(request: HttpRequest, host: String, port: Int) { + try { + bootstrap.attr(AttributeKey.valueOf("url"), request.uri()) + // bootstrap.attr(AttributeKey.valueOf("uid"), carUid) + val ch = bootstrap.connect(host, port).sync().channel() + ch.writeAndFlush(request) + ch.closeFuture().sync()//wait for answer + // val handler: ClientHandler = ch.pipeline().get(ClientHandler().javaClass) + } catch (e: InterruptedException) { + + } + } + +} \ No newline at end of file diff --git a/server/carEmulator/src/client/ClientHandler.kt b/server/carEmulator/src/client/ClientHandler.kt new file mode 100644 index 00000000000..e93b6cfce15 --- /dev/null +++ b/server/carEmulator/src/client/ClientHandler.kt @@ -0,0 +1,62 @@ +package client + +import com.google.protobuf.InvalidProtocolBufferException +import connectUrl +import io.netty.channel.ChannelHandlerContext +import io.netty.channel.SimpleChannelInboundHandler +import io.netty.handler.codec.http.DefaultHttpContent +import io.netty.handler.codec.http.HttpContent +import io.netty.handler.codec.http.HttpRequest +import io.netty.handler.codec.http.HttpResponse +import io.netty.util.AttributeKey +import proto.car.ConnectP + +/** + * Created by user on 7/8/16. + */ +class ClientHandler : SimpleChannelInboundHandler { + + constructor() + + var url: String = "" + var contentBytes: ByteArray = ByteArray(0); + + + override fun channelReadComplete(ctx: ChannelHandlerContext) { + + val url = ctx.channel().attr(AttributeKey.valueOf("url")).get() + + when (url) { + connectUrl -> { + try { + val uid = ConnectP.ConnectionResponse.parseFrom(contentBytes).uid + synchronized(ThisCar.instance, { + ThisCar.instance.id = uid; + }) + } catch (e: InvalidProtocolBufferException) { + e.printStackTrace() + } + } + else -> { + //todo error + } + } + ctx.close() + } + + override fun channelRead(ctx: ChannelHandlerContext?, msg: Any?) { + super.channelRead(ctx, msg) + } + + override fun channelRead0(ctx: ChannelHandlerContext?, msg: Any?) { + if (msg is HttpResponse) { + // this.url = msg.uri() + } + + if (msg is HttpContent) { + val contentsBytes = msg.content(); + contentBytes = ByteArray(contentsBytes.capacity()) + contentsBytes.readBytes(contentBytes) + } + } +} \ No newline at end of file diff --git a/server/carEmulator/src/client/ClientInitializer.kt b/server/carEmulator/src/client/ClientInitializer.kt new file mode 100644 index 00000000000..9110caba152 --- /dev/null +++ b/server/carEmulator/src/client/ClientInitializer.kt @@ -0,0 +1,19 @@ +package client + +import io.netty.channel.ChannelInitializer +import io.netty.channel.socket.SocketChannel +import io.netty.handler.codec.http.HttpClientCodec + +/** + * Created by user on 7/8/16. + */ +class ClientInitializer : ChannelInitializer { + + constructor() + + override fun initChannel(ch: SocketChannel) { + val p = ch.pipeline() + p.addLast(HttpClientCodec()) + p.addLast(ClientHandler()) + } +} \ No newline at end of file diff --git a/server/carEmulator/src/proto/car/ConnectP.java b/server/carEmulator/src/proto/car/ConnectP.java new file mode 100644 index 00000000000..f4b42e29bbb --- /dev/null +++ b/server/carEmulator/src/proto/car/ConnectP.java @@ -0,0 +1,1013 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: connect.proto + +package proto.car; + +public final class ConnectP { + private ConnectP() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + } + public interface ConnectionRequestOrBuilder extends + // @@protoc_insertion_point(interface_extends:carkot.ConnectionRequest) + com.google.protobuf.MessageOrBuilder { + + /** + * optional string ip = 1; + */ + java.lang.String getIp(); + /** + * optional string ip = 1; + */ + com.google.protobuf.ByteString + getIpBytes(); + + /** + * optional int32 port = 2; + */ + int getPort(); + } + /** + * Protobuf type {@code carkot.ConnectionRequest} + */ + public static final class ConnectionRequest extends + com.google.protobuf.GeneratedMessage implements + // @@protoc_insertion_point(message_implements:carkot.ConnectionRequest) + ConnectionRequestOrBuilder { + // Use ConnectionRequest.newBuilder() to construct. + private ConnectionRequest(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + } + private ConnectionRequest() { + ip_ = ""; + port_ = 0; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private ConnectionRequest( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + + ip_ = s; + break; + } + case 16: { + + port_ = input.readInt32(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return proto.car.ConnectP.internal_static_carkot_ConnectionRequest_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return proto.car.ConnectP.internal_static_carkot_ConnectionRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + proto.car.ConnectP.ConnectionRequest.class, proto.car.ConnectP.ConnectionRequest.Builder.class); + } + + public static final int IP_FIELD_NUMBER = 1; + private volatile java.lang.Object ip_; + /** + * optional string ip = 1; + */ + public java.lang.String getIp() { + java.lang.Object ref = ip_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + ip_ = s; + return s; + } + } + /** + * optional string ip = 1; + */ + public com.google.protobuf.ByteString + getIpBytes() { + java.lang.Object ref = ip_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + ip_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int PORT_FIELD_NUMBER = 2; + private int port_; + /** + * optional int32 port = 2; + */ + public int getPort() { + return port_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!getIpBytes().isEmpty()) { + com.google.protobuf.GeneratedMessage.writeString(output, 1, ip_); + } + if (port_ != 0) { + output.writeInt32(2, port_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!getIpBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessage.computeStringSize(1, ip_); + } + if (port_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, port_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + public static proto.car.ConnectP.ConnectionRequest parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static proto.car.ConnectP.ConnectionRequest parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static proto.car.ConnectP.ConnectionRequest parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static proto.car.ConnectP.ConnectionRequest parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static proto.car.ConnectP.ConnectionRequest parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input); + } + public static proto.car.ConnectP.ConnectionRequest parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static proto.car.ConnectP.ConnectionRequest parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseDelimitedWithIOException(PARSER, input); + } + public static proto.car.ConnectP.ConnectionRequest parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static proto.car.ConnectP.ConnectionRequest parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input); + } + public static proto.car.ConnectP.ConnectionRequest parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(proto.car.ConnectP.ConnectionRequest prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code carkot.ConnectionRequest} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder implements + // @@protoc_insertion_point(builder_implements:carkot.ConnectionRequest) + proto.car.ConnectP.ConnectionRequestOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return proto.car.ConnectP.internal_static_carkot_ConnectionRequest_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return proto.car.ConnectP.internal_static_carkot_ConnectionRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + proto.car.ConnectP.ConnectionRequest.class, proto.car.ConnectP.ConnectionRequest.Builder.class); + } + + // Construct using proto.car.ConnectP.ConnectionRequest.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + ip_ = ""; + + port_ = 0; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return proto.car.ConnectP.internal_static_carkot_ConnectionRequest_descriptor; + } + + public proto.car.ConnectP.ConnectionRequest getDefaultInstanceForType() { + return proto.car.ConnectP.ConnectionRequest.getDefaultInstance(); + } + + public proto.car.ConnectP.ConnectionRequest build() { + proto.car.ConnectP.ConnectionRequest result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public proto.car.ConnectP.ConnectionRequest buildPartial() { + proto.car.ConnectP.ConnectionRequest result = new proto.car.ConnectP.ConnectionRequest(this); + result.ip_ = ip_; + result.port_ = port_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof proto.car.ConnectP.ConnectionRequest) { + return mergeFrom((proto.car.ConnectP.ConnectionRequest)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(proto.car.ConnectP.ConnectionRequest other) { + if (other == proto.car.ConnectP.ConnectionRequest.getDefaultInstance()) return this; + if (!other.getIp().isEmpty()) { + ip_ = other.ip_; + onChanged(); + } + if (other.getPort() != 0) { + setPort(other.getPort()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + proto.car.ConnectP.ConnectionRequest parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (proto.car.ConnectP.ConnectionRequest) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private java.lang.Object ip_ = ""; + /** + * optional string ip = 1; + */ + public java.lang.String getIp() { + java.lang.Object ref = ip_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + ip_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string ip = 1; + */ + public com.google.protobuf.ByteString + getIpBytes() { + java.lang.Object ref = ip_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + ip_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string ip = 1; + */ + public Builder setIp( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + ip_ = value; + onChanged(); + return this; + } + /** + * optional string ip = 1; + */ + public Builder clearIp() { + + ip_ = getDefaultInstance().getIp(); + onChanged(); + return this; + } + /** + * optional string ip = 1; + */ + public Builder setIpBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + ip_ = value; + onChanged(); + return this; + } + + private int port_ ; + /** + * optional int32 port = 2; + */ + public int getPort() { + return port_; + } + /** + * optional int32 port = 2; + */ + public Builder setPort(int value) { + + port_ = value; + onChanged(); + return this; + } + /** + * optional int32 port = 2; + */ + public Builder clearPort() { + + port_ = 0; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:carkot.ConnectionRequest) + } + + // @@protoc_insertion_point(class_scope:carkot.ConnectionRequest) + private static final proto.car.ConnectP.ConnectionRequest DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new proto.car.ConnectP.ConnectionRequest(); + } + + public static proto.car.ConnectP.ConnectionRequest getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public ConnectionRequest parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new ConnectionRequest(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public proto.car.ConnectP.ConnectionRequest getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ConnectionResponseOrBuilder extends + // @@protoc_insertion_point(interface_extends:carkot.ConnectionResponse) + com.google.protobuf.MessageOrBuilder { + + /** + * optional string uid = 1; + */ + java.lang.String getUid(); + /** + * optional string uid = 1; + */ + com.google.protobuf.ByteString + getUidBytes(); + } + /** + * Protobuf type {@code carkot.ConnectionResponse} + */ + public static final class ConnectionResponse extends + com.google.protobuf.GeneratedMessage implements + // @@protoc_insertion_point(message_implements:carkot.ConnectionResponse) + ConnectionResponseOrBuilder { + // Use ConnectionResponse.newBuilder() to construct. + private ConnectionResponse(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + } + private ConnectionResponse() { + uid_ = ""; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private ConnectionResponse( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + + uid_ = s; + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return proto.car.ConnectP.internal_static_carkot_ConnectionResponse_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return proto.car.ConnectP.internal_static_carkot_ConnectionResponse_fieldAccessorTable + .ensureFieldAccessorsInitialized( + proto.car.ConnectP.ConnectionResponse.class, proto.car.ConnectP.ConnectionResponse.Builder.class); + } + + public static final int UID_FIELD_NUMBER = 1; + private volatile java.lang.Object uid_; + /** + * optional string uid = 1; + */ + public java.lang.String getUid() { + java.lang.Object ref = uid_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + uid_ = s; + return s; + } + } + /** + * optional string uid = 1; + */ + public com.google.protobuf.ByteString + getUidBytes() { + java.lang.Object ref = uid_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + uid_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!getUidBytes().isEmpty()) { + com.google.protobuf.GeneratedMessage.writeString(output, 1, uid_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!getUidBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessage.computeStringSize(1, uid_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + public static proto.car.ConnectP.ConnectionResponse parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static proto.car.ConnectP.ConnectionResponse parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static proto.car.ConnectP.ConnectionResponse parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static proto.car.ConnectP.ConnectionResponse parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static proto.car.ConnectP.ConnectionResponse parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input); + } + public static proto.car.ConnectP.ConnectionResponse parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static proto.car.ConnectP.ConnectionResponse parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseDelimitedWithIOException(PARSER, input); + } + public static proto.car.ConnectP.ConnectionResponse parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static proto.car.ConnectP.ConnectionResponse parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input); + } + public static proto.car.ConnectP.ConnectionResponse parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(proto.car.ConnectP.ConnectionResponse prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code carkot.ConnectionResponse} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder implements + // @@protoc_insertion_point(builder_implements:carkot.ConnectionResponse) + proto.car.ConnectP.ConnectionResponseOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return proto.car.ConnectP.internal_static_carkot_ConnectionResponse_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return proto.car.ConnectP.internal_static_carkot_ConnectionResponse_fieldAccessorTable + .ensureFieldAccessorsInitialized( + proto.car.ConnectP.ConnectionResponse.class, proto.car.ConnectP.ConnectionResponse.Builder.class); + } + + // Construct using proto.car.ConnectP.ConnectionResponse.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + uid_ = ""; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return proto.car.ConnectP.internal_static_carkot_ConnectionResponse_descriptor; + } + + public proto.car.ConnectP.ConnectionResponse getDefaultInstanceForType() { + return proto.car.ConnectP.ConnectionResponse.getDefaultInstance(); + } + + public proto.car.ConnectP.ConnectionResponse build() { + proto.car.ConnectP.ConnectionResponse result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public proto.car.ConnectP.ConnectionResponse buildPartial() { + proto.car.ConnectP.ConnectionResponse result = new proto.car.ConnectP.ConnectionResponse(this); + result.uid_ = uid_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof proto.car.ConnectP.ConnectionResponse) { + return mergeFrom((proto.car.ConnectP.ConnectionResponse)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(proto.car.ConnectP.ConnectionResponse other) { + if (other == proto.car.ConnectP.ConnectionResponse.getDefaultInstance()) return this; + if (!other.getUid().isEmpty()) { + uid_ = other.uid_; + onChanged(); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + proto.car.ConnectP.ConnectionResponse parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (proto.car.ConnectP.ConnectionResponse) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private java.lang.Object uid_ = ""; + /** + * optional string uid = 1; + */ + public java.lang.String getUid() { + java.lang.Object ref = uid_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + uid_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string uid = 1; + */ + public com.google.protobuf.ByteString + getUidBytes() { + java.lang.Object ref = uid_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + uid_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string uid = 1; + */ + public Builder setUid( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + uid_ = value; + onChanged(); + return this; + } + /** + * optional string uid = 1; + */ + public Builder clearUid() { + + uid_ = getDefaultInstance().getUid(); + onChanged(); + return this; + } + /** + * optional string uid = 1; + */ + public Builder setUidBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + uid_ = value; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:carkot.ConnectionResponse) + } + + // @@protoc_insertion_point(class_scope:carkot.ConnectionResponse) + private static final proto.car.ConnectP.ConnectionResponse DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new proto.car.ConnectP.ConnectionResponse(); + } + + public static proto.car.ConnectP.ConnectionResponse getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public ConnectionResponse parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new ConnectionResponse(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public proto.car.ConnectP.ConnectionResponse getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_carkot_ConnectionRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_carkot_ConnectionRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_carkot_ConnectionResponse_descriptor; + private static final + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_carkot_ConnectionResponse_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\rconnect.proto\022\006carkot\"-\n\021ConnectionReq" + + "uest\022\n\n\002ip\030\001 \001(\t\022\014\n\004port\030\002 \001(\005\"!\n\022Connec" + + "tionResponse\022\013\n\003uid\030\001 \001(\tB\025\n\tproto.carB\010" + + "ConnectPb\006proto3" + }; + com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = + new com.google.protobuf.Descriptors.FileDescriptor. InternalDescriptorAssigner() { + public com.google.protobuf.ExtensionRegistry assignDescriptors( + com.google.protobuf.Descriptors.FileDescriptor root) { + descriptor = root; + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + }, assigner); + internal_static_carkot_ConnectionRequest_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_carkot_ConnectionRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_carkot_ConnectionRequest_descriptor, + new java.lang.String[] { "Ip", "Port", }); + internal_static_carkot_ConnectionResponse_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_carkot_ConnectionResponse_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_carkot_ConnectionResponse_descriptor, + new java.lang.String[] { "Uid", }); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/server/carEmulator/src/proto/car/LocationP.java b/server/carEmulator/src/proto/car/LocationP.java new file mode 100644 index 00000000000..1a7c61d8a9d --- /dev/null +++ b/server/carEmulator/src/proto/car/LocationP.java @@ -0,0 +1,540 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: location.proto + +package proto.car; + +public final class LocationP { + private LocationP() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + } + public interface LocationOrBuilder extends + // @@protoc_insertion_point(interface_extends:carkot.Location) + com.google.protobuf.MessageOrBuilder { + + /** + * optional double x = 1; + */ + double getX(); + + /** + * optional double y = 2; + */ + double getY(); + + /** + * optional double angle = 3; + */ + double getAngle(); + } + /** + * Protobuf type {@code carkot.Location} + */ + public static final class Location extends + com.google.protobuf.GeneratedMessage implements + // @@protoc_insertion_point(message_implements:carkot.Location) + LocationOrBuilder { + // Use Location.newBuilder() to construct. + private Location(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + } + private Location() { + x_ = 0D; + y_ = 0D; + angle_ = 0D; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Location( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 9: { + + x_ = input.readDouble(); + break; + } + case 17: { + + y_ = input.readDouble(); + break; + } + case 25: { + + angle_ = input.readDouble(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return proto.car.LocationP.internal_static_carkot_Location_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return proto.car.LocationP.internal_static_carkot_Location_fieldAccessorTable + .ensureFieldAccessorsInitialized( + proto.car.LocationP.Location.class, proto.car.LocationP.Location.Builder.class); + } + + public static final int X_FIELD_NUMBER = 1; + private double x_; + /** + * optional double x = 1; + */ + public double getX() { + return x_; + } + + public static final int Y_FIELD_NUMBER = 2; + private double y_; + /** + * optional double y = 2; + */ + public double getY() { + return y_; + } + + public static final int ANGLE_FIELD_NUMBER = 3; + private double angle_; + /** + * optional double angle = 3; + */ + public double getAngle() { + return angle_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (x_ != 0D) { + output.writeDouble(1, x_); + } + if (y_ != 0D) { + output.writeDouble(2, y_); + } + if (angle_ != 0D) { + output.writeDouble(3, angle_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (x_ != 0D) { + size += com.google.protobuf.CodedOutputStream + .computeDoubleSize(1, x_); + } + if (y_ != 0D) { + size += com.google.protobuf.CodedOutputStream + .computeDoubleSize(2, y_); + } + if (angle_ != 0D) { + size += com.google.protobuf.CodedOutputStream + .computeDoubleSize(3, angle_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + public static proto.car.LocationP.Location parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static proto.car.LocationP.Location parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static proto.car.LocationP.Location parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static proto.car.LocationP.Location parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static proto.car.LocationP.Location parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input); + } + public static proto.car.LocationP.Location parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static proto.car.LocationP.Location parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseDelimitedWithIOException(PARSER, input); + } + public static proto.car.LocationP.Location parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static proto.car.LocationP.Location parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input); + } + public static proto.car.LocationP.Location parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(proto.car.LocationP.Location prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code carkot.Location} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder implements + // @@protoc_insertion_point(builder_implements:carkot.Location) + proto.car.LocationP.LocationOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return proto.car.LocationP.internal_static_carkot_Location_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return proto.car.LocationP.internal_static_carkot_Location_fieldAccessorTable + .ensureFieldAccessorsInitialized( + proto.car.LocationP.Location.class, proto.car.LocationP.Location.Builder.class); + } + + // Construct using proto.car.LocationP.Location.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + x_ = 0D; + + y_ = 0D; + + angle_ = 0D; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return proto.car.LocationP.internal_static_carkot_Location_descriptor; + } + + public proto.car.LocationP.Location getDefaultInstanceForType() { + return proto.car.LocationP.Location.getDefaultInstance(); + } + + public proto.car.LocationP.Location build() { + proto.car.LocationP.Location result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public proto.car.LocationP.Location buildPartial() { + proto.car.LocationP.Location result = new proto.car.LocationP.Location(this); + result.x_ = x_; + result.y_ = y_; + result.angle_ = angle_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof proto.car.LocationP.Location) { + return mergeFrom((proto.car.LocationP.Location)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(proto.car.LocationP.Location other) { + if (other == proto.car.LocationP.Location.getDefaultInstance()) return this; + if (other.getX() != 0D) { + setX(other.getX()); + } + if (other.getY() != 0D) { + setY(other.getY()); + } + if (other.getAngle() != 0D) { + setAngle(other.getAngle()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + proto.car.LocationP.Location parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (proto.car.LocationP.Location) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private double x_ ; + /** + * optional double x = 1; + */ + public double getX() { + return x_; + } + /** + * optional double x = 1; + */ + public Builder setX(double value) { + + x_ = value; + onChanged(); + return this; + } + /** + * optional double x = 1; + */ + public Builder clearX() { + + x_ = 0D; + onChanged(); + return this; + } + + private double y_ ; + /** + * optional double y = 2; + */ + public double getY() { + return y_; + } + /** + * optional double y = 2; + */ + public Builder setY(double value) { + + y_ = value; + onChanged(); + return this; + } + /** + * optional double y = 2; + */ + public Builder clearY() { + + y_ = 0D; + onChanged(); + return this; + } + + private double angle_ ; + /** + * optional double angle = 3; + */ + public double getAngle() { + return angle_; + } + /** + * optional double angle = 3; + */ + public Builder setAngle(double value) { + + angle_ = value; + onChanged(); + return this; + } + /** + * optional double angle = 3; + */ + public Builder clearAngle() { + + angle_ = 0D; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:carkot.Location) + } + + // @@protoc_insertion_point(class_scope:carkot.Location) + private static final proto.car.LocationP.Location DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new proto.car.LocationP.Location(); + } + + public static proto.car.LocationP.Location getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Location parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Location(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public proto.car.LocationP.Location getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_carkot_Location_descriptor; + private static final + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_carkot_Location_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\016location.proto\022\006carkot\"/\n\010Location\022\t\n\001" + + "x\030\001 \001(\001\022\t\n\001y\030\002 \001(\001\022\r\n\005angle\030\003 \001(\001B\026\n\tpro" + + "to.carB\tLocationPb\006proto3" + }; + com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = + new com.google.protobuf.Descriptors.FileDescriptor. InternalDescriptorAssigner() { + public com.google.protobuf.ExtensionRegistry assignDescriptors( + com.google.protobuf.Descriptors.FileDescriptor root) { + descriptor = root; + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + }, assigner); + internal_static_carkot_Location_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_carkot_Location_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_carkot_Location_descriptor, + new java.lang.String[] { "X", "Y", "Angle", }); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/server/carEmulator/src/proto/car/RouteDoneP.java b/server/carEmulator/src/proto/car/RouteDoneP.java new file mode 100644 index 00000000000..36e630de8b5 --- /dev/null +++ b/server/carEmulator/src/proto/car/RouteDoneP.java @@ -0,0 +1,496 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: routeDone.proto + +package proto.car; + +public final class RouteDoneP { + private RouteDoneP() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + } + public interface RouteDoneOrBuilder extends + // @@protoc_insertion_point(interface_extends:carkot.RouteDone) + com.google.protobuf.MessageOrBuilder { + + /** + * optional string uid = 1; + */ + java.lang.String getUid(); + /** + * optional string uid = 1; + */ + com.google.protobuf.ByteString + getUidBytes(); + } + /** + * Protobuf type {@code carkot.RouteDone} + */ + public static final class RouteDone extends + com.google.protobuf.GeneratedMessage implements + // @@protoc_insertion_point(message_implements:carkot.RouteDone) + RouteDoneOrBuilder { + // Use RouteDone.newBuilder() to construct. + private RouteDone(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + } + private RouteDone() { + uid_ = ""; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private RouteDone( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + + uid_ = s; + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return proto.car.RouteDoneP.internal_static_carkot_RouteDone_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return proto.car.RouteDoneP.internal_static_carkot_RouteDone_fieldAccessorTable + .ensureFieldAccessorsInitialized( + proto.car.RouteDoneP.RouteDone.class, proto.car.RouteDoneP.RouteDone.Builder.class); + } + + public static final int UID_FIELD_NUMBER = 1; + private volatile java.lang.Object uid_; + /** + * optional string uid = 1; + */ + public java.lang.String getUid() { + java.lang.Object ref = uid_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + uid_ = s; + return s; + } + } + /** + * optional string uid = 1; + */ + public com.google.protobuf.ByteString + getUidBytes() { + java.lang.Object ref = uid_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + uid_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!getUidBytes().isEmpty()) { + com.google.protobuf.GeneratedMessage.writeString(output, 1, uid_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!getUidBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessage.computeStringSize(1, uid_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + public static proto.car.RouteDoneP.RouteDone parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static proto.car.RouteDoneP.RouteDone parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static proto.car.RouteDoneP.RouteDone parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static proto.car.RouteDoneP.RouteDone parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static proto.car.RouteDoneP.RouteDone parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input); + } + public static proto.car.RouteDoneP.RouteDone parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static proto.car.RouteDoneP.RouteDone parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseDelimitedWithIOException(PARSER, input); + } + public static proto.car.RouteDoneP.RouteDone parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static proto.car.RouteDoneP.RouteDone parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input); + } + public static proto.car.RouteDoneP.RouteDone parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(proto.car.RouteDoneP.RouteDone prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code carkot.RouteDone} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder implements + // @@protoc_insertion_point(builder_implements:carkot.RouteDone) + proto.car.RouteDoneP.RouteDoneOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return proto.car.RouteDoneP.internal_static_carkot_RouteDone_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return proto.car.RouteDoneP.internal_static_carkot_RouteDone_fieldAccessorTable + .ensureFieldAccessorsInitialized( + proto.car.RouteDoneP.RouteDone.class, proto.car.RouteDoneP.RouteDone.Builder.class); + } + + // Construct using proto.car.RouteDoneP.RouteDone.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + uid_ = ""; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return proto.car.RouteDoneP.internal_static_carkot_RouteDone_descriptor; + } + + public proto.car.RouteDoneP.RouteDone getDefaultInstanceForType() { + return proto.car.RouteDoneP.RouteDone.getDefaultInstance(); + } + + public proto.car.RouteDoneP.RouteDone build() { + proto.car.RouteDoneP.RouteDone result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public proto.car.RouteDoneP.RouteDone buildPartial() { + proto.car.RouteDoneP.RouteDone result = new proto.car.RouteDoneP.RouteDone(this); + result.uid_ = uid_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof proto.car.RouteDoneP.RouteDone) { + return mergeFrom((proto.car.RouteDoneP.RouteDone)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(proto.car.RouteDoneP.RouteDone other) { + if (other == proto.car.RouteDoneP.RouteDone.getDefaultInstance()) return this; + if (!other.getUid().isEmpty()) { + uid_ = other.uid_; + onChanged(); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + proto.car.RouteDoneP.RouteDone parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (proto.car.RouteDoneP.RouteDone) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private java.lang.Object uid_ = ""; + /** + * optional string uid = 1; + */ + public java.lang.String getUid() { + java.lang.Object ref = uid_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + uid_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string uid = 1; + */ + public com.google.protobuf.ByteString + getUidBytes() { + java.lang.Object ref = uid_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + uid_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string uid = 1; + */ + public Builder setUid( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + uid_ = value; + onChanged(); + return this; + } + /** + * optional string uid = 1; + */ + public Builder clearUid() { + + uid_ = getDefaultInstance().getUid(); + onChanged(); + return this; + } + /** + * optional string uid = 1; + */ + public Builder setUidBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + uid_ = value; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:carkot.RouteDone) + } + + // @@protoc_insertion_point(class_scope:carkot.RouteDone) + private static final proto.car.RouteDoneP.RouteDone DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new proto.car.RouteDoneP.RouteDone(); + } + + public static proto.car.RouteDoneP.RouteDone getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public RouteDone parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new RouteDone(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public proto.car.RouteDoneP.RouteDone getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_carkot_RouteDone_descriptor; + private static final + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_carkot_RouteDone_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\017routeDone.proto\022\006carkot\"\030\n\tRouteDone\022\013" + + "\n\003uid\030\001 \001(\tB\027\n\tproto.carB\nRouteDonePb\006pr" + + "oto3" + }; + com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = + new com.google.protobuf.Descriptors.FileDescriptor. InternalDescriptorAssigner() { + public com.google.protobuf.ExtensionRegistry assignDescriptors( + com.google.protobuf.Descriptors.FileDescriptor root) { + descriptor = root; + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + }, assigner); + internal_static_carkot_RouteDone_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_carkot_RouteDone_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_carkot_RouteDone_descriptor, + new java.lang.String[] { "Uid", }); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/server/carEmulator/src/proto/car/RouteP.java b/server/carEmulator/src/proto/car/RouteP.java new file mode 100644 index 00000000000..95393f50b19 --- /dev/null +++ b/server/carEmulator/src/proto/car/RouteP.java @@ -0,0 +1,1168 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: route.proto + +package proto.car; + +public final class RouteP { + private RouteP() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + } + public interface RouteOrBuilder extends + // @@protoc_insertion_point(interface_extends:carkot.Route) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + java.util.List + getWayPointsList(); + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + proto.car.RouteP.Route.WayPoint getWayPoints(int index); + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + int getWayPointsCount(); + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + java.util.List + getWayPointsOrBuilderList(); + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + proto.car.RouteP.Route.WayPointOrBuilder getWayPointsOrBuilder( + int index); + } + /** + * Protobuf type {@code carkot.Route} + */ + public static final class Route extends + com.google.protobuf.GeneratedMessage implements + // @@protoc_insertion_point(message_implements:carkot.Route) + RouteOrBuilder { + // Use Route.newBuilder() to construct. + private Route(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + } + private Route() { + wayPoints_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Route( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + wayPoints_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + wayPoints_.add(input.readMessage(proto.car.RouteP.Route.WayPoint.parser(), extensionRegistry)); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + wayPoints_ = java.util.Collections.unmodifiableList(wayPoints_); + } + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return proto.car.RouteP.internal_static_carkot_Route_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return proto.car.RouteP.internal_static_carkot_Route_fieldAccessorTable + .ensureFieldAccessorsInitialized( + proto.car.RouteP.Route.class, proto.car.RouteP.Route.Builder.class); + } + + public interface WayPointOrBuilder extends + // @@protoc_insertion_point(interface_extends:carkot.Route.WayPoint) + com.google.protobuf.MessageOrBuilder { + + /** + * optional double distance = 2; + */ + double getDistance(); + + /** + * optional double angle_delta = 3; + */ + double getAngleDelta(); + } + /** + * Protobuf type {@code carkot.Route.WayPoint} + */ + public static final class WayPoint extends + com.google.protobuf.GeneratedMessage implements + // @@protoc_insertion_point(message_implements:carkot.Route.WayPoint) + WayPointOrBuilder { + // Use WayPoint.newBuilder() to construct. + private WayPoint(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + } + private WayPoint() { + distance_ = 0D; + angleDelta_ = 0D; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private WayPoint( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 17: { + + distance_ = input.readDouble(); + break; + } + case 25: { + + angleDelta_ = input.readDouble(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return proto.car.RouteP.internal_static_carkot_Route_WayPoint_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return proto.car.RouteP.internal_static_carkot_Route_WayPoint_fieldAccessorTable + .ensureFieldAccessorsInitialized( + proto.car.RouteP.Route.WayPoint.class, proto.car.RouteP.Route.WayPoint.Builder.class); + } + + public static final int DISTANCE_FIELD_NUMBER = 2; + private double distance_; + /** + * optional double distance = 2; + */ + public double getDistance() { + return distance_; + } + + public static final int ANGLE_DELTA_FIELD_NUMBER = 3; + private double angleDelta_; + /** + * optional double angle_delta = 3; + */ + public double getAngleDelta() { + return angleDelta_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (distance_ != 0D) { + output.writeDouble(2, distance_); + } + if (angleDelta_ != 0D) { + output.writeDouble(3, angleDelta_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (distance_ != 0D) { + size += com.google.protobuf.CodedOutputStream + .computeDoubleSize(2, distance_); + } + if (angleDelta_ != 0D) { + size += com.google.protobuf.CodedOutputStream + .computeDoubleSize(3, angleDelta_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + public static proto.car.RouteP.Route.WayPoint parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static proto.car.RouteP.Route.WayPoint parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static proto.car.RouteP.Route.WayPoint parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static proto.car.RouteP.Route.WayPoint parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static proto.car.RouteP.Route.WayPoint parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input); + } + public static proto.car.RouteP.Route.WayPoint parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static proto.car.RouteP.Route.WayPoint parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseDelimitedWithIOException(PARSER, input); + } + public static proto.car.RouteP.Route.WayPoint parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static proto.car.RouteP.Route.WayPoint parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input); + } + public static proto.car.RouteP.Route.WayPoint parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(proto.car.RouteP.Route.WayPoint prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code carkot.Route.WayPoint} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder implements + // @@protoc_insertion_point(builder_implements:carkot.Route.WayPoint) + proto.car.RouteP.Route.WayPointOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return proto.car.RouteP.internal_static_carkot_Route_WayPoint_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return proto.car.RouteP.internal_static_carkot_Route_WayPoint_fieldAccessorTable + .ensureFieldAccessorsInitialized( + proto.car.RouteP.Route.WayPoint.class, proto.car.RouteP.Route.WayPoint.Builder.class); + } + + // Construct using proto.car.RouteP.Route.WayPoint.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + distance_ = 0D; + + angleDelta_ = 0D; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return proto.car.RouteP.internal_static_carkot_Route_WayPoint_descriptor; + } + + public proto.car.RouteP.Route.WayPoint getDefaultInstanceForType() { + return proto.car.RouteP.Route.WayPoint.getDefaultInstance(); + } + + public proto.car.RouteP.Route.WayPoint build() { + proto.car.RouteP.Route.WayPoint result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public proto.car.RouteP.Route.WayPoint buildPartial() { + proto.car.RouteP.Route.WayPoint result = new proto.car.RouteP.Route.WayPoint(this); + result.distance_ = distance_; + result.angleDelta_ = angleDelta_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof proto.car.RouteP.Route.WayPoint) { + return mergeFrom((proto.car.RouteP.Route.WayPoint)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(proto.car.RouteP.Route.WayPoint other) { + if (other == proto.car.RouteP.Route.WayPoint.getDefaultInstance()) return this; + if (other.getDistance() != 0D) { + setDistance(other.getDistance()); + } + if (other.getAngleDelta() != 0D) { + setAngleDelta(other.getAngleDelta()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + proto.car.RouteP.Route.WayPoint parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (proto.car.RouteP.Route.WayPoint) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private double distance_ ; + /** + * optional double distance = 2; + */ + public double getDistance() { + return distance_; + } + /** + * optional double distance = 2; + */ + public Builder setDistance(double value) { + + distance_ = value; + onChanged(); + return this; + } + /** + * optional double distance = 2; + */ + public Builder clearDistance() { + + distance_ = 0D; + onChanged(); + return this; + } + + private double angleDelta_ ; + /** + * optional double angle_delta = 3; + */ + public double getAngleDelta() { + return angleDelta_; + } + /** + * optional double angle_delta = 3; + */ + public Builder setAngleDelta(double value) { + + angleDelta_ = value; + onChanged(); + return this; + } + /** + * optional double angle_delta = 3; + */ + public Builder clearAngleDelta() { + + angleDelta_ = 0D; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:carkot.Route.WayPoint) + } + + // @@protoc_insertion_point(class_scope:carkot.Route.WayPoint) + private static final proto.car.RouteP.Route.WayPoint DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new proto.car.RouteP.Route.WayPoint(); + } + + public static proto.car.RouteP.Route.WayPoint getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public WayPoint parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new WayPoint(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public proto.car.RouteP.Route.WayPoint getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public static final int WAY_POINTS_FIELD_NUMBER = 1; + private java.util.List wayPoints_; + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public java.util.List getWayPointsList() { + return wayPoints_; + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public java.util.List + getWayPointsOrBuilderList() { + return wayPoints_; + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public int getWayPointsCount() { + return wayPoints_.size(); + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public proto.car.RouteP.Route.WayPoint getWayPoints(int index) { + return wayPoints_.get(index); + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public proto.car.RouteP.Route.WayPointOrBuilder getWayPointsOrBuilder( + int index) { + return wayPoints_.get(index); + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < wayPoints_.size(); i++) { + output.writeMessage(1, wayPoints_.get(i)); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < wayPoints_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, wayPoints_.get(i)); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + public static proto.car.RouteP.Route parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static proto.car.RouteP.Route parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static proto.car.RouteP.Route parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static proto.car.RouteP.Route parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static proto.car.RouteP.Route parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input); + } + public static proto.car.RouteP.Route parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static proto.car.RouteP.Route parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseDelimitedWithIOException(PARSER, input); + } + public static proto.car.RouteP.Route parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static proto.car.RouteP.Route parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input); + } + public static proto.car.RouteP.Route parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessage + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(proto.car.RouteP.Route prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code carkot.Route} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder implements + // @@protoc_insertion_point(builder_implements:carkot.Route) + proto.car.RouteP.RouteOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return proto.car.RouteP.internal_static_carkot_Route_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return proto.car.RouteP.internal_static_carkot_Route_fieldAccessorTable + .ensureFieldAccessorsInitialized( + proto.car.RouteP.Route.class, proto.car.RouteP.Route.Builder.class); + } + + // Construct using proto.car.RouteP.Route.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getWayPointsFieldBuilder(); + } + } + public Builder clear() { + super.clear(); + if (wayPointsBuilder_ == null) { + wayPoints_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + } else { + wayPointsBuilder_.clear(); + } + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return proto.car.RouteP.internal_static_carkot_Route_descriptor; + } + + public proto.car.RouteP.Route getDefaultInstanceForType() { + return proto.car.RouteP.Route.getDefaultInstance(); + } + + public proto.car.RouteP.Route build() { + proto.car.RouteP.Route result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public proto.car.RouteP.Route buildPartial() { + proto.car.RouteP.Route result = new proto.car.RouteP.Route(this); + int from_bitField0_ = bitField0_; + if (wayPointsBuilder_ == null) { + if (((bitField0_ & 0x00000001) == 0x00000001)) { + wayPoints_ = java.util.Collections.unmodifiableList(wayPoints_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.wayPoints_ = wayPoints_; + } else { + result.wayPoints_ = wayPointsBuilder_.build(); + } + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof proto.car.RouteP.Route) { + return mergeFrom((proto.car.RouteP.Route)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(proto.car.RouteP.Route other) { + if (other == proto.car.RouteP.Route.getDefaultInstance()) return this; + if (wayPointsBuilder_ == null) { + if (!other.wayPoints_.isEmpty()) { + if (wayPoints_.isEmpty()) { + wayPoints_ = other.wayPoints_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureWayPointsIsMutable(); + wayPoints_.addAll(other.wayPoints_); + } + onChanged(); + } + } else { + if (!other.wayPoints_.isEmpty()) { + if (wayPointsBuilder_.isEmpty()) { + wayPointsBuilder_.dispose(); + wayPointsBuilder_ = null; + wayPoints_ = other.wayPoints_; + bitField0_ = (bitField0_ & ~0x00000001); + wayPointsBuilder_ = + com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ? + getWayPointsFieldBuilder() : null; + } else { + wayPointsBuilder_.addAllMessages(other.wayPoints_); + } + } + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + proto.car.RouteP.Route parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (proto.car.RouteP.Route) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List wayPoints_ = + java.util.Collections.emptyList(); + private void ensureWayPointsIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + wayPoints_ = new java.util.ArrayList(wayPoints_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilder< + proto.car.RouteP.Route.WayPoint, proto.car.RouteP.Route.WayPoint.Builder, proto.car.RouteP.Route.WayPointOrBuilder> wayPointsBuilder_; + + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public java.util.List getWayPointsList() { + if (wayPointsBuilder_ == null) { + return java.util.Collections.unmodifiableList(wayPoints_); + } else { + return wayPointsBuilder_.getMessageList(); + } + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public int getWayPointsCount() { + if (wayPointsBuilder_ == null) { + return wayPoints_.size(); + } else { + return wayPointsBuilder_.getCount(); + } + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public proto.car.RouteP.Route.WayPoint getWayPoints(int index) { + if (wayPointsBuilder_ == null) { + return wayPoints_.get(index); + } else { + return wayPointsBuilder_.getMessage(index); + } + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public Builder setWayPoints( + int index, proto.car.RouteP.Route.WayPoint value) { + if (wayPointsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureWayPointsIsMutable(); + wayPoints_.set(index, value); + onChanged(); + } else { + wayPointsBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public Builder setWayPoints( + int index, proto.car.RouteP.Route.WayPoint.Builder builderForValue) { + if (wayPointsBuilder_ == null) { + ensureWayPointsIsMutable(); + wayPoints_.set(index, builderForValue.build()); + onChanged(); + } else { + wayPointsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public Builder addWayPoints(proto.car.RouteP.Route.WayPoint value) { + if (wayPointsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureWayPointsIsMutable(); + wayPoints_.add(value); + onChanged(); + } else { + wayPointsBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public Builder addWayPoints( + int index, proto.car.RouteP.Route.WayPoint value) { + if (wayPointsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureWayPointsIsMutable(); + wayPoints_.add(index, value); + onChanged(); + } else { + wayPointsBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public Builder addWayPoints( + proto.car.RouteP.Route.WayPoint.Builder builderForValue) { + if (wayPointsBuilder_ == null) { + ensureWayPointsIsMutable(); + wayPoints_.add(builderForValue.build()); + onChanged(); + } else { + wayPointsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public Builder addWayPoints( + int index, proto.car.RouteP.Route.WayPoint.Builder builderForValue) { + if (wayPointsBuilder_ == null) { + ensureWayPointsIsMutable(); + wayPoints_.add(index, builderForValue.build()); + onChanged(); + } else { + wayPointsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public Builder addAllWayPoints( + java.lang.Iterable values) { + if (wayPointsBuilder_ == null) { + ensureWayPointsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, wayPoints_); + onChanged(); + } else { + wayPointsBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public Builder clearWayPoints() { + if (wayPointsBuilder_ == null) { + wayPoints_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + wayPointsBuilder_.clear(); + } + return this; + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public Builder removeWayPoints(int index) { + if (wayPointsBuilder_ == null) { + ensureWayPointsIsMutable(); + wayPoints_.remove(index); + onChanged(); + } else { + wayPointsBuilder_.remove(index); + } + return this; + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public proto.car.RouteP.Route.WayPoint.Builder getWayPointsBuilder( + int index) { + return getWayPointsFieldBuilder().getBuilder(index); + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public proto.car.RouteP.Route.WayPointOrBuilder getWayPointsOrBuilder( + int index) { + if (wayPointsBuilder_ == null) { + return wayPoints_.get(index); } else { + return wayPointsBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public java.util.List + getWayPointsOrBuilderList() { + if (wayPointsBuilder_ != null) { + return wayPointsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(wayPoints_); + } + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public proto.car.RouteP.Route.WayPoint.Builder addWayPointsBuilder() { + return getWayPointsFieldBuilder().addBuilder( + proto.car.RouteP.Route.WayPoint.getDefaultInstance()); + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public proto.car.RouteP.Route.WayPoint.Builder addWayPointsBuilder( + int index) { + return getWayPointsFieldBuilder().addBuilder( + index, proto.car.RouteP.Route.WayPoint.getDefaultInstance()); + } + /** + * repeated .carkot.Route.WayPoint way_points = 1; + */ + public java.util.List + getWayPointsBuilderList() { + return getWayPointsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilder< + proto.car.RouteP.Route.WayPoint, proto.car.RouteP.Route.WayPoint.Builder, proto.car.RouteP.Route.WayPointOrBuilder> + getWayPointsFieldBuilder() { + if (wayPointsBuilder_ == null) { + wayPointsBuilder_ = new com.google.protobuf.RepeatedFieldBuilder< + proto.car.RouteP.Route.WayPoint, proto.car.RouteP.Route.WayPoint.Builder, proto.car.RouteP.Route.WayPointOrBuilder>( + wayPoints_, + ((bitField0_ & 0x00000001) == 0x00000001), + getParentForChildren(), + isClean()); + wayPoints_ = null; + } + return wayPointsBuilder_; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:carkot.Route) + } + + // @@protoc_insertion_point(class_scope:carkot.Route) + private static final proto.car.RouteP.Route DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new proto.car.RouteP.Route(); + } + + public static proto.car.RouteP.Route getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Route parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Route(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public proto.car.RouteP.Route getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_carkot_Route_descriptor; + private static final + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_carkot_Route_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_carkot_Route_WayPoint_descriptor; + private static final + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_carkot_Route_WayPoint_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\013route.proto\022\006carkot\"f\n\005Route\022*\n\nway_po" + + "ints\030\001 \003(\0132\026.carkot.Route.WayPoint\0321\n\010Wa" + + "yPoint\022\020\n\010distance\030\002 \001(\001\022\023\n\013angle_delta\030" + + "\003 \001(\001B\023\n\tproto.carB\006RoutePb\006proto3" + }; + com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = + new com.google.protobuf.Descriptors.FileDescriptor. InternalDescriptorAssigner() { + public com.google.protobuf.ExtensionRegistry assignDescriptors( + com.google.protobuf.Descriptors.FileDescriptor root) { + descriptor = root; + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + }, assigner); + internal_static_carkot_Route_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_carkot_Route_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_carkot_Route_descriptor, + new java.lang.String[] { "WayPoints", }); + internal_static_carkot_Route_WayPoint_descriptor = + internal_static_carkot_Route_descriptor.getNestedTypes().get(0); + internal_static_carkot_Route_WayPoint_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_carkot_Route_WayPoint_descriptor, + new java.lang.String[] { "Distance", "AngleDelta", }); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/server/src/server/ServerHandler.kt b/server/carEmulator/src/server/Handler.kt similarity index 58% rename from server/src/server/ServerHandler.kt rename to server/carEmulator/src/server/Handler.kt index 1bb2b302120..82b1fbea14a 100644 --- a/server/src/server/ServerHandler.kt +++ b/server/carEmulator/src/server/Handler.kt @@ -1,5 +1,6 @@ package server +import com.google.protobuf.InvalidProtocolBufferException import connectUrl import getLocationUrl import io.netty.buffer.Unpooled @@ -7,67 +8,66 @@ import io.netty.channel.ChannelFutureListener import io.netty.channel.ChannelHandlerContext import io.netty.channel.SimpleChannelInboundHandler import io.netty.handler.codec.http.* -import io.netty.util.CharsetUtil -import objects.Environment import proto.car.ConnectP.ConnectionRequest -import proto.car.RouteDoneP +import proto.car.LocationP import proto.car.RouteDoneP.RouteDone +import proto.car.RouteP import routeDoneUrl import setRouteUrl -import java.nio.charset.Charset -import java.text.SimpleDateFormat import java.util.* /** * Created by user on 7/6/16. */ -class ServerHandler : SimpleChannelInboundHandler() { +class Handler : SimpleChannelInboundHandler() { var url: String = "" var contentBytes: ByteArray = ByteArray(0); override fun channelReadComplete(ctx: ChannelHandlerContext) { - val environment = Environment.instance + val car = ThisCar.instance var success = true; + + var dataAnswer: ByteArray = ByteArray(0) when (url) { - connectUrl -> { - val data = ConnectionRequest.parseFrom(contentBytes) - //todo + getLocationUrl -> { + dataAnswer = LocationP.Location.newBuilder().setAngle(car.angle).setX(car.x).setY(car.y).build().toByteArray(); } - routeDoneUrl -> { - val data = RouteDone.parseFrom(contentBytes) - val id = data.uid - synchronized(environment.map, { - val car = environment.map.get(id) - if (car != null) { - car.free = true - } else { - success = false - } - }) + setRouteUrl -> { + var data: RouteP.Route? = null; + try { + data = RouteP.Route.parseFrom(contentBytes) + } catch (e: InvalidProtocolBufferException) { + //todo error answer + } + if (data != null) { + val wayPoints = data.wayPointsList + println("try set path") + ThisCar.instance.setPath(wayPoints) + } } else -> { success = false - //todo unsup operation + //todo unsup operation. error answer } } - val response = DefaultFullHttpResponse(HttpVersion.HTTP_1_1, if (success) HttpResponseStatus.OK else HttpResponseStatus.NOT_FOUND) + val response = DefaultFullHttpResponse(HttpVersion.HTTP_1_1, if (success) HttpResponseStatus.OK else HttpResponseStatus.NOT_FOUND, Unpooled.copiedBuffer(dataAnswer)) response.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, response.content().readableBytes()) ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE); } + override fun channelRead(ctx: ChannelHandlerContext?, msg: Any?) { + super.channelRead(ctx, msg) + } + override fun channelRead0(ctx: ChannelHandlerContext, msg: Any) { if (msg is HttpRequest) { this.url = msg.uri() -// sb.append("" + msg.method() + " " + msg.protocolVersion() + "\n" + msg.uri()) -// for (header in msg.headers()) { -// sb.append(header.key + ":" + header.value + "\n") -// } } - if (msg is DefaultHttpContent) { + if (msg is HttpContent) { val contentsBytes = msg.content(); contentBytes = ByteArray(contentsBytes.capacity()) contentsBytes.readBytes(contentBytes) diff --git a/server/carEmulator/src/server/Initializer.kt b/server/carEmulator/src/server/Initializer.kt new file mode 100644 index 00000000000..8011537788e --- /dev/null +++ b/server/carEmulator/src/server/Initializer.kt @@ -0,0 +1,29 @@ +package server + +import io.netty.channel.ChannelInitializer +import io.netty.channel.ChannelPipeline +import io.netty.channel.socket.SocketChannel +import io.netty.handler.codec.http.HttpRequestDecoder +import io.netty.handler.codec.http.HttpResponseEncoder +import io.netty.handler.codec.http.HttpServerCodec +import io.netty.util.concurrent.DefaultEventExecutorGroup +import io.netty.util.concurrent.EventExecutorGroup + +/** + * Created by user on 7/6/16. + */ +class Initializer : ChannelInitializer { + + + constructor() { + } + + override fun initChannel(channel: SocketChannel) { + val p: ChannelPipeline = channel.pipeline() + + p.addLast(HttpServerCodec()) +// p.addLast(HttpRequestDecoder()) +// p.addLast(HttpResponseEncoder()) + p.addLast(Handler()) + } +} \ No newline at end of file diff --git a/server/src/Main.kt b/server/src/Main.kt deleted file mode 100644 index 274507a2f4d..00000000000 --- a/server/src/Main.kt +++ /dev/null @@ -1,23 +0,0 @@ -import server.Server -import java.awt.Robot -import java.util.* -import kotlin.concurrent.thread -import kotlin.jvm.internal.iterator - -/** - * Created by user on 7/6/16. - */ - -//хардкод это плохо, но пока так...:) -val port:Int = 7925 -val handlerThreadsCount:Int = 100 -val getLocationUrl = "getLocation" -val routeDoneUrl = "routeDone" -val setRouteUrl = "route" -val connectUrl = "connect" - -fun main(args: Array) { - println("server started") - val server = Server(port, handlerThreadsCount) - val serverThread = thread{server.run()} -} \ No newline at end of file diff --git a/server/src/ServerMain.kt b/server/src/ServerMain.kt new file mode 100644 index 00000000000..98e4a8ab21c --- /dev/null +++ b/server/src/ServerMain.kt @@ -0,0 +1,116 @@ +import car.client.Client +import io.netty.bootstrap.ServerBootstrap +import io.netty.buffer.Unpooled +import io.netty.channel.nio.NioEventLoopGroup +import io.netty.channel.socket.nio.NioServerSocketChannel +import io.netty.handler.codec.http.* +import objects.Car +import proto.car.RouteP +import java.util.* +import kotlin.concurrent.thread + +/** + * Created by user on 7/6/16. + */ + +//хардкод это плохо, но пока так...:) +val carServerPort: Int = 7925 +val webServerPort: Int = 7926 +val handlerThreadsCount: Int = 100 +val getLocationUrl = "getLocation" +val routeDoneUrl = "routeDone" +val setRouteUrl = "route" +val connectUrl = "connect" + +fun main(args: Array) { + + println("car server started") + val serverCarThread = thread { + val bossGroup = NioEventLoopGroup(1) + val workerGroup = NioEventLoopGroup() + val b = ServerBootstrap() + b.group(bossGroup, workerGroup) + .channel(NioServerSocketChannel().javaClass) + .childHandler(car.server.Initializer(handlerThreadsCount)) + + try { + val channel = b.bind(carServerPort).sync().channel() + channel.closeFuture().sync() + } catch (e: InterruptedException) { + println("car server stoped!") + e.printStackTrace() + } finally { + bossGroup.shutdownGracefully() + workerGroup.shutdownGracefully() + } + } + + // val serverWebThread = thread { + // val bossGroup = NioEventLoopGroup(1) + // val workerGroup = NioEventLoopGroup() + // val b = ServerBootstrap() + // b.group(bossGroup, workerGroup) + // .channel(NioServerSocketChannel().javaClass) + // .childHandler(web.server.Initializer(handlerThreadsCount)) + // + // try { + // val channel = b.bind(webServerPort).sync().channel() + // channel.closeFuture().sync() + // } catch (e: InterruptedException) { + // println("web server stoped!") + // } finally { + // bossGroup.shutdownGracefully() + // workerGroup.shutdownGracefully() + // } + // } + val serverWebThread = thread { + val environment = objects.Environment.instance + val scanner = Scanner(System.`in`) + while (scanner.hasNext()) { + val s = scanner.nextLine() + if (s.equals("cars", true)) { + synchronized(environment, { + println(environment.map.values) + }) + } else if (s.equals("pathto", true)) { + println("print datas. format: [string id] [double distance] [double angle]") + val data = scanner.nextLine() + val datas = data.split(" ") + try { + val id = datas[0] + val distance = datas[1].toDouble() + val angle = datas[2].toDouble() + + val car: Car? = + synchronized(environment, { + environment.map.get(id) + }) + if (car != null) { + val wayPoint = RouteP.Route.WayPoint.newBuilder().setDistance(distance).setAngleDelta(angle).build() + val route = RouteP.Route.newBuilder().addWayPoints(wayPoint).build() + val request = DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, setRouteUrl, Unpooled.copiedBuffer(route.toByteArray())) + request.headers().set(HttpHeaderNames.HOST, car.host) + request.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE) + request.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, request.content().readableBytes()) + Client.sendRequest(request, car.host, car.port, id) + } + + } catch (e: Exception) { + e.printStackTrace() + println("incorrect format") + } + } else if (s.equals("refloc", true)) { + val cars = synchronized(environment, {environment.map.values}) + for (car in cars) { + val request = DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, getLocationUrl, Unpooled.EMPTY_BUFFER) + request.headers().set(HttpHeaderNames.HOST, car.host) + request.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE) + request.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, request.content().readableBytes()) + Client.sendRequest(request, car.host, car.port, car.id) + } + } + } + } + + +} \ No newline at end of file diff --git a/server/src/car/client/Client.kt b/server/src/car/client/Client.kt new file mode 100644 index 00000000000..60139148dac --- /dev/null +++ b/server/src/car/client/Client.kt @@ -0,0 +1,40 @@ +package car.client + +import io.netty.bootstrap.Bootstrap +import io.netty.channel.ChannelFutureListener +import io.netty.channel.ChannelInitializer +import io.netty.channel.nio.NioEventLoopGroup +import io.netty.channel.socket.SocketChannel +import io.netty.channel.socket.nio.NioSocketChannel +import io.netty.handler.codec.http.HttpRequest +import io.netty.util.AttributeKey + +/** + * Created by user on 7/8/16. + */ +object Client { + + val bootstrap: Bootstrap = makeBootstrap() + + private fun makeBootstrap(): Bootstrap { + val group = NioEventLoopGroup(); + val b = Bootstrap(); + b.group(group).channel(NioSocketChannel().javaClass).handler(ClientInitializer()) + .attr(AttributeKey.newInstance("url"), "") + .attr(AttributeKey.newInstance("uid"), "") + return b + } + + fun sendRequest(request: HttpRequest, host: String, port: Int, carUid: String) { + try { + bootstrap.attr(AttributeKey.valueOf("url"), request.uri()) + bootstrap.attr(AttributeKey.valueOf("uid"), carUid) + val ch = bootstrap.connect(host, port).sync().channel() + ch.writeAndFlush(request) + ch.closeFuture().sync()//wait for answer + } catch (e: InterruptedException) { + + } + } + +} \ No newline at end of file diff --git a/server/src/car/client/ClientHandler.kt b/server/src/car/client/ClientHandler.kt new file mode 100644 index 00000000000..066b788fd98 --- /dev/null +++ b/server/src/car/client/ClientHandler.kt @@ -0,0 +1,60 @@ +package car.client + +import com.google.protobuf.InvalidProtocolBufferException +import getLocationUrl +import io.netty.channel.ChannelHandlerContext +import io.netty.channel.SimpleChannelInboundHandler +import io.netty.handler.codec.http.HttpContent +import io.netty.util.AttributeKey +import objects.Environment +import proto.car.LocationP +import setRouteUrl +import java.util.* + +/** + * Created by user on 7/8/16. + */ +class ClientHandler : SimpleChannelInboundHandler { + + constructor() + + var contentBytes: ByteArray = ByteArray(0); + + override fun channelReadComplete(ctx: ChannelHandlerContext) { + val url = ctx.channel().attr(AttributeKey.valueOf("url")).get() + val carUid = ctx.channel().attr(AttributeKey.valueOf("uid")).get() + val environment = Environment.instance + when (url) { + setRouteUrl -> { + + } + getLocationUrl -> { + + try { + val data = LocationP.Location.parseFrom(contentBytes) + synchronized(environment, { + val car = environment.map.get(carUid) + if (car != null) { + car.x = data.x + car.y = data.y + } + }) + } catch (e: InvalidProtocolBufferException) { + //todo error answer + } + } + else -> { + + } + } + ctx.close() + } + + override fun channelRead0(ctx: ChannelHandlerContext?, msg: Any?) { + if (msg is HttpContent) { + val contentsBytes = msg.content(); + contentBytes = ByteArray(contentsBytes.capacity()) + contentsBytes.readBytes(contentBytes) + } + } +} \ No newline at end of file diff --git a/server/src/car/client/ClientInitializer.kt b/server/src/car/client/ClientInitializer.kt new file mode 100644 index 00000000000..9b122271baa --- /dev/null +++ b/server/src/car/client/ClientInitializer.kt @@ -0,0 +1,19 @@ +package car.client + +import io.netty.channel.ChannelInitializer +import io.netty.channel.socket.SocketChannel +import io.netty.handler.codec.http.HttpClientCodec + +/** + * Created by user on 7/8/16. + */ +class ClientInitializer : ChannelInitializer { + + constructor() + + override fun initChannel(ch: SocketChannel) { + val p = ch.pipeline() + p.addLast(HttpClientCodec()) + p.addLast(ClientHandler()) + } +} \ No newline at end of file diff --git a/server/src/car/server/Handler.kt b/server/src/car/server/Handler.kt new file mode 100644 index 00000000000..6f62d455e0c --- /dev/null +++ b/server/src/car/server/Handler.kt @@ -0,0 +1,95 @@ +package car.server + +import com.google.protobuf.InvalidProtocolBufferException +import connectUrl +import io.netty.buffer.Unpooled +import io.netty.channel.ChannelFutureListener +import io.netty.channel.ChannelHandlerContext +import io.netty.channel.SimpleChannelInboundHandler +import io.netty.handler.codec.http.* +import objects.Car +import objects.Environment +import proto.car.ConnectP +import proto.car.ConnectP.ConnectionRequest +import proto.car.RouteDoneP.RouteDone +import routeDoneUrl +import java.util.* + +/** + * Created by user on 7/6/16. + */ +class Handler : SimpleChannelInboundHandler() { + + var url: String = "" + var contentBytes: ByteArray = ByteArray(0); + + override fun channelReadComplete(ctx: ChannelHandlerContext) { + + val environment = Environment.instance + var success = true; + + var answer:ByteArray = ByteArray(0) + when (url) { + connectUrl -> { + var data: ConnectionRequest? = null + try { + data = ConnectionRequest.parseFrom(contentBytes) + } catch (e: InvalidProtocolBufferException) { + //todo error answer + } + if (data != null) { + val uid = environment.connectCar(data.ip, data.port) + answer = ConnectP.ConnectionResponse.newBuilder().setUid(uid).build().toByteArray() + } + } + routeDoneUrl -> { + var data: RouteDone? = null + try { + data = RouteDone.parseFrom(contentBytes) + } catch (e: InvalidProtocolBufferException) { + //todo error answer + } + if (data != null) { + val id = data.uid + synchronized(environment.map, { + val car = environment.map.get(id) + if (car != null) { + car.free = true + } else { + success = false + } + }) + } + } + else -> { + success = false + //todo unsup operation. error answer + } + } + + val response = DefaultFullHttpResponse(HttpVersion.HTTP_1_1, if (success) HttpResponseStatus.OK else HttpResponseStatus.NOT_FOUND, Unpooled.copiedBuffer(answer)) + response.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, response.content().readableBytes()) + ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE); + } + + override fun channelRead0(ctx: ChannelHandlerContext, msg: Any) { + if (msg is HttpRequest) { + this.url = msg.uri() + } + + if (msg is DefaultHttpContent) { + val contentsBytes = msg.content(); + contentBytes = ByteArray(contentsBytes.capacity()) + contentsBytes.readBytes(contentBytes) + } + } + + + override fun exceptionCaught(ctx: ChannelHandlerContext?, cause: Throwable?) { + println("exception") + cause?.printStackTrace() + if (ctx != null) { + ctx.close() + } + } +} \ No newline at end of file diff --git a/server/src/car/server/Initializer.kt b/server/src/car/server/Initializer.kt new file mode 100644 index 00000000000..08d716eaf75 --- /dev/null +++ b/server/src/car/server/Initializer.kt @@ -0,0 +1,31 @@ +package car.server + +import io.netty.channel.ChannelInitializer +import io.netty.channel.ChannelPipeline +import io.netty.channel.socket.SocketChannel +import io.netty.handler.codec.http.HttpRequestDecoder +import io.netty.handler.codec.http.HttpResponseEncoder +import io.netty.handler.codec.http.HttpServerCodec +import io.netty.util.concurrent.DefaultEventExecutorGroup +import io.netty.util.concurrent.EventExecutorGroup + +/** + * Created by user on 7/6/16. + */ +class Initializer : ChannelInitializer { + + val group: EventExecutorGroup; + + constructor(handlerThreadCount: Int) { + this.group = DefaultEventExecutorGroup(handlerThreadCount) + } + + override fun initChannel(channel: SocketChannel) { + val p: ChannelPipeline = channel.pipeline() + + p.addLast(HttpServerCodec()) +// p.addLast(HttpRequestDecoder()) +// p.addLast(HttpResponseEncoder()) + p.addLast(group, Handler()) + } +} \ No newline at end of file diff --git a/server/src/objects/Car.kt b/server/src/objects/Car.kt index 94abc87fd2e..e5f6738e6e2 100644 --- a/server/src/objects/Car.kt +++ b/server/src/objects/Car.kt @@ -1,21 +1,31 @@ package objects +import car.client.Client + /** * Created by user on 7/7/16. */ class Car constructor(id: String, host: String, port: Int) { - private val id: String - private val host: String - private val port: Int + val id: String + val host: String + val port: Int - var free:Boolean + var free: Boolean + + var x: Double + var y: Double init { this.id = id this.host = host this.port = port this.free = true + x = 0.toDouble() + y = 0.toDouble() } + override fun toString(): String { + return "$id ; x:$x; y:$y" + } } \ No newline at end of file diff --git a/server/src/objects/Environment.kt b/server/src/objects/Environment.kt index 99b171fd2be..00468f5298c 100644 --- a/server/src/objects/Environment.kt +++ b/server/src/objects/Environment.kt @@ -1,5 +1,7 @@ package objects +import java.util.* + /** * Created by user on 7/7/16. */ @@ -16,5 +18,22 @@ class Environment private constructor() { map = mutableMapOf(); } + @Synchronized + fun connectCar(host:String, port:Int):String { + //todo учетка памяти, тут машинки добавляются,но никогда не удаляются. Если включать и выключать одну и ту же машинку, то либо сервер зациклится, либо out of memory + //todo в зависимости от того, что кончится раньше, память или айдишники:) Может сделать поток, который мониторит раз в N минут все машинки и дропает те, которые не активны более какого-то времени? + var unique = false + val random = Random() + var stringUid = "" + while (!unique) { + stringUid = "id:" + random.nextInt(1000000) + if (map.get(stringUid) == null) { + unique = true; + } + } + map.put(stringUid, Car(stringUid, host, port)) + return stringUid + } + } diff --git a/server/src/server/Server.kt b/server/src/server/Server.kt deleted file mode 100644 index f20b575b467..00000000000 --- a/server/src/server/Server.kt +++ /dev/null @@ -1,44 +0,0 @@ -package server - -import io.netty.bootstrap.ServerBootstrap -import io.netty.channel.nio.NioEventLoopGroup -import io.netty.channel.socket.nio.NioServerSocketChannel -import io.netty.handler.logging.LogLevel -import io.netty.handler.logging.LoggingHandler - -/** - * Created by user on 7/6/16. - */ -class Server : Runnable { - - val port: Int; - val handlerThreadsCount: Int; - - constructor(port: Int, handlerThreadsCount: Int) { - this.port = port - this.handlerThreadsCount = handlerThreadsCount - } - - override fun run() { - val bossGroup = NioEventLoopGroup(1) - val workerGroup = NioEventLoopGroup() - val b = ServerBootstrap() - b.group(bossGroup, workerGroup) - .channel(NioServerSocketChannel().javaClass) - .handler(LoggingHandler(LogLevel.INFO)) - .childHandler(ServerInitializer(handlerThreadsCount)) - - try { - val channel = b.bind(port).sync().channel() - channel.closeFuture().sync() - } catch (e: InterruptedException) { - e.printStackTrace() - //todo - } finally { - bossGroup.shutdownGracefully() - workerGroup.shutdownGracefully() - } - - } - -} \ No newline at end of file diff --git a/server/src/web/server/Handler.kt b/server/src/web/server/Handler.kt new file mode 100644 index 00000000000..7302e770372 --- /dev/null +++ b/server/src/web/server/Handler.kt @@ -0,0 +1,45 @@ +package web.server + +import connectUrl +import getLocationUrl +import io.netty.buffer.Unpooled +import io.netty.channel.ChannelFutureListener +import io.netty.channel.ChannelHandlerContext +import io.netty.channel.SimpleChannelInboundHandler +import io.netty.handler.codec.http.* +import io.netty.util.CharsetUtil +import objects.Environment +import proto.car.ConnectP.ConnectionRequest +import proto.car.RouteDoneP +import proto.car.RouteDoneP.RouteDone +import routeDoneUrl +import setRouteUrl +import java.nio.charset.Charset +import java.text.SimpleDateFormat +import java.util.* + +/** + * Created by user on 7/6/16. + */ +class Handler : SimpleChannelInboundHandler() { + + var content: StringBuilder = StringBuilder() + + override fun channelReadComplete(ctx: ChannelHandlerContext) { + + content.setLength(0) + } + + override fun channelRead0(ctx: ChannelHandlerContext, msg: Any) { + println(msg) + } + + + override fun exceptionCaught(ctx: ChannelHandlerContext?, cause: Throwable?) { + println("exception") + cause?.printStackTrace() + if (ctx != null) { + ctx.close() + } + } +} \ No newline at end of file diff --git a/server/src/server/ServerInitializer.kt b/server/src/web/server/Initializer.kt similarity index 76% rename from server/src/server/ServerInitializer.kt rename to server/src/web/server/Initializer.kt index 47a5a3832e7..1c84c820bf8 100644 --- a/server/src/server/ServerInitializer.kt +++ b/server/src/web/server/Initializer.kt @@ -1,17 +1,18 @@ -package server +package web.server import io.netty.channel.ChannelInitializer import io.netty.channel.ChannelPipeline import io.netty.channel.socket.SocketChannel import io.netty.handler.codec.http.HttpRequestDecoder import io.netty.handler.codec.http.HttpResponseEncoder +import io.netty.handler.codec.http.HttpServerCodec import io.netty.util.concurrent.DefaultEventExecutorGroup import io.netty.util.concurrent.EventExecutorGroup /** * Created by user on 7/6/16. */ -class ServerInitializer : ChannelInitializer { +class Initializer : ChannelInitializer { val group: EventExecutorGroup; @@ -21,8 +22,8 @@ class ServerInitializer : ChannelInitializer { override fun initChannel(channel: SocketChannel) { val p: ChannelPipeline = channel.pipeline() - p.addLast(HttpRequestDecoder()) - p.addLast(HttpResponseEncoder()) - p.addLast(group, ServerHandler()) + + p.addLast(HttpServerCodec()) + p.addLast(group, Handler()) } } \ No newline at end of file