The MMBase Function Framework

  <functionlist>
    <function key="stringFunction" name="bbb">
      <class>org.mmbase.util.functions.ExampleBean</class>
    </function>
  </functionlist>

You can use the following in a template:

  <mm:node number="default.mags"><mm:function name="bbb" /></mm:node>

This example uses the method stringFunction from ExampleBean (see above). It returns '[[null/default]]'.

Another example uses a class while including the class 'org.mmbase.util.functions.ExampleBuilder' in the class element of the 'news' builder.

  <class>org.mmbase.util.functions.ExampleBuilder</class>

  <ol>
  <mm:listnodes type="news">
    <li>
      number: <mm:field name="number" />
      title: <mm:field name="title" />
      predecessor: <mm:function name="predecessor" />
    </li>
  </mm:listnodes>
  </ol> 

It returns the nodenumbers preceding the current one. The complete code of this example method can be found in the example class.

As should be clear from the above examples it is not especially necessary to define a function in a special builder class. Allthough because the function is only defined in the builder of the nodetype 'magazines', it only works on nodes of type 'magazines'. When you want your functions to be used by every type of node you better define a functionset.

You can check whether a node supports a certain function with the tag <mm:hasfunction />.

  <mm:hasfunction name="index">
    <mm:function name="index" />
  </hasfunction>
 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE functionset PUBLIC 
  "//MMBase - functionset //" "http://www.mmbase.org/dtd/functionset_1_0.dtd">
<functionset>

  <description>
   Some util functions from org.mmbase.util, made accessible through 
   the function-framework.
  </description>

  <function name="generatePassword">
    <description>
      Generates a password. Using a template (chain of characters A (random letter) C (random
      alphanumeric) H (random hex) S (random syllable) 6 (random dice) 9 (random digit)). Default
      template: SSSSSS.
    </description>
    <type>class</type>
    <class>org.mmbase.util.PasswordGenerator</class>
    <method>getPassword</method>
    <param name="template" type="String">SSSSSS</param>
  </function>

  <function name="randomLong">
    <description>
      Generates a random long integer.
    </description>
    <type>class</type>
    <class>org.mmbase.util.RandomPool</class>
    <method>value_and_stir</method>
  </function>

  <function name="filename">
    <description>
      Makes filename of commons file upload's FileItem.getName.
    </description>
    <type>class</type>
    <class>org.mmbase.util.functions.Utils</class>
    <method>getFileItemName</method>
    <param name="filename" type="String" />
  </function>

</functionset>     

As you can see the 'utils' functionset defines three functions that can be accessed using functiontags. For example like <mm:function set="utils" name="generatePassword" />.

    public MMObjectNode getRandomNode() {
        return cloud.getRandomNode(randomnumber); // none working code
    }

The same is possible with lists :

  <mm:functionnodelist set="util" name="getRandomNodes">
    object number : <mm:field name="number" />
    object type : <mm:field name="otype" />
    object owner : <mm:field name="owner" />
  </mm:functionnodelist>
  

    public List getRandomNodes() {
        List list =  new ArrayList();
        list.add(cloud.getRandomNode(randomnumber)); // none working code
        list.add(cloud.getRandomNode(randomnumber2)); // none working code
        list.add(cloud.getRandomNode(randomnumber3)); // none working code
        return list;
    }

Its also possible to use virtual nodes in functions, this opens up a interesting uses in that it allows you to return any information in the form of MMBase objects. The main advantage of this that the frontend programmers can use the tools they already know for handling nodes, fields and lists for example we could return some information as a mmbase node like this :

    public MMObjectNode getOSInfo() {
        Cloud cloud = LocalContext.getCloudContext().getCloud("mmbase");
        MMObjectNode virtual = builder.getNewNode("admin");
        virtual.setValue("hardware", System.getProperty("os.arch");
        virtual.setValue("os", System.getProperty("os.name");
        virtual.setValue("version", System.getProperty("os.version");
        return virtual;
    }

  <mm:nodefunction set="mySet" name="getOSInfo">
    So you use <mm:field name="hardware" />
    <mm:field name="os">
      <mm:compare value="osx">
              and i guess you don't like Bill Gates.
      </mm:compare>
      <mm:compare value="windowsxp">
              and i guess you don't like Steve Jobs.
      </mm:compare>
    </mm:field>
  </mm:nodefunction>

We can also create lists. For example we could make a list of accounts from a LDAP server that acts like any normal MMBase list (made up code for the ldap parts).

    public List getAccounts(String searchkey) {
        Cloud cloud = LocalContext.getCloudContext().getCloud("mmbase");
        List list =  new ArrayList();
        // fill the list from the ldap server, using a while
        Iterator i = ldap.getAccounts(searchkey);
        while (i.hasNext()) {
            NextLDAP user = (NextLDAP)i.next();
            MMObjectNode virtual = builder.getNewNode("admin");
            virtual.setValue("account", user.getAccount();
            virtual.setValue("firstname", user.getFirstName();
            virtual.setValue("surname", user.getSurName();
            list.add(virtual);
        }
    }

  <mm:nodelistfunction set="mySet" name="getUsers" referid="searchkey">
    <mm:first>The first user found</mm:first>
    <mm:last>The last user found</mm:last>
    <mm:field name="account" /> (<mm:field name="firstname" /> <mm:field name="surname" />)<br />
  </mm:nodelistfunction>