# Vert.x for Kotlin

If you are using Maven or Gradle, add the following dependency to the dependencies section of your project descriptor to access the Vert.x Core API and enable the Kotlin support:

- Maven (in your `pom.xml`):

    <dependency>
    <groupId>io.vertx</groupId>
    <artifactId>vertx-core</artifactId>
    <version>4.3.1</version>
    </dependency>
    <dependency>
     <groupId>io.vertx</groupId>
     <artifactId>vertx-lang-kotlin</artifactId>
     <version>4.3.1</version>
    </dependency>

- Gradle (in your `build.gradle` file):

    compile "io.vertx:vertx-core:4.3.1"
    compile "io.vertx:vertx-lang-kotlin:4.3.1"

## Verticles

### Writing Verticles

Writing a Verticle with Kotlin is achieved the same way you write a Java Verticle by extending the `AbstractVerticle`.

Here’s an example verticle:

    import io.vertx.core.AbstractVerticle

    class MyVerticle : AbstractVerticle() {

     // Called when verticle is deployed
     override fun start() {
     }

     // Optional - called when verticle is undeployed
     override fun stop() {
     }
    }

Please refer to the Java documentation.

## Data Objects builders

Data Objects play an essential role in the Vert.x stack (a Data Object is a type that can be converted to/from JSON).

For example, Vert.x modules often use Data Objects for the configuration of servers:

    val classic: HttpServerOptions = HttpServerOptions()
     .setIdleTimeout(5)
     .setIdleTimeoutUnit(TimeUnit.MINUTES)
     .setLogActivity(true)

While the above construct is valid, there is a more idiomatic way of configuring Data Objects. In Kotlin, all Data Objects have a builder method suffixed with `Of`:

    val options = httpServerOptionsOf(idleTimeout = 5, idleTimeoutUnit = TimeUnit.MINUTES, logActivity = true)

## JSON

Unlike some other languages, Java does not have first class support for JSON so we provide two classes to make handling JSON in your Vert.x applications a bit easier.

Use the `JsonObject` class to represent JSON objects and the `JsonArray` class to represent JSON arrays, you can refer to the Java documentation for more details.

### Builders

Builders are provided to provide a more fluent JSON construction:

    // The json builder declares a JSON structure
    val result = json {

     // in this structure the obj function can be used

     // takes a vararg of Kotlin pairs
     obj(
       "key_1" to 1,
       "key_2" to 2,
       "key_3" to 3
     )

     // or an iterable of Kotlin pairs
     obj((1..3).map { "key_$it" to it })

     // or a Map<String, Any?>
     obj(someMap)

     // apply function on object receiver
     obj {
       for (i in 1..3) {
         put("key_$i", i)
       }
     }
    }

You can also build JSON arrays:

    // The json builder declares a JSON structure
    val result = json {

     // in this structure the array function can be used

     // takes a vararg of values
     array("1", "2", "3")

     // or an iterable of values
     array((1..3).map { "$it" })

     // apply function on array receiver
     array {
       for (i in 1..3) {
         add("$i")
       }
     }
    }

Of course it is possible to mix objects and arrays

    // The json builder declares a JSON structure
    val result = json {
         obj(
           "firstName" to "Dale",
           "lastName" to "Cooper",
           "age" to 64,
           "names" to array("Dale", "Bartholomew")
         )
    }

### Postscript operator overloading

The Kotlin postscript operator is overloaded for JSON object and array:

    print(someObject["firstName"]);
    print(someArray[4]);