Package org.gradle.model

## Class RuleSource

- java.lang.Object
- - org.gradle.model.RuleSource

-     @Incubating
      public class RuleSource
      extends java.lang.Object

  A marker type for a class that is a collection of rules.

  A rule source is not used like a regular Java object. It is a stateless container of methods and possibly constants.

  Please consult the “Rule based model configuration” chapter of the Gradle User Manual for general information about “rules”.

  ### Rule methods

  Each method that is annotated with one of the following is considered a rule:

  - `Model`
  - `Defaults`
  - `Mutate`
  - `Finalize`
  - `Validate`
  - `Rules`
  - `ComponentType`
  - `ComponentBinaries`
  - `BinaryTasks`

  Each annotation specifies the type of the rule, which affects when it will be executed.

  The following constraints apply to all rule methods:

  - A method may only be annotated by at most one of the above annotations.
  - A rule method may be `static` or not; it makes no difference.
  - A rule method cannot be generic (i.e. cannot have type parameters).
  - With the exception of `Model` methods, all methods must have at least one parameter.
  - With the exception of `Model` methods, all methods must have a `void` return type.

  See `Model` for information on the significance of the return type of a `Model` method.

  #### Subjects and inputs

  Method rules declare the subject and any inputs as parameters to the method. With the exception of `Model` methods, the subject of the rule is the, required, first parameter and all subsequent parameters are inputs. For a non-void `Model` method, the subject (i.e. model element being created) is the return object. For a void `Model` method, the subject is the first method parameter.

  The `Path` annotation can be placed on any parameter (except the subject of `Model` rules) to indicate the model element to bind to. If there is no `Path` annotation, a “by-type” binding will be attempted. The binding scope is determined by how the rule source is applied.

  ### General class constraints

  Along with the constraints on individual rule methods by their associated annotation, the following are general constraints of rule source implementations:

  - Constructors are not allowed.
  - Inheritance hierarchies are not allowed (i.e. all rules sources must directly extend `RuleSource`).
  - Instance variables are not allowed.
  - Non-final static variables are not allowed (i.e. constants are allowed).
  - Methods cannot be overloaded.
  - Implementations cannot be generic (i.e. cannot use type parameters).

- - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `RuleSource()` |

  - ### Method Summary

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### RuleSource

          public RuleSource()