Package: groovy.lang

## [Java] Class ExpandoMetaClass

- groovy.lang.ExpandoMetaClass

- All Implemented Interfaces and Traits:
    GroovyObject

      public class ExpandoMetaClass
      extends MetaClassImpl
      implements GroovyObject

  ExpandoMetaClass is a MetaClass that behaves like an Expando, allowing the addition or replacement of methods, properties and constructors on the fly.

  Some examples of usage:

       // defines or replaces instance method:
       metaClass.myMethod = { args -> }

       // defines a new instance method
       metaClass.myMethod << { args -> }

       // creates multiple overloaded methods of the same name
       metaClass.myMethod << { String s -> } << { Integer i -> }

       // defines or replaces a static method with the 'static' qualifier
       metaClass.'static'.myMethod = { args ->  }

       // defines a new static method with the 'static' qualifier
       metaClass.'static'.myMethod << { args ->  }

       // defines a new constructor
       metaClass.constructor << { String arg -> }

       // defines or replaces a constructor
       metaClass.constructor = { String arg -> }

       // defines a new property with an initial value of "blah"
       metaClass.myProperty = "blah"

  ExpandoMetaClass also supports a DSL/builder like notation to combine multiple definitions together. So instead of this:

       Number.metaClass.multiply = { Amount amount -> amount.times(delegate) }
       Number.metaClass.div =      { Amount amount -> amount.inverse().times(delegate) }

  You can also now do this:

       Number.metaClass {
           multiply { Amount amount -> amount.times(delegate) }
           div      { Amount amount -> amount.inverse().times(delegate) }
       }

  ExpandoMetaClass also supports runtime mixins. While `@Mixin` allows you to mix in new behavior to classes you own and are designing, you can not easily mixin anything to types you didn't own, e.g. from third party libraries or from JDK library classes. Runtime mixins let you add a mixin on any type at runtime.

       interface Vehicle {
           String getName()
       }

       // Category annotation style
       @Category(Vehicle) class FlyingAbility {
           def fly() { "I'm the ${name} and I fly!" }
       }

       // traditional category style
       class DivingAbility {
           static dive(Vehicle self) { "I'm the ${self.name} and I dive!" }
       }

       // provided by a third-party, so can't augment using Mixin annotation
       class JamesBondVehicle implements Vehicle {
           String getName() { "James Bond's vehicle" }
       }

       // Can be added via metaClass, e.g.:
       // JamesBondVehicle.metaClass.mixin DivingAbility, FlyingAbility
       // Or using shorthand through DGM method on Class
       JamesBondVehicle.mixin DivingAbility, FlyingAbility

       assert new JamesBondVehicle().fly() ==
              "I'm the James Bond's vehicle and I fly!"
       assert new JamesBondVehicle().dive() ==
              "I'm the James Bond's vehicle and I dive!"

  As another example, consider the following class definitions:

       class Student {
           List schedule = []
           def addLecture(String lecture) { schedule << lecture }
       }

       class Worker {
           List schedule = []
           def addMeeting(String meeting) { schedule << meeting }
       }

  We can mimic a form of multiple inheritance as follows:

       class CollegeStudent {
           static { mixin Student, Worker }
       }
       new CollegeStudent().with {
           addMeeting('Performance review with Boss')
           addLecture('Learn about Groovy Mixins')
           println schedule
           println mixedIn[Student].schedule
           println mixedIn[Worker].schedule
       }

  Which outputs these lines when run:

       [Performance review with Boss]
       [Learn about Groovy Mixins]
       [Performance review with Boss]

  Perhaps some explanation is required here. The methods and properties of Student and Worker are added to CollegeStudent. Worker is added last, so for overlapping methods, its methods will be used, e.g. when calling `schedule`, it will be the schedule property (getSchedule method) from Worker that is used. The schedule property from Student will be shadowed but the `mixedIn` notation allows us to get to that too if we need as the last two lines show.

  We can also be a little more dynamic and not require the CollegeStudent class to be defined at all, e.g.:

       def cs = new Object()
       cs.metaClass {
           mixin Student, Worker
           getSchedule {
               mixedIn[Student].schedule + mixedIn[Worker].schedule
           }
       }
       cs.with {
           addMeeting('Performance review with Boss')
           addLecture('Learn about Groovy Mixins')
           println schedule
       }

  Which outputs this line when run:

       [Learn about Groovy Mixins, Performance review with Boss]

  As another example, we can also define a no dup queue by mixing in some Queue and Set functionality as follows:

       def ndq = new Object()
       ndq.metaClass {
           mixin ArrayDeque
           mixin HashSet
           leftShift = { Object o  ->
               if (!mixedIn[Set].contains(o)) {
                   mixedIn[Queue].push(o)
                   mixedIn[Set].add(o)
               }
           }
       }
       ndq << 1
       ndq << 2
       ndq << 1
       assert ndq.size() == 2

  As a final example, we sometimes need to pass such mixed in classes or objects into Java methods which require a given static type but the ExpandoMetaClass mixin approach uses a very dynamic approach based on duck typing rather than static interface definitions, so doesn't by default produce objects matching the required static type. Luckily, there is a mixins capability within ExpandoMetaClass which supports the use of Groovy's common 'as StaticType' notation to produce an object having the correct static type so that it can be passed to the Java method call in question. A slightly contrived example illustrating this feature:

       class CustomComparator implements Comparator {
           int compare(Object a, b) { return a.size() - b.size() }
       }

       class CustomCloseable implements Closeable {
           void close() { println 'Lights out - I am closing' }
       }

       import static mypackage.IOUtils.closeQuietly
       import static java.util.Collections.sort
       def o = new Object()
       o.metaClass.mixin CustomComparator, CustomCloseable
       def items = ['a', 'bbb', 'cc']
       sort(items, o as Comparator)
       println items                // => [a, cc, bbb]
       closeQuietly(o as Closeable) // => Lights out - I am closing

  Further details

  When using the default implementations of MetaClass, methods are only allowed to be added before initialize() is called. In other words you create a new MetaClass, add some methods and then call initialize(). If you attempt to add new methods after initialize() has been called, an error will be thrown. This is to ensure that the MetaClass can operate appropriately in multithreaded environments as it forces you to do all method additions at the beginning, before using the MetaClass.

  ExpandoMetaClass differs here from the default in that it allows you to add methods after initialize has been called. This is done by setting the initialize flag internally to false and then add the methods. Since this is not thread safe it has to be done in a synchronized block. The methods to check for modification and initialization are therefore synchronized as well. Any method call done through this metaclass will first check if the it is synchronized. Should this happen during a modification, then the method cannot be selected or called unless the modification is completed.

  Since:
    1.5

- - ### Nested Class Summary

    Nested classes
    Modifiers | Name | Description
    --- | --- | ---
    `protected class` | `ExpandoMetaClass.ExpandoMetaConstructor` | Handles the ability to use the left shift operator to append new constructors
    `protected class` | `ExpandoMetaClass.ExpandoMetaProperty` | Instances of this class are returned when using the `<<` left shift operator.

  - ### Field Summary

    Fields
    Modifiers | Name | Description
    --- | --- | ---
    `static String` | `CONSTRUCTOR` | Pseudo-property used by the expando DSL to define constructors.
    `static String` | `STATIC_QUALIFIER` | Pseudo-property used by the expando DSL to define static members.
    `boolean` | `inRegistry` | Indicates whether this expando meta class is registered in the global registry.

  - Inherited fields
    Fields inherited from class | Fields
    --- | ---
    `class MetaClassImpl` | `EMPTY_ARGUMENTS, INVOKE_METHOD_METHOD, METHOD_MISSING, PROPERTY_MISSING, STATIC_METHOD_MISSING, STATIC_PROPERTY_MISSING, getPropertyMethod, invokeMethodMethod, isGroovyObject, isMap, metaMethodIndex, registry, setPropertyMethod, theCachedClass, theClass`

  - ### Constructor Summary

    Constructors
    Constructor and description
    `ExpandoMetaClass(Class theClass, boolean register, boolean allowChangesAfterInit, MetaMethod[] add)` Creates an expando meta class with explicit registry behaviour and additional methods.
    `ExpandoMetaClass(MetaClassRegistry registry, Class theClass, boolean register, boolean allowChangesAfterInit, MetaMethod[] add)` Creates an expando meta class bound to a specific registry.
    `ExpandoMetaClass(Class theClass)` Constructs a new ExpandoMetaClass instance for the given class
    `ExpandoMetaClass(Class theClass, MetaMethod[] add)` Creates an unregistered expando meta class with additional initial methods.
    `ExpandoMetaClass(Class theClass, boolean register)` Constructs a new ExpandoMetaClass instance for the given class optionally placing the MetaClass in the MetaClassRegistry automatically
    `ExpandoMetaClass(Class theClass, boolean register, MetaMethod[] add)` Creates an expando meta class with optional global registration and additional initial methods.
    `ExpandoMetaClass(Class theClass, boolean register, boolean allowChangesAfterInit)` Constructs a new ExpandoMetaClass instance for the given class optionally placing the MetaClass in the MetaClassRegistry automatically

  - ### Methods Summary

    Methods
    Type Params | Return Type | Name and description
    --- | --- | ---
    `` | `public boolean` | `addMixinClass(MixinInMetaClass mixin)` Since: 6.0.0
    `` | `public Object` | `castToMixedType(Object obj, Class type)` Returns the mixed-in view of an object for the requested mixin type.
    `` | `protected void` | `checkInitalised()` * checks if the initialisation of the class id complete. * This method should be called as a form of assert, it is no * way to test if there is still initialisation work to be done. * Such logic must be implemented in a different way. * * throws: IllegalStateException if the initialisation is incomplete yet
    `` | `public ExpandoMetaClass` | `define(Closure closure)` Executes the expando definition DSL against this meta class.
    `` | `public static void` | `disableGlobally()` Call to disable the global use of ExpandoMetaClass
    `` | `public static void` | `enableGlobally()` Call to enable global use of ExpandoMetaClass within the registry.
    `` | `public MetaMethod` | `findMixinMethod(String methodName, Class[] arguments)` * Searches for a matching mixin method. * * Parameters: `methodName` - the method name * `arguments` - the parameter types * Returns: the matching mixin method, or `null` if none is found
    `` | `public List<MetaMethod>` | `getExpandoMethods()` Returns a list of expando MetaMethod instances added to this ExpandoMetaClass
    `` | `public Collection<MetaProperty>` | `getExpandoProperties()` Returns a list of MetaBeanProperty instances added to this ExpandoMetaClass
    `` | `public Collection` | `getExpandoSubclassMethods()` Returns the subclass-scoped expando methods registered on this meta class.
    `` | `public Class` | `getJavaClass()` Returns: The Java class enhanced by this MetaClass
    `` | `public MetaClass` | `getMetaClass()` * Returns the metaclass for a given class. * * Returns: the metaClass of this instance
    `` | `public MetaProperty` | `getMetaProperty(String name)` Looks up an existing MetaProperty by name
    `` | `public List<MetaMethod>` | `getMethods()` Overrides the behavior of parent getMethods() method to make MetaClass aware of added Expando methods
    `` | `public List<MetaProperty>` | `getProperties()` * Returns the available properties for this type. * * Returns: a list of `MetaProperty` objects
    `` | `public Object` | `getProperty(String property)` * Retrieves a property value. * * Parameters: `propertyName` - the name of the property of interest * Returns: the given property
    `` | `public Object` | `getProperty(Class sender, Object object, String name, boolean useSuper, boolean fromInsideClass)` Overrides default implementation just in case getProperty method has been overridden by ExpandoMetaClass
    `` | `public Object` | `getProperty(Object object, String name)` Overrides default implementation just in case getProperty method has been overridden by ExpandoMetaClass
    `` | `public String` | `getPropertyForSetter(String setterName)` Returns a property name equivalent for the given setter name or null if it is not a getter
    `` | `protected Object` | `getSubclassMetaMethods(String methodName)` * Returns subclass-scoped meta methods contributed by specialized meta classes. * * Parameters: `methodName` - the method name * Returns: subclass methods for the name, or `null` if none are registered
    `` | `public boolean` | `hasCustomInvokeMethod()` Whether this metaclass has a custom `invokeMethod` registration.
    `` | `public boolean` | `hasCustomStaticInvokeMethod()` * indicates is the metaclass method invocation for static methods is done * through a custom invoker object. * * Returns: true - if the method invocation is not done by the metaclass itself
    `` | `public boolean` | `hasMetaMethod(String name, Class[] args)` Checks whether a MetaMethod for the given name and arguments exists
    `` | `public boolean` | `hasMetaProperty(String name)` Returns true if the MetaClass has the given property
    `` | `public void` | `initialize()` * Complete the initialisation process. After this method * is called no methods should be added to the metaclass. * Invocation of methods or access to fields/properties is * forbidden unless this method is called. This method * should contain any initialisation code, taking a longer * time to complete. An example is the creation of the * Reflector. It is suggested to synchronize this * method.
    `` | `public Object` | `invokeConstructor(Object[] arguments)` * Invokes a constructor for the given arguments. The MetaClass will attempt to pick the best argument which * matches the types of the objects passed within the arguments array * * Parameters: `arguments` - The arguments to the constructor * Returns: An instance of the java.lang.Class that this MetaObjectProtocol object applies to
    `` | `public Object` | `invokeMethod(String name, Object args)` * Invokes the given method. * * Parameters: `name` - the name of the method to call * `args` - the arguments to use for the method call * Returns: the result of invoking the method
    `` | `public Object` | `invokeMethod(Class sender, Object object, String methodName, Object[] originalArguments, boolean isCallToSuper, boolean fromInsideClass)` Overrides default implementation just in case invokeMethod has been overridden by ExpandoMetaClass
    `` | `public Object` | `invokeStaticMethod(Object object, String methodName, Object[] arguments)` Overrides default implementation just in case a static invoke method has been set on ExpandoMetaClass
    `` | `protected boolean` | `isInitialized()` Checks if the metaclass is initialized.
    `` | `public boolean` | `isModified()` * Returns whether this MetaClassImpl has been modified. Since MetaClassImpl * is not designed for modification this method always returns false * * Returns: false
    `` | `public boolean` | `isSetter(String name, CachedClass[] args)` Determines whether the supplied method signature represents a Groovy bean setter.
    `` | `public static boolean` | `isValidExpandoProperty(String property)` Checks whether a property name is available for the expando DSL.
    `` | `protected void` | `onGetPropertyFoundInHierarchy(MetaMethod method)` * Callback invoked when a `getProperty` implementation is discovered. * * Parameters: `method` - the discovered handler
    `` | `protected void` | `onInvokeMethodFoundInHierarchy(MetaMethod method)` * Callback invoked when an `invokeMethod` implementation is discovered. * * Parameters: `method` - the discovered handler
    `` | `protected void` | `onSetPropertyFoundInHierarchy(MetaMethod method)` * Callback invoked when a `setProperty` implementation is discovered. * * Parameters: `method` - the discovered handler
    `` | `protected void` | `onSuperMethodFoundInHierarchy(MetaMethod method)` * Callback invoked when a super-class method is discovered during initialization. * * Parameters: `method` - the inherited method
    `` | `protected void` | `onSuperPropertyFoundInHierarchy(MetaBeanProperty property)` * Callback invoked when a super-class bean property is discovered during initialization. * * Parameters: `property` - the inherited property
    `` | `protected void` | `performOperationOnMetaClass(Runnable runner)` Performs a mutating expando operation while coordinating initialization state and locks.
    `` | `public void` | `refreshInheritedMethods(Set modifiedSuperExpandos)` Called from ExpandoMetaClassCreationHandle in the registry if it exists to set up inheritance handling
    `` | `public void` | `registerBeanProperty(String property, Object newValue)` Registers a new bean property.
    `` | `public void` | `registerInstanceMethod(String name, Closure closure)` Registers a new instance method.
    `` | `public void` | `registerInstanceMethod(MetaMethod metaMethod)` Registers a new instance method.
    `` | `protected void` | `registerStaticMethod(String name, Closure callable)` Registers a new static expando method using the closure's declared parameter types.
    `` | `protected void` | `registerStaticMethod(String name, Closure callable, Class[] paramTypes)` Registers a new static method for the given method name and closure on this MetaClass
    `` | `public void` | `registerSubclassInstanceMethod(String name, Class klazz, Closure closure)` Registers an instance method contribution that only applies to the supplied subclass.
    `` | `public void` | `registerSubclassInstanceMethod(MetaMethod metaMethod)` Registers a subclass-scoped meta method.
    `` | `public MetaMethod` | `retrieveConstructor(Object[] args)` * This is a helper method which is used only by indy. It is for internal use. * * Since: 2.1.0
    `` | `protected void` | `setInitialized(boolean b)` * Updates the initialization flag for this meta class. * * Parameters: `initialized` - the new initialization state
    `` | `public void` | `setMetaClass(MetaClass metaClass)` * Allows the MetaClass to be replaced with a derived implementation. * * Parameters: `metaClass` - the new metaclass
    `` | `public void` | `setProperty(String property, Object newValue)` * Sets the given property to the new value. * * Parameters: `propertyName` - the name of the property of interest * `newValue` - the new value for the property
    `` | `public void` | `setProperty(Class sender, Object object, String name, Object newValue, boolean useSuper, boolean fromInsideClass)`

  - ### Inherited Methods Summary

    Inherited Methods
    Methods inherited from class | Name
    --- | ---
    `class MetaClassImpl` | `addMetaBeanProperty, addMetaMethod, addMetaMethodToIndex, addNewInstanceMethod, addNewStaticMethod, applyPropertyDescriptors, checkIfGroovyObjectMethod, checkInitalised, chooseConstructor, chooseMethod, chooseNamedArgCompatibleConstructor, clearInvocationCaches, createErrorMessageForAmbiguity, createTransformMetaMethod, doChooseMostSpecificParams, dropMethodCache, dropStaticMethodCache, findMethodInClassHierarchy, findMixinMethod, findOwnMethod, findPropertyInClassHierarchy, getAdditionalMetaMethods, getAttribute, getAttribute, getAttribute, getClassInfo, getClassNode, getEffectiveGetMetaProperty, getMetaMethod, getMetaMethods, getMetaProperty, getMethodWithCaching, getMethodWithCaching, getMethodWithoutCaching, getMethods, getNonClosureOuter, getProperties, getProperty, getProperty, getRegistry, getStaticMetaMethod, getSubclassMetaMethods, getSuperClasses, getTheCachedClass, getTheClass, getVersion, handleMatches, hasCustomInvokeMethod, hasCustomStaticInvokeMethod, hasProperty, incVersion, initialize, invokeConstructor, invokeMethod, invokeMethod, invokeMethod, invokeMissingMethod, invokeMissingProperty, invokeStaticMethod, invokeStaticMissingProperty, isGroovyObject, isInitialized, isModified, isPermissivePropertyAccess, onGetPropertyFoundInHierarchy, onInvokeMethodFoundInHierarchy, onMixinMethodFound, onSetPropertyFoundInHierarchy, onSuperMethodFoundInHierarchy, onSuperPropertyFoundInHierarchy, pickMethod, reinitialize, respondsTo, respondsTo, retrieveConstructor, retrieveConstructor, retrieveStaticMethod, selectConstructorAndTransformArguments, setAttribute, setAttribute, setInitialized, setPermissivePropertyAccess, setProperties, setProperty, setProperty, toString`

- - ### Field Detail

    - #### public static final String CONSTRUCTOR

      Pseudo-property used by the expando DSL to define constructors.

    - #### public static final String STATIC_QUALIFIER

      Pseudo-property used by the expando DSL to define static members.

    - #### public boolean inRegistry

      Indicates whether this expando meta class is registered in the global registry.

  - ### Constructor Detail

    - #### public ExpandoMetaClass(Class theClass, boolean register, boolean allowChangesAfterInit, MetaMethod[] add)

      Creates an expando meta class with explicit registry behaviour and additional methods.

      Parameters:
        `theClass` - the enhanced class
        `register` - whether the meta class should be registered globally
        `allowChangesAfterInit` - whether mutation is allowed after initialization
        `add` - additional meta methods to seed the meta class with

    - #### public ExpandoMetaClass(MetaClassRegistry registry, Class theClass, boolean register, boolean allowChangesAfterInit, MetaMethod[] add)

      Creates an expando meta class bound to a specific registry.

      Parameters:
        `registry` - the meta class registry to work with
        `theClass` - the enhanced class
        `register` - whether the meta class should be registered globally
        `allowChangesAfterInit` - whether mutation is allowed after initialization
        `add` - additional meta methods to seed the meta class with

    - #### public ExpandoMetaClass(Class theClass)

      Constructs a new ExpandoMetaClass instance for the given class

      Parameters:
        `theClass` - The class that the MetaClass applies to

    - #### public ExpandoMetaClass(Class theClass, MetaMethod[] add)

      Creates an unregistered expando meta class with additional initial methods.

      Parameters:
        `theClass` - the enhanced class
        `add` - additional meta methods to seed the meta class with

    - #### public ExpandoMetaClass(Class theClass, boolean register)

      Constructs a new ExpandoMetaClass instance for the given class optionally placing the MetaClass in the MetaClassRegistry automatically

      Parameters:
        `theClass` - The class that the MetaClass applies to
        `register` - True if the MetaClass should be registered inside the MetaClassRegistry. This defaults to true and ExpandoMetaClass will affect all instances if changed

    - #### public ExpandoMetaClass(Class theClass, boolean register, MetaMethod[] add)

      Creates an expando meta class with optional global registration and additional initial methods.

      Parameters:
        `theClass` - the enhanced class
        `register` - whether the meta class should be registered globally
        `add` - additional meta methods to seed the meta class with

    - #### public ExpandoMetaClass(Class theClass, boolean register, boolean allowChangesAfterInit)

      Constructs a new ExpandoMetaClass instance for the given class optionally placing the MetaClass in the MetaClassRegistry automatically

      Parameters:
        `theClass` - The class that the MetaClass applies to
        `register` - True if the MetaClass should be registered inside the MetaClassRegistry. This defaults to true and ExpandoMetaClass will affect all instances if changed
        `allowChangesAfterInit` - Should the metaclass be modifiable after initialization. Default is false.

  - ### Method Detail

    - #### public boolean addMixinClass(MixinInMetaClass mixin)

      Since:
        6.0.0

    - #### public Object castToMixedType(Object obj, Class type)

      Returns the mixed-in view of an object for the requested mixin type.

      Parameters:
        `obj` - the receiver object
        `type` - the requested mixin type
      Returns:
        the mixin instance, or `null` if the type is not mixed in

    - #### protected void checkInitalised()

      * checks if the initialisation of the class id complete. * This method should be called as a form of assert, it is no * way to test if there is still initialisation work to be done. * Such logic must be implemented in a different way. * *

      throws:
        IllegalStateException if the initialisation is incomplete yet

    - #### public ExpandoMetaClass define(@ClosureParams(value=SimpleType.class, options="java.lang.Object")
      @DelegatesTo(value=DefiningClosure.class, strategy=Closure.DELEGATE_ONLY)
      Closure closure)

      Executes the expando definition DSL against this meta class.

      Parameters:
        `closure` - the definition closure
      Returns:
        this meta class

    - #### public static void disableGlobally()

      Call to disable the global use of ExpandoMetaClass

    - #### public static void enableGlobally()

      Call to enable global use of ExpandoMetaClass within the registry. This has the advantage that inheritance will function correctly and metaclass modifications will also apply to existing objects, but has a higher memory usage on the JVM than normal Groovy

    - #### public MetaMethod findMixinMethod(String methodName, Class[] arguments)

      * Searches for a matching mixin method. * *

      Parameters:
        `methodName` - the method name *
        `arguments` - the parameter types *
      Returns:
        the matching mixin method, or `null` if none is found

    - #### public List<MetaMethod> getExpandoMethods()

      Returns a list of expando MetaMethod instances added to this ExpandoMetaClass

      Returns:
        the expandoMethods

    - #### public Collection<MetaProperty> getExpandoProperties()

      Returns a list of MetaBeanProperty instances added to this ExpandoMetaClass

      Returns:
        the expandoProperties

    - #### public Collection getExpandoSubclassMethods()

      Returns the subclass-scoped expando methods registered on this meta class.

      Returns:
        an unmodifiable view of the registered subclass method entries

    - #### public Class getJavaClass()

      Returns:
        The Java class enhanced by this MetaClass

    - #### public MetaClass getMetaClass()

      * Returns the metaclass for a given class. * *

      Returns:
        the metaClass of this instance

    - #### public MetaProperty getMetaProperty(String name)

      Looks up an existing MetaProperty by name

      Parameters:
        `name` - The name of the MetaProperty
      Returns:
        The MetaProperty or null if it doesn't exist

    - #### public List<MetaMethod> getMethods()

      Overrides the behavior of parent getMethods() method to make MetaClass aware of added Expando methods

      Returns:
        A list of MetaMethods
      See Also:
        MetaObjectProtocol.getMethods

    - #### public List<MetaProperty> getProperties()

      * Returns the available properties for this type. * *

      Returns:
        a list of `MetaProperty` objects

    - #### public Object getProperty(String property)

      * Retrieves a property value. * *

      Parameters:
        `propertyName` - the name of the property of interest *
      Returns:
        the given property

    - #### public Object getProperty(Class sender, Object object, String name, boolean useSuper, boolean fromInsideClass)

      Overrides default implementation just in case getProperty method has been overridden by ExpandoMetaClass

      See Also:
        MetaClassImpl.getProperty

    - #### public Object getProperty(Object object, String name)

      Overrides default implementation just in case getProperty method has been overridden by ExpandoMetaClass

      See Also:
        MetaClassImpl.getProperty

    - #### public String getPropertyForSetter(String setterName)

      Returns a property name equivalent for the given setter name or null if it is not a getter

      Parameters:
        `setterName` - The setter name
      Returns:
        The property name equivalent

    - #### protected Object getSubclassMetaMethods(String methodName)

      * Returns subclass-scoped meta methods contributed by specialized meta classes. * *

      Parameters:
        `methodName` - the method name *
      Returns:
        subclass methods for the name, or `null` if none are registered

    - #### public boolean hasCustomInvokeMethod()

      Whether this metaclass has a custom `invokeMethod` registration.

      Returns:
        `true` if a custom invokeMethod is registered
      Since:
        6.0.0

    - #### public boolean hasCustomStaticInvokeMethod()

      * indicates is the metaclass method invocation for static methods is done * through a custom invoker object. * *

      Returns:
        true - if the method invocation is not done by the metaclass itself

    - #### public boolean hasMetaMethod(String name, Class[] args)

      Checks whether a MetaMethod for the given name and arguments exists

      Parameters:
        `name` - The name of the MetaMethod
        `args` - The arguments to the meta method
      Returns:
        True if the method exists otherwise null

    - #### public boolean hasMetaProperty(String name)

      Returns true if the MetaClass has the given property

      Parameters:
        `name` - The name of the MetaProperty
      Returns:
        True it exists as a MetaProperty

    - #### public void initialize()

      * Complete the initialisation process. After this method * is called no methods should be added to the metaclass. * Invocation of methods or access to fields/properties is * forbidden unless this method is called. This method * should contain any initialisation code, taking a longer * time to complete. An example is the creation of the * Reflector. It is suggested to synchronize this * method.

    - #### public Object invokeConstructor(Object[] arguments)

      * Invokes a constructor for the given arguments. The MetaClass will attempt to pick the best argument which * matches the types of the objects passed within the arguments array * *

      Parameters:
        `arguments` - The arguments to the constructor *
      Returns:
        An instance of the java.lang.Class that this MetaObjectProtocol object applies to

    - #### public Object invokeMethod(String name, Object args)

      * Invokes the given method. * *

      Parameters:
        `name` - the name of the method to call *
        `args` - the arguments to use for the method call *
      Returns:
        the result of invoking the method

    - #### public Object invokeMethod(Class sender, Object object, String methodName, Object[] originalArguments, boolean isCallToSuper, boolean fromInsideClass)

      Overrides default implementation just in case invokeMethod has been overridden by ExpandoMetaClass

      See Also:
        MetaClassImpl.invokeMethod

    - #### public Object invokeStaticMethod(Object object, String methodName, Object[] arguments)

      Overrides default implementation just in case a static invoke method has been set on ExpandoMetaClass

      See Also:
        MetaClassImpl.invokeStaticMethod

    - #### protected boolean isInitialized()

      Checks if the metaclass is initialized.

      See Also:
        MetaClassImpl.isInitialized

    - #### public boolean isModified()

      * Returns whether this MetaClassImpl has been modified. Since MetaClassImpl * is not designed for modification this method always returns false * *

      Returns:
        false

    - #### public boolean isSetter(String name, CachedClass[] args)

      Determines whether the supplied method signature represents a Groovy bean setter.

      Parameters:
        `name` - the candidate method name
        `args` - the candidate parameter types
      Returns:
        `true` if the signature represents a setter

    - #### public static boolean isValidExpandoProperty(String property)

      Checks whether a property name is available for the expando DSL.

      Parameters:
        `property` - the property name to test
      Returns:
        `true` if the name can be used by the expando DSL

    - #### protected void onGetPropertyFoundInHierarchy(MetaMethod method)

      * Callback invoked when a `getProperty` implementation is discovered. * *

      Parameters:
        `method` - the discovered handler

    - #### protected void onInvokeMethodFoundInHierarchy(MetaMethod method)

      * Callback invoked when an `invokeMethod` implementation is discovered. * *

      Parameters:
        `method` - the discovered handler

    - #### protected void onSetPropertyFoundInHierarchy(MetaMethod method)

      * Callback invoked when a `setProperty` implementation is discovered. * *

      Parameters:
        `method` - the discovered handler

    - #### protected void onSuperMethodFoundInHierarchy(MetaMethod method)

      * Callback invoked when a super-class method is discovered during initialization. * *

      Parameters:
        `method` - the inherited method

    - #### protected void onSuperPropertyFoundInHierarchy(MetaBeanProperty property)

      * Callback invoked when a super-class bean property is discovered during initialization. * *

      Parameters:
        `property` - the inherited property

    - #### protected void performOperationOnMetaClass(Runnable runner)

      Performs a mutating expando operation while coordinating initialization state and locks.

      Parameters:
        `runner` - the operation to execute

    - #### public void refreshInheritedMethods(Set modifiedSuperExpandos)

      Called from ExpandoMetaClassCreationHandle in the registry if it exists to set up inheritance handling

      Parameters:
        `modifiedSuperExpandos` - A list of modified super ExpandoMetaClass

    - #### public void registerBeanProperty(String property, Object newValue)

      Registers a new bean property.

      Parameters:
        `property` - the property name
        `newValue` - the properties initial value

    - #### public void registerInstanceMethod(String name, Closure closure)

      Registers a new instance method.

      Parameters:
        `name` - the method name or `"constructor"` for a constructor
        `closure` - the implementation

    - #### public void registerInstanceMethod(MetaMethod metaMethod)

      Registers a new instance method.

    - #### protected void registerStaticMethod(String name, Closure callable)

      Registers a new static expando method using the closure's declared parameter types.

      Parameters:
        `name` - the method name
        `callable` - the implementation closure

    - #### protected void registerStaticMethod(String name, Closure callable, Class[] paramTypes)

      Registers a new static method for the given method name and closure on this MetaClass

      Parameters:
        `name` - The method name
        `callable` - The callable Closure

    - #### public void registerSubclassInstanceMethod(String name, Class klazz, Closure closure)

      Registers an instance method contribution that only applies to the supplied subclass.

      Parameters:
        `name` - the method name
        `klazz` - the subclass receiving the method
        `closure` - the implementation closure

    - #### public void registerSubclassInstanceMethod(MetaMethod metaMethod)

      Registers a subclass-scoped meta method.

      Parameters:
        `metaMethod` - the method to register

    - #### public MetaMethod retrieveConstructor(Object[] args)

      * This is a helper method which is used only by indy. It is for internal use. * *

      Since:
        2.1.0

    - #### protected void setInitialized(boolean b)

      * Updates the initialization flag for this meta class. * *

      Parameters:
        `initialized` - the new initialization state

    - #### public void setMetaClass(MetaClass metaClass)

      * Allows the MetaClass to be replaced with a derived implementation. * *

      Parameters:
        `metaClass` - the new metaclass

    - #### public void setProperty(String property, Object newValue)

      * Sets the given property to the new value. * *

      Parameters:
        `propertyName` - the name of the property of interest *
        `newValue` - the new value for the property

    - #### public void setProperty(Class sender, Object object, String name, Object newValue, boolean useSuper, boolean fromInsideClass)