### Add Unit API Springdoc Starter (Maven)

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/quickstart/spring-boot.md

Include the springdoc starter dependency for the unit-api in your Maven pom.xml file. This enables enhanced Swagger documentation for your API endpoints, providing examples for quantity properties.

```xml
<dependency>
    <groupId>com.raynigon.unit-api</groupId>
    <artifactId>springdoc-starter</artifactId>
    <version>{{latest_version}}</version>
</dependency>
```

--------------------------------

### JSON Input Examples for Quantity Serialization

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/quickstart/jackson.md

Demonstrates various JSON formats that Jackson will accept for a quantity field annotated with @JsonUnit. These examples show how numbers, strings, and objects representing quantities are correctly parsed and converted to the specified unit (e.g., km/h).

```json
{
  "id": "65bf1872-d197-4d72-9950-2b7b4d74a674",
  "speed": 80
}
```

```json
{
  "id": "65bf1872-d197-4d72-9950-2b7b4d74a674",
  "speed": "80"
}
```

```json
{
  "id": "65bf1872-d197-4d72-9950-2b7b4d74a674",
  "speed": {
    "value:" 80,
    "unit": "km/h"
  }
}
```

```json
{
  "id": "65bf1872-d197-4d72-9950-2b7b4d74a674",
  "speed": "80 km/h"
}
```

```json
{
  "id": "65bf1872-d197-4d72-9950-2b7b4d74a674",
  "speed": "22.2222 m/s"
}
```

--------------------------------

### JSON Example: Number Input for Quantity

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/quickstart/spring-boot.md

Demonstrates accepting a numerical value for a quantity field in JSON, which will be interpreted according to the unit specified in the model's annotation (`@JsonUnit`).

```json
{
  "id": "65bf1872-d197-4d72-9950-2b7b4d74a674",
  "speed": 80
}
```

--------------------------------

### Add Unit API Springdoc Starter (Gradle)

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/quickstart/spring-boot.md

Include the springdoc starter dependency for the unit-api in your Gradle build file. This enables enhanced Swagger documentation for your API endpoints, providing examples for quantity properties.

```groovy
implementation("com.raynigon.unit-api:springdoc-starter:{{latest_version}}")
```

--------------------------------

### JSON Example: String Input for Quantity

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/quickstart/spring-boot.md

Demonstrates accepting a string representation of a numerical value for a quantity field in JSON. Jackson will parse this string into the appropriate quantity type.

```json
{
  "id": "65bf1872-d197-4d72-9950-2b7b4d74a674",
  "speed": "80"
}
```

--------------------------------

### Add Spring Boot Unit-API Dependencies (Gradle)

Source: https://github.com/raynigon/unit-api/blob/main/docs/spring-boot/index.md

Includes the necessary Unit-API starters for Spring Boot using Gradle. These starters provide integration with Jackson for serialization/deserialization, JPA for database persistence, and Springdoc for API documentation.

```groovy
implementation("com.raynigon.unit-api:spring-boot-jackson-starter:{{latest_version}}")
implementation("com.raynigon.unit-api:spring-boot-jpa-starter:{{latest_version}}")
implementation("com.raynigon.unit-api:spring-boot-springdoc-starter:{{latest_version}}")
```

--------------------------------

### JSON Example: String Input with Unit (km/h)

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/quickstart/spring-boot.md

Demonstrates accepting a string value that includes the unit (km/h) for a quantity field in JSON. Jackson will parse this string and convert it if necessary to the target unit.

```json
{
  "id": "65bf1872-d197-4d72-9950-2b7b4d74a674",
  "speed": "80 km/h"
}
```

--------------------------------

### Add Unit API Jackson and JPA Starters (Maven)

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/quickstart/spring-boot.md

Include the Jackson and JPA starter dependencies for the unit-api in your Maven pom.xml file. These starters enable automatic unit conversion for JSON serialization/deserialization and persistence, respectively.

```xml
<dependency>
    <groupId>com.raynigon.unit-api</groupId>
    <artifactId>jackson-starter</artifactId>
    <version>{{latest_version}}</version>
</dependency>
<dependency>
    <groupId>com.raynigon.unit-api</groupId>
    <artifactId>jpa-starter</artifactId>
    <version>{{latest_version}}</version>
</dependency>
```

--------------------------------

### JSON Example: String Input with Unit (m/s)

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/quickstart/spring-boot.md

Demonstrates accepting a string value with a different unit (m/s) for a quantity field in JSON. Jackson will parse this string and convert it to the target unit (`km/h` in this case).

```json
{
  "id": "65bf1872-d197-4d72-9950-2b7b4d74a674",
  "speed": "22.2222 m/s"
}
```

--------------------------------

### Add Spring Boot Unit-API Dependencies (Maven)

Source: https://github.com/raynigon/unit-api/blob/main/docs/spring-boot/index.md

Adds the required Unit-API starters for Spring Boot to your Maven project. These dependencies facilitate seamless integration with Jackson, JPA, and Springdoc, enhancing unit handling capabilities.

```xml
<dependency>
    <groupId>com.raynigon.unit-api</groupId>
    <artifactId>spring-boot-jackson-starter</artifactId>
    <version>{{latest_version}}</version>
</dependency>
<dependency>
    <groupId>com.raynigon.unit-api</groupId>
    <artifactId>spring-boot-jpa-starter</artifactId>
    <version>{{latest_version}}</version>
</dependency>
<dependency>
    <groupId>com.raynigon.unit-api</groupId>
    <artifactId>spring-boot-springdoc-starter</artifactId>
    <version>{{latest_version}}</version>
</dependency>
```

--------------------------------

### Add Jackson Module Dependency for unit-api

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/quickstart/jackson.md

Include the unit-api Jackson module in your project to enable Jackson serialization and deserialization of quantity types. This dependency should be added to your build configuration (pom.xml for Maven, build.gradle for Gradle).

```groovy
implementation("com.raynigon.unit-api:jackson-module:{{latest_version}}")
```

```xml
<dependency>
    <groupId>com.raynigon.unit-api</groupId>
    <artifactId>jackson-module</artifactId>
    <version>{{latest_version}}</version>
</dependency>
```

--------------------------------

### Register SystemOfUnits Service

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/quickstart/custom-units.md

This is a plain text file used for registering a custom `SystemOfUnits` with the Java service mechanism. The path `META-INF/services/javax.measure.spi.SystemOfUnits` and the fully qualified class name are essential for discovery.

```plaintext
com.company.product.units.CustomSystemOfUnits
```

--------------------------------

### Add Unit API Jackson and JPA Starters (Gradle)

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/quickstart/spring-boot.md

Include the Jackson and JPA starter dependencies for the unit-api in your Gradle build file. These starters enable automatic unit conversion for JSON serialization/deserialization and persistence, respectively.

```groovy
implementation("com.raynigon.unit-api:jackson-starter:{{latest_version}}")
implementation("com.raynigon.unit-api:jpa-starter:{{latest_version}}")
```

--------------------------------

### DummySystemOfUnits Implementation (Java/Groovy)

Source: https://github.com/raynigon/unit-api/blob/main/docs/java/index.md

Provides an example of a custom SystemOfUnits implementation. This is useful for extending the API with non-standard unit systems.

```Groovy
import com.raynigon.unit.api.core.units.SystemOfUnits
import com.raynigon.unit.api.core.units.UnknownUnit
import javax.measure.Unit

class DummySystemOfUnits implements SystemOfUnits {
    override getUnits(): Set<Unit<*>> {
        setOf(UnknownUnit.INSTANCE)
    }

    override getUnit(String symbol): Unit<*>? {
        null
    }
}
```

--------------------------------

### DummyUnit Definition (Java/Groovy)

Source: https://github.com/raynigon/unit-api/blob/main/docs/java/index.md

An example of defining a custom Unit. This is a prerequisite for creating custom SystemOfUnits implementations.

```Groovy
import com.raynigon.unit.api.core.units.AbstractUnit
import javax.measure.Unit

class DummyUnit extends AbstractUnit<Void> {
    // Dummy Unit - Does not represent any real physical quantity
    private static final DummyUnit INSTANCE = new DummyUnit()

    private DummyUnit() {
        super("dummy", "dummy", Void::class.java)
    }

    @Override
    protected Unit<Void> copy(String name, String symbol) {
        this
    }

    @Override
    protected Unit<Void> getSystemDefaultUnit() {
        this
    }

    @Override
    protected Unit<Void> getBaseUnits() {
        this
    }

    @Override
    protected Unit<Void> getConverterTo(Unit<Void> unit) {
        this
    }

    @Override
    protected Unit<Void> getConverterToAnyUnit(Unit<?> unit) {
        this
    }

    static getInstance(): DummyUnit {
        INSTANCE
    }
}
```

--------------------------------

### Declare Model with @JsonUnit Annotation

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/quickstart/jackson.md

Define your Java model classes using the @JsonUnit annotation to specify the target unit for quantity fields. This annotation guides Jackson on how to serialize and deserialize values, ensuring they are converted to the desired unit.

```java
public class BasicEntity {

    public String id;

    @JsonUnit(KilometrePerHour.class)
    public Quantity<Speed> speed;
}
```

--------------------------------

### Initialize Unit API Jackson with Basic Configuration

Source: https://github.com/raynigon/unit-api/blob/main/docs/java/jackson.md

This Groovy code snippet initializes the Unit API Jackson module with basic configuration. It's a minimal setup for integrating unit handling into Jackson's object mapping.

```groovy
new UnitApiJacksonModule()
```

--------------------------------

### Configure ObjectMapper with Unit API Features

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/modules/jackson-module.md

Java and Kotlin code examples demonstrating how to create an ObjectMapper instance and register the UnitApiModule with specific features enabled, such as SYSTEM_UNIT_ON_MISSING_ANNOTATION. This allows for customized handling of units during JSON processing.

```java
class JacksonConfiguration {

    public ObjectMapper createObjectMapper() {
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(
                UnitApiModule.withFeatures(UnitApiFeature.SYSTEM_UNIT_ON_MISSING_ANNOTATION)
        );
        return mapper;
    }
}
```

```kotlin
class JacksonConfiguration {

    fun createObjectMapper(): ObjectMapper {
        val mapper = ObjectMapper()
        mapper.registerModule(
                UnitApiModule.withFeatures(UnitApiFeature.SYSTEM_UNIT_ON_MISSING_ANNOTATION)
        )
        return mapper
    }
}
```

--------------------------------

### Define Custom SystemOfUnits in Kotlin

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/quickstart/custom-units.md

This Kotlin code defines a custom `SystemOfUnits` named 'CUSTOM_UNIT'. It specifies how to retrieve units based on their symbol or quantity type. This system is intended to be registered with the default Java service mechanism.

```kotlin
package com.company.product.units

import javax.measure.spi.SystemOfUnits
import javax.measure.Unit
import javax.measure.UnitConverter
import javax.measure.quantity.Speed
import javax.measure.spi.quantity
import javax.measure.spi.Dimension
import com.raynigon.unit_api.core.units.IUnit
import com.raynigon.unit_api.core.units.TransformedUnit
import com.raynigon.unit_api.core.units.system.MetrePerSecond
import com.raynigon.unit_api.core.units.system.KilometrePerHour
import com.raynigon.unit_api.core.units.converter.MultiplyConverter
import com.raynigon.unit_api.core.units.Dimension
import java.util.Collections

class CustomSystemOfUnits : SystemOfUnits {

    companion object {
        const val ID = "CUSTOM_UNIT"
        private val symbolToUnit: Map<String, Unit<*>> = listOf(
            KilometrePer100Hour()
        ).map { it.getSymbol() to it }.toMap()
    }

    override fun getName(): String {
        return ID
    }

    override fun <Q : Quantity<Q>?> getUnit(quantityType: Class<Q>): Unit<Q>? {
        return units.filterIsInstance<IUnit<Q>>().firstOrNull { quantityType.isAssignableFrom(it.quantityType) }
    }

    override fun getUnit(symbol: String): Unit<*>? {
        return symbolToUnit[symbol]
    }

    override fun getUnits(): MutableSet<out Unit<*>> {
        return symbolToUnit.values.toMutableSet()
    }

    override fun getUnits(dimension: Dimension?): MutableSet<out Unit<*>> {
        return Collections.emptySet()
    }
}
```

--------------------------------

### JSON Examples for Quantity Serialization

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/modules/jackson-module.md

Demonstrates various JSON formats that Jackson will accept for a 'speed' field annotated with @JsonUnit(KilometrePerHour.class). This includes plain numbers, strings, objects with value and unit, and strings with explicit units.

```json
{
    "id": "65bf1872-d197-4d72-9950-2b7b4d74a674",
    "speed": 80
}
```

```json
{
    "id": "65bf1872-d197-4d72-9950-2b7b4d74a674",
    "speed": "80"
}
```

```json
{
    "id": "65bf1872-d197-4d72-9950-2b7b4d74a674",
    "speed": {
        "value:" 80,
        "unit": "km/h"
    }
}
```

```json
{
    "id": "65bf1872-d197-4d72-9950-2b7b4d74a674",
    "speed": "80 km/h"
}
```

```json
{
    "id": "65bf1872-d197-4d72-9950-2b7b4d74a674",
    "speed": "22.2222 m/s"
}
```

--------------------------------

### Define KilometrePer100Hour Unit in Kotlin

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/quickstart/custom-units.md

This Kotlin code defines a custom `KilometrePer100Hour` unit, which represents speed. It inherits from `TransformedUnit` and is based on `KilometrePerHour` divided by 100. The `getSystemId` method links it to the `CustomSystemOfUnits`.

```kotlin
class KilometrePer100Hour :
    TransformedUnit<Speed>(
        "km/100h",
        "KilometrePer100Hour",
        KilometrePerHour().divide(100),
        MetrePerSecond(),
        MultiplyConverter.of(1.0)
    ),
    IUnit<Speed> {

    override fun getSystemId(): String {
        return CustomSystemOfUnits.ID
    }

    override fun getQuantityType(): Class<Speed> {
        return Speed::class.java
    }

    override fun isSystemUnit(): Boolean {
        return false
    }
}

@Suppress("FunctionName")
fun KilometrePer100Hour(value: Number): Quantity<Speed> = quantity(value, KilometrePer100Hour())
```

--------------------------------

### Kotlin Data Class with @JsonUnit Annotation

Source: https://github.com/raynigon/unit-api/blob/main/docs/spring-boot/springdoc.md

Example of a Kotlin data class demonstrating the usage of the `@JsonUnit` annotation. This annotation is used to specify the unit for a `Quantity<?>` property, which will then be reflected in the generated API documentation.

```kotlin
data class TelemetryRecordRequest(

    @JsonUnit(MilliSecond::class)
    val rtt: Quantity<Time>,
    val fuel: TelemetryFuel,
    val sensors: TelemetrySensors,
    val energy: TelemetryEnergy,
    val computer: TelemetryComputer
)

data class TelemetryFuel(
    val nto: Quantity<Mass>,
    val hydrazine: Quantity<Mass>
)
```

--------------------------------

### Use Custom Unit in Kotlin Data Class

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/quickstart/custom-units.md

This Kotlin data class `SpeedResponse` demonstrates how to use a custom unit (`KilometrePer100Hour`) with the `@JsonUnit` annotation for serialization/deserialization purposes.

```kotlin
data class SpeedResponse(

    @JsonUnit(KilometrePer100Hour::class)
    val speed: Quantity<Speed>?
)
```

--------------------------------

### Declare Quantity Field in Spring Boot JPA Entity (Java)

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/quickstart/spring-boot.md

Configure a JPA entity to persist unit-aware quantities. This involves using the `@JpaUnit` annotation and defining a Hibernate `@TypeDef` for the `Quantity` type. The `@Column` annotation may require `columnDefinition` based on your database.

```java
@Entity
@Table("basic_entity")
@TypeDef(
        name = "quantity",
        typeClass = QuantityType.class,
        defaultForType = Quantity.class
)
public class BasicEntity {

    @Id
    @Column(name="id")
    public String id;
    
    @JpaUnit(KilometrePerHour.class)
    @Column(name="speed")
    public Quantity<Speed> speed;
}
```

--------------------------------

### Define Model for Unit API Jackson Serialization

Source: https://github.com/raynigon/unit-api/blob/main/docs/java/jackson.md

This Groovy code defines an example entity class with a 'speed' attribute. When used with the Unit API Jackson module, Jackson can serialize and deserialize this 'speed' attribute, automatically handling unit conversions.

```groovy
package com.raynigon.unit.api.jackson.helpers

import com.raynigon.unit.api.core.unit.SIUnits.SPEED as SPEED_UNIT
import io.github.unitsofmeasurement.UnitOfUnit
import jakarta.persistence.Id
import org.springframework.data.mongodb.core.mapping.Document

@Document
class ExampleEntity {

    @Id
    String id

    @UnitOfUnit(SPEED_UNIT)
    Number speed

    @Override
    String toString() {
        return "ExampleEntity(id:'${id}', speed:${speed})"
    }
}
```

--------------------------------

### Define JPA Entity with Unit Type

Source: https://github.com/raynigon/unit-api/blob/main/docs/spring-boot/jpa.md

Example of a JPA Entity in Java that uses the Raynigon Unit API for a 'speed' field. It demonstrates the use of `@Entity`, `@Table`, `@Id`, `@Column`, `@JpaUnit`, and `@Type` annotations to map a unit-aware quantity to a database column.

```java
@Entity
@Table("basic_entity")
public class BasicEntity {

    @Id
    @Column(name="id")
    public String id;
    
    @JpaUnit(KilometrePerHour.class)
    @Type(QuantityType.class)
    @Column(name="speed")
    public Quantity<Speed> speed;
}
```

--------------------------------

### Add Jackson Starter Dependency (Gradle)

Source: https://github.com/raynigon/unit-api/blob/main/docs/spring-boot/jackson.md

This snippet shows how to add the Jackson Starter dependency to your project using Gradle. Ensure you replace '{{latest_version}}' with the actual latest version of the library.

```groovy
implementation("com.raynigon.unit-api:spring-boot-jackson-starter:{{latest_version}}")
```

--------------------------------

### Add Jackson Starter Dependency (Maven)

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/modules/jackson-starter.md

This snippet demonstrates how to add the Unit-API Jackson Starter dependency to a Maven project. It requires the Maven build tool and an XML configuration file.

```xml
<dependency>
    <groupId>com.raynigon.unit-api</groupId>
    <artifactId>jackson-starter</artifactId>
    <version>{{latest_version}}</version>
</dependency>
```

--------------------------------

### Add Jackson Starter Dependency (Gradle)

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/modules/jackson-starter.md

This snippet shows how to add the Unit-API Jackson Starter dependency to a Gradle project. It requires the Gradle build tool.

```groovy
implementation("com.raynigon.unit-api:jackson-starter:{{latest_version}}")
```

--------------------------------

### Add Springdoc Starter Dependency

Source: https://github.com/raynigon/unit-api/blob/main/docs/spring-boot/springdoc.md

Instructions for adding the Springdoc starter dependency to your project's build configuration. This enables integration between Unit API and Springdoc for enhanced API documentation.

```groovy
implementation("com.raynigon.unit-api:spring-boot-springdoc-starter:{{latest_version}}")
```

```xml
<dependency>
    <groupId>com.raynigon.unit-api</groupId>
    <artifactId>spring-boot-springdoc-starter</artifactId>
    <version>{{latest_version}}</version>
</dependency>
```

--------------------------------

### Add Jackson Starter Dependency (Maven)

Source: https://github.com/raynigon/unit-api/blob/main/docs/spring-boot/jackson.md

This snippet shows how to add the Jackson Starter dependency to your project using Maven. Replace '{{latest_version}}' with the appropriate version number.

```xml
<dependency>
        <groupId>com.raynigon.unit-api</groupId>
        <artifactId>spring-boot-jackson-starter</artifactId>
        <version>{{latest_version}}</version>
    </dependency>
```

--------------------------------

### Add JPA Starter Dependency for Gradle

Source: https://github.com/raynigon/unit-api/blob/main/docs/spring-boot/jpa.md

This snippet shows how to add the Raynigon Unit API Spring Boot JPA starter dependency to your project using Gradle. This enables JPA integration for unit types.

```groovy
implementation("com.raynigon.unit-api:spring-boot-jpa-starter:{{latest_version}}")
```

--------------------------------

### Add JPA Starter Dependency for Maven

Source: https://github.com/raynigon/unit-api/blob/main/docs/spring-boot/jpa.md

This snippet shows how to add the Raynigon Unit API Spring Boot JPA starter dependency to your project using Maven. This enables JPA integration for unit types.

```xml
<dependency>
        <groupId>com.raynigon.unit-api</groupId>
        <artifactId>spring-boot-jpa-starter</artifactId>
        <version>{{latest_version}}</version>
    </dependency>
```

--------------------------------

### Register SystemOfUnits via SPI (Text)

Source: https://github.com/raynigon/unit-api/blob/main/docs/java/index.md

Shows the configuration for registering a custom SystemOfUnits using Java's Service Provider Interface (SPI). This requires creating a specific file in META-INF/services.

```Plain text
com.raynigon.unit.api.core.service.testdata.DummySystemOfUnits
```

--------------------------------

### Enable SYSTEM_UNIT_ON_MISSING_ANNOTATION (Properties)

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/modules/jackson-starter.md

This snippet shows how to enable the SYSTEM_UNIT_ON_MISSING_ANNOTATION feature for the Unit-API Jackson Starter using Spring's application.properties file. This feature uses the system unit for quantities when no specific annotation is present.

```properties
spring.jackson.unit-api.features.SYSTEM_UNIT_ON_MISSING_ANNOTATION=true
```

--------------------------------

### Initialize Unit API Jackson with Features

Source: https://github.com/raynigon/unit-api/blob/main/docs/java/jackson.md

This Groovy code snippet shows how to initialize the Unit API Jackson module with specific features enabled. This allows for more advanced control over how units are handled during JSON serialization and deserialization.

```groovy
new UnitApiJacksonModule().with(UnitApiJacksonModule.Feature.SYSTEM_UNIT_ON_MISSING_ANNOTATION)
```

--------------------------------

### Create Temperature Quantity (Java/Groovy)

Source: https://github.com/raynigon/unit-api/blob/main/docs/java/index.md

Shows how to create a Temperature Quantity object, specifically in Celsius, using the Raynigon Unit API. This highlights the API's support for various units.

```Groovy
import com.raynigon.unit.api.core.units.si.temperature.Celsius
import javax.measure.unit.Units

// Given
val temperature = Units.getInstance().getQuantity(Celsius::class.java).returnQuantity(25.0)
```

--------------------------------

### Create Length Quantity (Java/Groovy)

Source: https://github.com/raynigon/unit-api/blob/main/docs/java/index.md

Demonstrates the creation of a Length Quantity object using the API. This is a fundamental operation for representing physical quantities.

```Groovy
import com.raynigon.unit.api.core.units.si.length.Metre
import javax.measure.unit.Units

// Given
val length = Units.getInstance().getQuantity(Metre::class.java).returnQuantity(10.0)
```

--------------------------------

### Register SystemOfUnits in Code (Java/Groovy)

Source: https://github.com/raynigon/unit-api/blob/main/docs/java/index.md

Demonstrates how to programmatically register a custom SystemOfUnits with the UnitsApiService. This makes the custom units available for use.

```Groovy
import com.raynigon.unit.api.core.service.UnitsApiService
import com.raynigon.unit.api.core.units.SystemOfUnits

// Given
val unitsApiService = UnitsApiService.getInstance()
val customSystemOfUnits: SystemOfUnits = DummySystemOfUnits()

// When
unitsApiService.addSystemOfUnits(customSystemOfUnits)
```

--------------------------------

### Temperature Calculation (Java/Groovy)

Source: https://github.com/raynigon/unit-api/blob/main/docs/java/index.md

Illustrates performing arithmetic operations with Temperature Quantity objects. This showcases the API's implementation of JSR-385's arithmetic functionalities.

```Groovy
import com.raynigon.unit.api.core.units.si.temperature.Celsius
import javax.measure.unit.Units

// Given
val temp1 = Units.getInstance().getQuantity(Celsius::class.java).returnQuantity(25.0)
val temp2 = Units.getInstance().getQuantity(Celsius::class.java).returnQuantity(10.0)

// When
val result = temp1.add(temp2)
```

--------------------------------

### Add Unit API Jackson Dependency to Gradle Project

Source: https://github.com/raynigon/unit-api/blob/main/docs/java/jackson.md

This snippet demonstrates how to add the Unit API Jackson module dependency to your Gradle project's build.gradle file. This enables Jackson integration for unit handling within your application.

```groovy
implementation("com.raynigon.unit-api:unit-api-jackson:{{latest_version}}")
```

--------------------------------

### Kotlin Time Quantity from Java Duration Conversion

Source: https://github.com/raynigon/unit-api/blob/main/docs/kotlin/index.md

Demonstrates how to create a Kotlin `Quantity<Time>` object from a Java `Duration` object using an extension method. Ensure the extension methods are imported.

```kotlin
val duration: Duration = Duration.ofSeconds(10)
val quantity: Quantity<Time> = duration.toQuantity()
```

--------------------------------

### Kotlin Pythagorean Theorem Calculation

Source: https://github.com/raynigon/unit-api/blob/main/docs/kotlin/index.md

Provides a function `pythagoreanTheorem` to calculate the length of the hypotenuse in a right-angled triangle given the lengths of the other two sides. Both inputs and the output are Quantity objects.

```kotlin
val a: Quantity<Length> = Metre(3)
val b: Quantity<Length> = Metre(4)
val c: Quantity<Length> = pythagoreanTheorem(a, b) // = 5m
```

--------------------------------

### Kotlin Quantity Comparison Operator

Source: https://github.com/raynigon/unit-api/blob/main/docs/kotlin/index.md

Demonstrates the use of the less than operator (<) for comparing two Quantity objects of the same unit type. This allows for direct comparison of values.

```kotlin
val small = Metre(3)
val large = Metre(4)
val comp = small < large // true
```

--------------------------------

### Add Unit API Jackson Dependency to Maven Project

Source: https://github.com/raynigon/unit-api/blob/main/docs/java/jackson.md

This snippet shows how to add the Unit API Jackson module dependency to your Maven project's pom.xml file. This is required to enable Jackson integration for unit handling.

```xml
<dependency>
    <groupId>com.raynigon.unit-api</groupId>
    <artifactId>unit-api-jackson</artifactId>
    <version>{{latest_version}}</version>
</dependency>
```

--------------------------------

### Add unit-api Kotlin Dependency (Maven)

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/modules/kotlin-module.md

Adds the unit-api Kotlin module as a dependency to your project using Maven. Ensure you replace {{latest_version}} with the actual latest version of the library.

```xml
<dependency>
    <groupId>com.raynigon.unit-api</groupId>
    <artifactId>unit-api-kotlin</artifactId>
    <version>{{latest_version}}</version>
</dependency>
```

--------------------------------

### Kotlin Quantity Multiplication with Factor

Source: https://github.com/raynigon/unit-api/blob/main/docs/kotlin/index.md

Illustrates multiplying a Quantity object by a scalar factor (Double). The result is a new Quantity with the scaled value.

```kotlin
val x = Quantities.getQuantity(3, Units.METRE)
val y = 2.0
val result = x * y // "6m"
```

--------------------------------

### Kotlin Quantity Division by Factor

Source: https://github.com/raynigon/unit-api/blob/main/docs/kotlin/index.md

Demonstrates dividing a Quantity object by a scalar factor (Double). The result is a new Quantity with the scaled value.

```kotlin
val x = Quantities.getQuantity(4, Units.METRE)
val y = 2.0
val result = x / y // "2m"
```

--------------------------------

### Kotlin Quantity Addition Operator

Source: https://github.com/raynigon/unit-api/blob/main/docs/kotlin/index.md

Shows how to use the addition operator (+) to combine two Quantity objects of the same unit type. The result is a new Quantity with the summed value.

```kotlin
val x = Metre(3)
val y = Metre(4)
val result = x + y // "7m"
```

--------------------------------

### Include Unit API Kotlin Module in Maven

Source: https://github.com/raynigon/unit-api/blob/main/docs/kotlin/index.md

Add the unit-api Kotlin module as a dependency in your Maven pom.xml file. This makes the library's functionalities available in your project.

```xml
<dependency>
        <groupId>com.raynigon.unit-api</groupId>
        <artifactId>unit-api-kotlin</artifactId>
        <version>{{latest_version}}</version>
    </dependency>
```

--------------------------------

### Kotlin Time Quantity to Java Duration Conversion

Source: https://github.com/raynigon/unit-api/blob/main/docs/kotlin/index.md

Shows how to convert a Kotlin `Quantity<Time>` object to a Java `Duration` object using an extension method. Ensure the extension methods are imported.

```kotlin
val quantity: Quantity<Time> = Second(10)
val duration: Duration = quantity.toDuration()
```

--------------------------------

### Kotlin Quantity Multiplication Operator

Source: https://github.com/raynigon/unit-api/blob/main/docs/kotlin/index.md

Demonstrates the multiplication operator (*) for Quantity objects. When multiplying two quantities, the result is a new quantity with units derived from the multiplication of the base units.

```kotlin
val x = Metre(3)
val y = Metre(4)
val result = x * y // "12m²"
```

--------------------------------

### Include Unit API Kotlin Module in Gradle

Source: https://github.com/raynigon/unit-api/blob/main/docs/kotlin/index.md

Add the unit-api Kotlin module as a dependency in your Gradle build file. This allows you to use the library's features in your Kotlin projects.

```groovy
implementation("com.raynigon.unit-api:unit-api-kotlin:{{latest_version}}")
```

--------------------------------

### Kotlin Quantity Division Operator

Source: https://github.com/raynigon/unit-api/blob/main/docs/kotlin/index.md

Shows the division operator (/) for Quantity objects. Dividing two quantities results in a dimensionless quantity (a number).

```kotlin
val x = Metre(8)
val y = Metre(4)
val result = y / x // "2"
```

--------------------------------

### Convert Java Duration to Time Quantity in Kotlin

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/modules/kotlin-module.md

Demonstrates converting a Java `Duration` object into a Kotlin `Quantity<Time>` object using an extension method. This facilitates using Java time representations within the unit-api framework.

```kotlin
import java.time.Duration

val duration: Duration = Duration.ofSeconds(10)
val quantity: Quantity<Time> = duration.toQuantity()
```

--------------------------------

### Kotlin Quantity Substraction Operator

Source: https://github.com/raynigon/unit-api/blob/main/docs/kotlin/index.md

Illustrates the use of the subtraction operator (-) for finding the difference between two Quantity objects of the same unit type. The result is a new Quantity representing the difference.

```kotlin
val x = Metre(3)
val y = Metre(4)
val result = y - x // "1m"
```

--------------------------------

### Convert Time Quantity to Java Duration in Kotlin

Source: https://github.com/raynigon/unit-api/blob/main/docs/_dep/modules/kotlin-module.md

Shows how to convert a Kotlin `Quantity<Time>` object (e.g., `Second`) into a Java `Duration` object using an extension method. This is useful for interoperability with Java libraries.

```kotlin
import java.time.Duration

val quantity: Quantity<Time> = Second(10)
val duration: Duration = quantity.toDuration()
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.