Package org.codehaus.groovy.runtime.m12n

# Class SimpleExtensionModule

java.lang.Object
org.codehaus.groovy.runtime.m12n.ExtensionModule
org.codehaus.groovy.runtime.m12n.SimpleExtensionModule

Direct Known Subclasses:
  `MetaInfExtensionModule`

public abstract class SimpleExtensionModule extends ExtensionModule
An extension module which provides extension methods using a `DefaultGroovyMethods`-like implementation, that is to say using static methods defined in an "extension class".

For commodity, multiple extension classes may be defined in a single module, including classes used to define new static methods.

Modules are required to implement the `getInstanceMethodsExtensionClasses()` for classes defining new instance methods, and `getStaticMethodsExtensionClasses()` for classes defining static methods.

For example, to define a module adding methods to the `String` class, you can write a helper class:

     class StringExtension {
         public static int count(String self, char c) {
             int result = 0;
             for (int i=0;i<self.length(); i++) {
                 if (self.charAt(i)==c) result++;
             }
             return result;
         }
     }

This class defines a single static method taking the string instance as first argument, allowing to define a new instance method on the String class:

    String#count(char c)

.

To define a new static method on a class, as the static modifier is already used for instance methods, you must use another helper class, for example:

     class StaticStringExtension {
         public static void foo(String self) { System.out.println("foo"); }
     }

The first argument of the method is only used to tell the class for which we add a static method. You can now define an extension module:

     class MyStringModule extends SimpleExtensionModule {
         // ...

         public List<Class> getInstanceMethodsExtensionClasses() {
             return Collections.singletonList(StringExtension.class);
         }

         public List<Class> getStaticMethodsExtensionClasses() {
             return Collections.singletonList(StaticStringExtension.class);
         }
     }

Since:
  2.0.0

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `SimpleExtensionModule(String moduleName, String moduleVersion)`
  Constructs a new SimpleExtensionModule.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `abstract List<Class>`
  `getInstanceMethodsExtensionClasses()`
  `List<MetaMethod>`
  `getMetaMethods()`
  Returns the list of all metamethods provided by this extension module.
  `abstract List<Class>`
  `getStaticMethodsExtensionClasses()`

  ### Methods inherited from class org.codehaus.groovy.runtime.m12n.ExtensionModule

  `getName, getVersion, toString`

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

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

- ## Constructor Details

  - ### SimpleExtensionModule

    public SimpleExtensionModule(String moduleName, String moduleVersion)
    Constructs a new SimpleExtensionModule.
    Parameters:
      `moduleName` - the name of this extension module
      `moduleVersion` - the version of this extension module

- ## Method Details

  - ### getMetaMethods

    public List<MetaMethod> getMetaMethods()
    Returns the list of all metamethods provided by this extension module. This method introspects the instance and static extension classes to extract metamethods from their public static methods.
    Specified by:
      `getMetaMethods` in class `ExtensionModule`
    Returns:
      a list of metamethods provided by this module

  - ### getInstanceMethodsExtensionClasses

    public abstract List<Class> getInstanceMethodsExtensionClasses()
    Returns:
      the list of classes defining new instance methods.

  - ### getStaticMethodsExtensionClasses

    public abstract List<Class> getStaticMethodsExtensionClasses()
    Returns:
      the list of classes defining new static methods.