Class annotation used to assist in the creation of tuple constructors in classes. If the class is also annotated with @ImmutableBase, then the generated constructor will contain additional code needed for immutable classes. Should be used with care with other annotations which create constructors - see "Known Limitations" for more details.

It allows you to write classes in this shortened form:

@groovy.transform.TupleConstructor class Customer {
    String first, last
    int age
    Date since
    Collection favItems
}
def c1 = new Customer(first:'Tom', last:'Jones', age:21, since:new Date(), favItems:['Books', 'Games'])
def c2 = new Customer('Tom', 'Jones', 21, new Date(), ['Books', 'Games'])
def c3 = new Customer('Tom', 'Jones')

The @TupleConstructor annotation instructs the compiler to execute an AST transformation which adds the necessary constructor method to your class.

A tuple constructor is created with a parameter for each property (and optionally field and super properties). The default order is properties, pseudo/JavaBean properties and then fields for parent classes first (if includeSuperXxx annotation attributes are used). A default value is provided (using Java's default values) for all parameters in the constructor. Groovy's normal conventions then allows any number of parameters to be left off the end of the parameter list including all of the parameters - giving a no-arg constructor which can be used with the map-style naming conventions.

The order of parameters is given by the properties of any super classes (if includeSuperProperties is set) with the most super first followed by the properties of the class followed by the fields of the class (if includeFields is set). Within each grouping the order is as attributes appear within the respective class.

More examples:

//--------------------------------------------------------------------------
import groovy.transform.TupleConstructor

@TupleConstructor()
class Person {
    String name
    List likes
    private boolean active = false
}

def person = new Person('mrhaki', ['Groovy', 'Java'])

assert person.name == 'mrhaki'
assert person.likes == ['Groovy', 'Java']

person = new Person('mrhaki')

assert person.name == 'mrhaki'
assert !person.likes

//--------------------------------------------------------------------------
// includeFields in the constructor creation.
import groovy.transform.TupleConstructor

@TupleConstructor(includeFields=true)
class Person {
    String name
    List likes
    private boolean active = false

    boolean isActivated() { active }
}

def person = new Person('mrhaki', ['Groovy', 'Java'], true)

assert person.name == 'mrhaki'
assert person.likes == ['Groovy', 'Java']
assert person.activated

//--------------------------------------------------------------------------
// use force attribute to force creation of constructor
// even if we define our own constructors.
import groovy.transform.TupleConstructor

@TupleConstructor(force=true)
class Person {
    String name
    List likes
    private boolean active = false

    Person(boolean active) {
        this.active = active
    }

    boolean isActivated() { active }
}

def person = new Person('mrhaki', ['Groovy', 'Java'])

assert person.name == 'mrhaki'
assert person.likes == ['Groovy', 'Java']
assert !person.activated

person = new Person(true)

assert person.activated

//--------------------------------------------------------------------------
// include properties and fields from super class.
import groovy.transform.TupleConstructor

@TupleConstructor(includeFields=true)
class Person {
    String name
    List likes
    private boolean active = false

    boolean isActivated() { active }
}

@TupleConstructor(callSuper=true, includeSuperProperties=true, includeSuperFields=true)
class Student extends Person {
    List courses
}

def student = new Student('mrhaki', ['Groovy', 'Java'], true, ['IT'])

assert student.name == 'mrhaki'
assert student.likes == ['Groovy', 'Java']
assert student.activated
assert student.courses == ['IT']

Custom visibility:

• The @TupleConstructor annotation generates a public constructor unless an applicable VisibilityOptions annotation is also present. It can be useful to change the visibility if you want to also create a builder or provide your own static factory method for object creation. You can make the constructor private and access it from the builder or your factory method. (Note: you'll probably want to use @CompileStatic in conjunction with such an approach since dynamic Groovy currently gives the ability to access even private constructors.)
• An optional visibilityId attribute can be specified. If present, it must match the optional id attribute of an applicable VisibilityOptions annotation. This can be useful if multiple VisibilityOptions annotations are needed.

Custom property handling:

• The @TupleConstructor annotation supports customization using @PropertyOptions which allows a custom property handler to be defined. This is most typically used behind the scenes by the @Immutable meta-annotation but you can also define your own handler. If a custom handler is present, it will determine the code generated when initializing any property (or field).

Named-argument support:

• Groovy supports named-arguments for classes with a no-arg constructor or a constructor with a Map as the first argument. This is compatible with the default kind of constructor(s) that @TupleConstructor produces.
• If the defaults annotation attribute is set to false, and no other map-based constructor are added then named-argument processing will not be available.
• If there is more than one included property (and/or field) and the first property (or field) has type Object, AbstractMap, Map or HashMap, then a special LinkedHashMap constructor will be created in addition to the tuple constructor to support named parameters in the normal way. This won't be created if the class is already annotated with @MapConstructor or if the defaults annotation attribute is set to false.
• If the first property (or field) has type LinkedHashMap or if there is a single Object, AbstractMap, Map or HashMap property (or field), then no additional constructor will be added and Groovy's normal map-style naming conventions will not be available.

Known limitations/special cases:

• This AST transform might become a no-op if you are defining your own constructors or combining with other AST transforms which create constructors (e.g. @InheritConstructors); the order in which the particular transforms are processed becomes important in that case. See the force attribute for further details about customizing this behavior.
• This AST transform normally uses default parameter values which creates multiple constructors under the covers. You should use with care if you are defining your own constructors or combining with other AST transforms which create constructors (e.g. @InheritConstructors); the order in which the particular transforms are processed becomes important in that case. See the defaults attribute for further details about customizing this behavior.