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)` |

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    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 Detail

    - #### SimpleExtensionModule

          public SimpleExtensionModule​(String moduleName,
                                       String moduleVersion)

  - ### Method Detail

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