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 and Description
`SimpleExtensionModule(java.lang.String moduleName, java.lang.String moduleVersion)`

### Method Summary

Methods
`abstract java.util.List<java.lang.Class>` `getInstanceMethodsExtensionClasses()`
`java.util.List<MetaMethod>` `getMetaMethods()`
`abstract java.util.List<java.lang.Class>` `getStaticMethodsExtensionClasses()`

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

`getName, getVersion`

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

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

### Constructor Detail

#### SimpleExtensionModule

    public SimpleExtensionModule(java.lang.String moduleName,
                         java.lang.String moduleVersion)

### Method Detail

#### getMetaMethods

    public java.util.List<MetaMethod> getMetaMethods()

Specified by:
  `getMetaMethods` in class `ExtensionModule`

#### getInstanceMethodsExtensionClasses

    public abstract java.util.List<java.lang.Class> getInstanceMethodsExtensionClasses()

Returns:
  the list of classes defining new instance methods.

#### getStaticMethodsExtensionClasses

    public abstract java.util.List<java.lang.Class> getStaticMethodsExtensionClasses()

Returns:
  the list of classes defining new static methods.