Mappie

https://mappie.tech
Admin
Mappie is a Kotlin Multiplatform compiler plugin that generates performant object mapping code at...
Tokens:9,630
Snippets:156
Trust Score:5
Update:1 month ago
Show doc for...
Tokens:
Raw
### Java Person Class Example

Source: https://mappie.tech/object-mapping/java-compatibility

This Java class demonstrates the standard getter convention that Mappie uses for property inference.

```java
class Person {
    private String name;
    
    public String getName() {
        return name;
    }
}
```

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

### Define Data Class without Backing Property

Source: https://mappie.tech/object-mapping/constructing-explicit-mappings

Example of a data class where a constructor parameter does not have a corresponding backing property.

```kotlin
data class PersonDto(
    val name: String,
    val age: Int,
    description: String,
)
```

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

### Define Mismatched Enum Classes

Source: https://mappie.tech/enum-mapping/entry-mapping

Example of two enum classes, Color and Colour, that contain different entries.

```kotlin
enum class Color { RED, GREEN, BLUE, ORANGE; }

enum class Colour { RED, GREEN, BLUE, OTHER; }
```

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

### Define Person and PersonDto data classes

Source: https://mappie.tech/object-mapping/constructing-explicit-mappings

Example data classes where PersonDto contains an extra description property not present in Person.

```kotlin
data class Person(
    val name: String, 
    val age: Int,
)

data class PersonDto(
    val name: String, 
    val age: Int, 
    val description: String,
)
```

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

### Generic Local Conversion Method

Source: https://mappie.tech/object-mapping/local-conversion-methods

Local conversion methods can be generic, allowing them to handle conversions for various types. This example shows a generic method to convert a list to a set.

```kotlin
data class Input(val items: List<String>)
data class Output(val items: Set<String>)

object Mapper : ObjectMappie<Input, Output>() {

    fun <T> toSet(list: List<T>): Set<T> = list.toSet()

    override fun map(from: Input) = mapping()
}
```

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

### Equivalent syntax for fromPropertyNotNull

Source: https://mappie.tech/object-mapping/constructing-explicit-mappings

Shows the shorthand syntax for mapping nullable types to non-nullable types using fromPropertyNotNull.

```kotlin
to::x fromProperty from::y transform { it!! }
```

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

### Apply Mappie Gradle Plugin (Kotlin DSL)

Source: https://mappie.tech/getting-started/gradle-configuration

Apply the Mappie Gradle plugin in your build.gradle.kts file.

```kotlin
plugins {
    id("tech.mappie.plugin") version "version"
}
```

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

### Global Mappie configuration options

Source: https://mappie.tech/getting-started/kotlin-toolchain-configuration

Detailed configuration options for the Mappie compiler plugin within the module.yaml file.

```yaml
settings:
  kotlin:
    compilerPlugins:
      - id: mappie
        dependency: tech.mappie:mappie-compiler-plugin:version
        options:
          output-dir: build/mappie                                     # Required. 
          use-default-arguments: false                                 # Disable using default arguments in implicit mappings
          strict-enums: false                                          # Do not report an error if not all enum sources are mapped
          strict-platform-type-nullability: false                      # Allow unsafe assigning Java platform types to non-nullable targets
          strict-visibility: true                                      # Allow calling constructors not visible from the calling scope
          report-enabled: true                                         # Enable report generation
```

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

### Apply Mappie Gradle Plugin (Groovy DSL)

Source: https://mappie.tech/getting-started/gradle-configuration

Apply the Mappie Gradle plugin in your build.gradle file.

```groovy
plugins {
    id "tech.mappie.plugin" version "version"
}
```

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

### Configure Mappie Gradle Options

Source: https://mappie.tech/getting-started/gradle-configuration

Configure Mappie's behavior globally via the Gradle build file. These settings can be overridden per mapper using annotations.

```kotlin
mappie {
    useDefaultArguments = false // Disable using default arguments in implicit mappings
    strictness {
        enums = false // Do not report an error if not all enum sources are mapped
        platformTypeNullability = true // Enable strict nullability checks for platform types in mappings
        visibility = true // Allow calling constructors not visible from the calling scope
    }
    reporting {
        enabled = true // Enable report generation
    }
}
```

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

### Create ObjectMappie for Implicit Mapping

Source: https://mappie.tech/object-mapping/inferring-implicit-mappings

Instantiate ObjectMappie with source and target types. Mappie will automatically infer mappings if properties match.

```kotlin
object PersonMapper : ObjectMappie<Person, PersonDto>()
```

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

### Configure Mappie Plugin Options

Source: https://mappie.tech/getting-started/maven-configuration

Set various configuration options for the Mappie plugin within the pom.xml. These options control aspects like default argument usage, enum mapping strictness, and platform type nullability.

```xml
<pluginOptions>
    <option>mappie:use-default-arguments=false</option> 
    <option>mappie:strict-enums=false</option> 
    <option>mappie:strict-platform-type-nullability=false</option> 
    <option>mappie:strict-visibility=true</option> 
    <option>mappie:report-enabled=true</option> 
</pluginOptions>
```

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

### Map List of Objects with ObjectMappie

Source: https://mappie.tech/object-mapping/lists-and-sets

Use `mapList` to automatically map a `List` of objects using a defined `ObjectMappie`. Ensure the `ObjectMappie` is correctly set up for the source and target types.

```kotlin
object PersonMapper : ObjectMappie<Person, PersonDto>()

val persons: List<Person> = listOf(Person("Sjon"), Person("Piet"))
val personDtos: List<PersonDto> = PersonMapper.mapList(persons)
```

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

### Configure Mappie in module.yaml

Source: https://mappie.tech/getting-started/kotlin-toolchain-configuration

Add the Mappie compiler plugin to the settings section of your module.yaml file.

```yaml
settings:
  kotlin:
    compilerPlugins:
      - id: mappie
        dependency: tech.mappie:mappie-compiler-plugin:version
        options:
          output-dir: build/mappie
```

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

### Map property using fromProperty

Source: https://mappie.tech/object-mapping/constructing-explicit-mappings

Constructs a mapper where PersonDto.description is explicitly set to the value of Person.name.

```kotlin
object PersonMapper : ObjectMappie<Person, PersonDto>() {
    override fun map(from: Person): PersonDto = mapping {
        PersonDto::description fromProperty from::name
    }
}
```

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

### Define Data Classes for Person and Address

Source: https://mappie.tech/object-mapping/the-via-operator

Define the source data classes Person and Address.

```kotlin
data class Person(
    val name: String, 
    val address: Address,
)

data class Address(
    val street: String,
)
```

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

### Implement Enum Mapper with EnumMappie

Source: https://mappie.tech/enum-mapping/enum-mapping-overview

Implement an enum mapper by extending EnumMappie to automatically map between enum classes with identical entries.

```kotlin
object ColorMapper : EnumMappie<Color, Colour>()
```

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

### Map Multiple Sources to a Single Target in Kotlin

Source: https://mappie.tech/object-mapping/multiple-sources

Use ObjectMappie3 (or up to ObjectMappie5) to define mappings from multiple source objects to a single target object. Ensure explicit mapping logic is provided for properties that exist in multiple sources.

```kotlin
object PersonDtoMapper : ObjectMappie3<Person, Address, ContactInformation, PersonDto>() {
    override fun map(first: Person, second: Address, third: ContactInformation): PersonDto = mapping {
        // mapping logic
    }
}
```

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

### Define Data Classes and Mappers

Source: https://mappie.tech/getting-started/introduction

Define data classes, enums, and a custom mapper using Mappie's ObjectMappie and EnumMappie for compile-time object mapping.

```kotlin
data class Person(
    val firstname: String, 
    val age: Int, 
    val gender: Gender,
)
enum class Gender { MALE, FEMALE, NON_BINARY, OTHER }

data class PersonDto(
    val name: String, 
    val age: Int, 
    val gender: GenderDto,
)
enum class GenderDto { MALE, FEMALE, OTHER }

object PersonMapper : ObjectMappie<Person, PersonDto>() {
    override fun map(from: Person) = mapping {
        to::name fromProperty from::firstname
    }
    
    private object GenderMapper : EnumMappie<Gender, GenderDto>() {
        override fun map(from: Gender) = mapping {
            GenderDto.OTHER fromEnumEntry Gender.NON_BINARY
        }
    }
}
```

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

### Define Mapper for Address and AddressDto

Source: https://mappie.tech/object-mapping/the-via-operator

Define a mapper for the Address and AddressDto classes.

```kotlin
object AddressMapper : ObjectMappie<Address, AddressDto>()
```

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

### Map target via fromExpression

Source: https://mappie.tech/object-mapping/constructing-explicit-mappings

Sets a target property using a lambda function that accepts the source object for dynamic mapping.

```kotlin
object PersonMapper : ObjectMappie<Person, PersonDto>() {
    override fun map(from: Person): PersonDto = mapping {
        PersonDto::description fromExpression { from -> 
            "Description: ${from.name}" 
        }
    }
}
```

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

### Reference primary constructor in mapping

Source: https://mappie.tech/object-mapping/constructing-explicit-mappings

Use the mapping function with type arguments for all constructor parameters to select the primary constructor.

```kotlin
object PersonMapper : ObjectMappie<Person, PersonDto>() {
    override fun map(from: Person) = 
        mapping<String, Int, String>(::PersonDto)
}
```

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

### Add mappie-api dependency

Source: https://mappie.tech/getting-started/kotlin-toolchain-configuration

Include the required mappie-api dependency in your project configuration.

```yaml
dependencies:
  - tech.mappie:mappie-api:version
```

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

### Add Mappie API Dependency (Kotlin DSL)

Source: https://mappie.tech/getting-started/gradle-configuration

Manually add the mappie-api dependency in your build.gradle.kts file if using older Mappie versions or for explicit control.

```kotlin
dependencies {
    implementation("tech.mappie:mappie-api:version")
}
```

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

### Map List of Strings from List of Objects

Source: https://mappie.tech/object-mapping/lists-and-sets

Define a mapper for the element type (`Page` to `String`) and then use `IterableToListMapper` within the main object mapper (`Book` to `BookDto`) to map a list of complex objects to a list of strings. This is useful when the target collection contains simpler types derived from the source collection's elements.

```kotlin
data class Book(val pages: List<Page>)

data class Page(val text: String)

data class BookDto(val pages: List<String>)

object PageMapper : ObjectMappie<Page, String>() {
    override fun map(from: Page): String = from.text
}

object BookMapper : ObjectMappie<Book, BookDto>() {
    override fun map(from: Book): BookDto = mapping {
        BookDto::pages fromProperty Book::pages via IterableToListMapper(PageMapper)
    }
}
```

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

### Enable Lenient Naming Convention Globally

Source: https://mappie.tech/object-mapping/object-mapping-configuration

Globally enable lenient property name matching. This setting normalizes property names by converting to lowercase and removing separators.

```gradle
mappie {
    namingConvention = NamingConvention.LENIENT // Enable lenient property name matching
}
```

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

### Reusable Conversions via Interface

Source: https://mappie.tech/object-mapping/local-conversion-methods

Define common conversion methods in an interface and implement it in multiple mappers for maximum reuse. Both mappers will automatically use these methods.

```kotlin
interface CommonConverters {
    fun unwrap(wrapper: StringWrapper): String = wrapper.value
    fun unwrapInt(wrapper: IntWrapper): Int = wrapper.value
}

object PersonMapper : ObjectMappie<Person, PersonDto>(), CommonConverters {
    override fun map(from: Person) = mapping()
}

object EmployeeMapper : ObjectMappie<Employee, EmployeeDto>(), CommonConverters {
    override fun map(from: Employee) = mapping()
}
```

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

### Configure Kotlin Maven Plugin with Mappie

Source: https://mappie.tech/getting-started/maven-configuration

Add the Mappie compiler plugin to your kotlin-maven-plugin configuration. Ensure you have the correct version for both the plugin and the Mappie API dependency.

```xml
<plugin>
    <groupId>org.jetbrains.kotlin</groupId>
    <artifactId>kotlin-maven-plugin</artifactId>
    <version>...</version>
    
    <configuration>
        <compilerPlugins>
            <compilerPlugin>mappie</compilerPlugin>
        </compilerPlugins>
        <pluginOptions>
            ...
        </pluginOptions>
    </configuration>
    <dependencies>
        <dependency>
            <groupId>tech.mappie</groupId>
            <artifactId>mappie-maven-plugin</artifactId>
            <version>version</version>
        </dependency>
    </dependencies>
</plugin>
```

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

### Use Mappie Mapper

Source: https://mappie.tech/getting-started/introduction

Utilize the generated Mappie mapper to convert objects from one type to another using the map function.

```kotlin
val personDto = PersonMapper.map(Person("Sjon", 58, Gender.MALE))
```

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

### Handling Nullable Source to Non-Nullable Target

Source: https://mappie.tech/object-mapping/the-transform-operator

When mapping a nullable source property to a non-nullable target property, use the 'transform' operator with the Elvis operator (?:) to provide a default value if the source is null.

```kotlin
data class Dog(val name: String?)

data class DogDto(val name: String)

object DogMapper : ObjectMappie<Dog, DogDto>() {
    override fun map(from: Dog): DogDto = mapping {
        DogDto::name fromProperty Dog::name transform {
            it ?: "unknown"
        }
    }
}
```

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

### Map to Constructor Parameter via to()

Source: https://mappie.tech/object-mapping/constructing-explicit-mappings

Uses the to function to target a constructor parameter that cannot be referenced via a property reference.

```kotlin
object PersonMapper : ObjectMappie<Person, PersonDto>() {
    override fun map(from: Person): PersonDto = mapping {
        to("description") fromValue "a constant"
    }
}
```

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

### Reference secondary constructor in mapping

Source: https://mappie.tech/object-mapping/constructing-explicit-mappings

Use the mapping function with type arguments matching the secondary constructor parameters to select it.

```kotlin
object PersonMapper : ObjectMappie<Person, PersonDto>() {
    override fun map(from: Person) = 
        mapping<String, Int>(::PersonDto)
}
```

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

### Add Mappie API Dependency for JVM

Source: https://mappie.tech/getting-started/maven-configuration

Include the Mappie API dependency for JVM projects. Replace 'version' with the actual Mappie version you are using.

```xml
<dependency>
    <groupId>tech.mappie</groupId>
    <artifactId>mappie-api-jvm</artifactId>
    <version>version</version>
</dependency>
```

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

### Define Data Classes for Implicit Mapping

Source: https://mappie.tech/object-mapping/inferring-implicit-mappings

Define source and target data classes with matching property names and types to enable implicit mapping.

```kotlin
data class Person(val name: String, val age: Int)

data class PersonDto(val name: String, val age: Int)
```

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

### Define Data Classes for PersonDto and AddressDto

Source: https://mappie.tech/object-mapping/the-via-operator

Define the target data classes PersonDto and AddressDto.

```kotlin
data class PersonDto(
    val name: String, 
    val addressDto: AddressDto,
)

data class AddressDto(
    val street: String,
)
```

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

### Define Enum Classes for Mapping

Source: https://mappie.tech/enum-mapping/enum-mapping-overview

Define the source and target enum classes with identical entries for automatic mapping.

```kotlin
enum class Color {
    RED, GREEN, BLUE;
}

enum class Colour {
    RED, GREEN, BLUE;
}
```

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

### Default List Mapping in Mappie

Source: https://mappie.tech/object-mapping/lists-and-sets

When no specific mapping logic is required for the elements within a collection, Mappie can often perform the mapping implicitly. An empty `ObjectMappie` definition is sufficient if the source and target collection element types are identical or have default mappings.

```kotlin
object BookMapper : ObjectMappie<Book, BookDto>()
```

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

### Define Local Conversion Method in Mapper

Source: https://mappie.tech/object-mapping/local-conversion-methods

Define a conversion method directly within your mapper class to handle simple type conversions. Mappie automatically discovers and uses this method.

```kotlin
data class StringWrapper(val value: String)

data class Person(val name: StringWrapper)
data class PersonDto(val name: String)

object PersonMapper : ObjectMappie<Person, PersonDto>() {

    fun unwrap(wrapper: StringWrapper): String = wrapper.value

    override fun map(from: Person) = mapping()
}
```

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

### Add Mappie API Dependency (Groovy DSL)

Source: https://mappie.tech/getting-started/gradle-configuration

Manually add the mappie-api dependency in your build.gradle file if using older Mappie versions or for explicit control.

```groovy
dependencies {
    implementation "tech.mappie:mappie-api:version"
}
```

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

### Map target via fromValue

Source: https://mappie.tech/object-mapping/constructing-explicit-mappings

Sets a target property to a static value using the fromValue operator.

```kotlin
object PersonMapper : ObjectMappie<Person, PersonDto>() {
    override fun map(from: Person): PersonDto = mapping {
        PersonDto::description fromValue "unknown"
    }
}
```

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

### Reuse AddressMapper with Via Operator for Person Mapping

Source: https://mappie.tech/object-mapping/the-via-operator

Reuse the AddressMapper to construct a mapper for Person and PersonDto using the 'via' operator.

```kotlin
object PersonMapper : ObjectMappie<Person, PersonDto>() {
    override fun map(from: Person) = mapping {
        to::addressDto fromProperty from::address via AddressMapper
    }
}
```

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

### Use the to alias for property mapping

Source: https://mappie.tech/object-mapping/constructing-explicit-mappings

The 'to' alias provides a shorthand for the target type, reducing clutter when defining explicit mappings.

```kotlin
object PersonMapper : ObjectMappie<Person, PersonDto>() {
    override fun map(from: Person): PersonDto = mapping {
        to::streetname fromProperty from.address::street
    }
}
```

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

### Enable Lenient Naming Convention Locally

Source: https://mappie.tech/object-mapping/object-mapping-configuration

Enable lenient property name matching locally using an annotation. This allows matching properties with different naming conventions, like snake_case and camelCase.

```kotlin
import tech.mappie.api.config.UseNamingConvention
import tech.mappie.api.config.NamingConvention

@UseNamingConvention(NamingConvention.LENIENT)
object PersonMapper : ObjectMappie<PersonInput, PersonOutput>()
```

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

### Map Enum Entries with fromEnumEntry

Source: https://mappie.tech/enum-mapping/entry-mapping

Maps a specific source enum entry to a different target enum entry using fromEnumEntry.

```kotlin
object ColorMapper : EnumMappie<Color, Colour>() {
    override fun map(from: Color): Colour = mapping {
        Colour.OTHER fromEnumEntry Color.ORANGE
    }
}
```

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

### Configure Strict Visibility for Constructors

Source: https://mappie.tech/object-mapping/object-mapping-configuration

Globally allow calling constructors not visible from the calling scope. This setting enables mapping using private or protected constructors.

```gradle
mappie {
    strictness {
        visibility = true // Allow calling constructors not visible from the calling scope
    }
}
```

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

### Define PersonDto with multiple constructors

Source: https://mappie.tech/object-mapping/constructing-explicit-mappings

The PersonDto data class includes both a primary constructor and a secondary constructor.

```kotlin
data class PersonDto(
    val name: String, 
    val age: Int, 
    val description: String,
) {
    constructor(name: String, age: Int) : this(name, age, "description")
}
```

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

### Define Abstract Uppercase Enum Mapper

Source: https://mappie.tech/enum-mapping/inheriting-mappers

Create an abstract base mapper that capitalizes enum names. This is useful when multiple source enums map to target enums with capitalized names.

```kotlin
abstract class UppercaseEnumMapper<FROM : Enum<FROM>, TO : Enum<TO>>(
    private val entries: EnumEntries<TO>
) : EnumMappie<FROM, TO>() {
    override fun map(from: FROM) = 
        entries.first { it.name == from.name.uppercase() }
}
```

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

### Utilize Default Arguments in Target Class

Source: https://mappie.tech/object-mapping/inferring-implicit-mappings

Mappie uses default arguments from the target class constructor when no explicit mapping is provided for that property.

```kotlin
data class PersonDto(
    val name: String, 
    val age: Int, 
    val hasChildren: Boolean = false,
)
```

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

### Transforming Date of Birth to Age

Source: https://mappie.tech/object-mapping/the-transform-operator

Use the 'transform' operator to convert a source 'LocalDate' to a target 'DateTimePeriod' (age). This requires importing necessary date and time classes.

```kotlin
data class Person(val name: String, val dateOfBirth: LocalDate)

data class PersonDto(
    val name: String, 
    val age: DateTimePeriod,
)

object PersonMapper : ObjectMappie<Person, PersonDto>() {
    override fun map(from: Person): PersonDto = mapping {
        PersonDto::age fromProperty Person::dateOfBirth transform {
            Clock.todayIn(TimeZone.currentSystemDefault()).periodUntil(dateOfBirth) 
        }
    }
}
```

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

### Generate Mapper for Nested Enums

Source: https://mappie.tech/object-mapping/inferring-implicit-mappings

Mappie automatically generates nested mappers for enums if their entries match, even if the parent classes require explicit mapping.

```kotlin
data class Person(val name: String, val gender: Gender)
enum class Gender { MALE, FEMALE, OTHER; }

data class PersonDto(val name: String, val gender: GenderDto)
enum class GenderDto { MALE, FEMALE, OTHER; }
```

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

### Configure Strict Platform Type Nullability Validation

Source: https://mappie.tech/object-mapping/object-mapping-configuration

Disable strict validation for Java platform types assigned to non-nullable targets globally. This setting allows unsafe assignments.

```gradle
mappie {
    strictness {
        platformTypeNullability = false // Allow unsafe assigning Java platform types to non-nullable targets
    }
}
```

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

### Implicit List Mapping in Mappie

Source: https://mappie.tech/object-mapping/lists-and-sets

Mappie can often infer collection mappings automatically. If the element types are directly mappable, you may not need to explicitly define the collection mapping or use `IterableToListMapper`. This is the most concise way to map collections when Mappie's defaults suffice.

```kotlin
object BookMapper : ObjectMappie<Book, BookDto>() {
    override fun map(from: Book): BookDto = mapping {
        BookDto::pages fromProperty Book::pages
    }
}
```

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

### Concrete Enum Mappers Reusing Abstract Logic

Source: https://mappie.tech/enum-mapping/inheriting-mappers

Define concrete mappers that extend an abstract base mapper to reuse its functionality. This approach is suitable for different enum types that share the same mapping strategy.

```kotlin
object GenderMapper : UppercaseEnumMapper<Gender, GenderDto>(GenderDto.entries)
object EyeColorMapper : UppercaseEnumMapper<EyeColor, EyeColorDto>(EyeColorDto.entries)
```

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

### Kotlin PersonDto Data Class

Source: https://mappie.tech/object-mapping/java-compatibility

A Kotlin data class used as a target for mapping from a Java object. Mappie infers the 'name' property.

```kotlin
data class PersonDto(val name: String)
```

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

### Disable Default Arguments in Mappings

Source: https://mappie.tech/object-mapping/object-mapping-configuration

Globally disable the use of default arguments in implicit mappings. This ensures that all arguments are explicitly provided.

```gradle
mappie {
    useDefaultArguments = false // Disable using default arguments in implicit mappings
}
```

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

### Mappie Object Mapper for Java-Kotlin

Source: https://mappie.tech/object-mapping/java-compatibility

Defines a Mappie object mapper to map between a Java 'Person' object and a Kotlin 'PersonDto'. Mappie automatically infers the 'name' property mapping due to the getter convention in the Java class.

```kotlin
class PersonMapper : ObjectMappie<Person, PersonDto>()
```

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

### Override to Strict Naming Convention

Source: https://mappie.tech/object-mapping/object-mapping-configuration

Override the global lenient naming convention to strict mode for a specific mapper. This ensures exact property name matches.

```kotlin
@UseNamingConvention(NamingConvention.STRICT)
object StrictMapper : ObjectMappie<Input, Output>()
```

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

### Disable Strict Enum Mapping Globally (Gradle)

Source: https://mappie.tech/enum-mapping/enum-mapping-configuration

Add this configuration to your Gradle build file to disable strict enum mapping globally. This prevents errors when not all enum sources are mapped.

```gradle
mappie {
    strictness {
        enums = false // Do not report an error if not all enum sources are mapped 
    }
}
```

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

### Exclude Method from Automatic Mapping

Source: https://mappie.tech/object-mapping/local-conversion-methods

Annotate a method with @ExcludeFromMapping if it matches the conversion method signature but should not be used for automatic conversion. This is useful for utility methods.

```kotlin
import tech.mappie.api.config.ExcludeFromMapping

object PersonMapper : ObjectMappie<Person, PersonDto>() {

    @ExcludeFromMapping
    fun validateWrapper(wrapper: StringWrapper): String {
        require(wrapper.value.isNotBlank())
        return wrapper.value
    }

    override fun map(from: Person) = mapping {
        PersonDto::name fromProperty Person::name transform { it.value }
    }
}
```

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

### Throw Exception with thrownByEnumEntry

Source: https://mappie.tech/enum-mapping/entry-mapping

Configures the mapper to throw an IllegalStateException when a specific enum entry is encountered.

```kotlin
object ColorMapper : EnumMappie<Color, Colour>() {
    override fun map(from: Color): Colour = mapping {
        IllegalStateException() thrownByEnumEntry Color.ORANGE
    }
}
```

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

### Disable Strict Enum Mapping Locally

Source: https://mappie.tech/enum-mapping/enum-mapping-configuration

Apply this annotation to a specific mapper to disable strict enum mapping for that mapper only. This is useful when only a subset of mappers requires this relaxed behavior.

```java
@UseStrictEnums(false)
```
Tokens:
Raw