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
Author:
  Cedric Champeau

## Constructor Summary

Constructors
Constructor
Description
`SimpleExtensionModule(String moduleName, String moduleVersion)`

## Method Summary

Modifier and Type
Method
Description
`abstract List<Class>`
`getInstanceMethodsExtensionClasses()`
`List<MetaMethod>`
`getMetaMethods()`
`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)

## Method Details

### getMetaMethods

public List<MetaMethod> getMetaMethods()

Specified by:
  `getMetaMethods` in class `ExtensionModule`

### 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.