You can define a new nodeclass using the #nodeclass shorthand notation by specifying the name of the class and at least one parent class, like so:

#nodeclass MyUselessClass : StateNode
#endnodeclass

You can also use the #shortnodeclass directive, which doesn't require a matching #endnodeclass. Instead, the class definition is terminated by a blank line:

#shortnodeclass MyUselessClass : StateNode

//      (the  blank line above terminated the shortnodeclass definition)

From now on, whatever we say about #nodeclass should be understood to also apply to #shortnodeclass. The only difference is in how the class definition is terminated. Either one of the above definitions expands into the following C++ code:

class MyUselessClass : public StateNode {
public:
  MyUselessClass(const std::string &nodename = "MyUselessClass") : StateNode(nodename) {}
};

One way to define a not-so-useless class is to pass some extra arguments to the parent's constructor. In the shorthand notation, instead of writing the name of a parent class you can write a call to its constructor, and the stateparser will do the rest. In any parent constructor call, the special symbol $ will be substituted for the nodename argument. Example:

#shortnodeclass SayHello : SpeechNode($,"Hello")

Now we can use SayHello in a state machine definition, just like any of the built-in node classes.

#shortnodeclass WriteNodeName : StateNode : DoStart
  cout << "This is node " << getName() << endl;

The declaration above both defines the class WriteNodeName and specifies that the lines that follow should be taken as the body of its DoStart method.

Here's another example of the same idea. To turn on a robot's green LED using a LedNode, you must tell the LedMC motion command inside the LedNode which LED you want to operate on, and what you want to do with it. To simplify things, you can make a new class called GreenLEDOn and include code in its constructor to supply the necessary information to the motion command:

#shortnodeclass GreenLEDOn : LEDNode : constructor
  getMC()->set(RobotInfo::GreenLEDMask, 1.0);

If you need to define more than one method for a class, you can use a #nodemethod or #shortnodemethod declaration to begin the next method. Any currently open method definition will be automatically closed for you.

Here's an example of a class with both DoStart and processEvent methods. This class waits for the user to press the green button on the robot, and then posts a completion event. (Normally we would use an EventTrans to look for a button event, and we might abbreviate it using a =B(...)=> shorthand transition. Here we're handling the button event in an unusual way just for illustrative purposes.) Notice that you do not need to specify the arguments to any of the standard StateNode methods in the shorthand notation; the stateparser will automatically supply a const EventBase &event argument to those methods that accept one, or a null argument to those that don't.

#shortnodeclass WaitForPress : StateNode : DoStart
    erouter->addListener(this, EventBase::buttonEGID, RobotInfo::GreenButOffset, EventBase::activateETID);
  #shortnodemethod processEvent
    cout << "Green button pressed: "  << event.getDescription() << endl;
    postStateCompletion();

In the above example, the #shortnodemethod line terminated the DoStart definition, and the blank line at the end terminated both the processEvent definition and the class definition.

#nodeclass WaitFor3Presses : StateNode : count()
  int count;

  #shortnodemethod DoStart
    count = 0;
    erouter->addListener(this, EventBase::buttonEGID, 
      RobotInfo::GreenButOffset, EventBase::activateETID);

  #shortnodemethod processEvent
    if ( ++count == 3 )
      postStateCompletion();

#endnodeclass

You might be wondering why count is explicitly initialized to 0 in the DoStart method instead of relying on the constructor's initializer list. The reason is that the constructor is only called to instantiate the class and produce an instance. If that state node instance is part of a loop it will be entered multiple times, and the counter needs to be reset each time. On the other hand, if the variable count did not have an intiailizer expression in the #nodeclass declaration, we would get a compiler warning. So an initializer must be supplied, but in this example the initial value it assigns is not being relied upon.

Here's an example: suppose we want to define a node class GoForward that takes a distance argument in its constructor, makes the robot travel forward by that distance, and also announces the distance in a message on the console. If we're coding for the AIBO or the Create we would use a WalkNode to do the moving. (At present we would have to use an XWalkNode on the Chiara, but this will change soon.) Here is the class definition:

#shortnodeclass GoForward(float distance) : WalkNode($,_distance,0,0,1) : DoStart
    cout << "Going forward by " << distance << " mm." << endl;

There are severalt things to note in the above example. First, even though we explicitly specified the form of the GoForward constructor, we did not have to include the nodename argument; that is supplied automatically by the stateparser and cannot be overridden. Second, note that the distance argument was referenced as "_distance" in the WalkNode constructor call, but as "distance" inside the DoStart method. The underscore is only necessary when variables are referenced in calls to parent constructors, or in initializer expressions; it should not be used when variables are referenced inside methods. Third, we did not have to write an initializer expression for distance; this was also handled automatically by the state parser. The declaration above expands into the following C++ code:

class GoForward : public WalkNode {
 public:
  float distance;  // cache the constructor's parameter
  GoForward(const std::string &nodename, float _distance) : WalkNode(nodename,_distance,0,0,1), distance(_distance) {}
  virtual void DoStart() {
    cout << "Going forward by " << distance << " mm." << endl;
  }
};

Note that since we did not specify a default value for the distance argument, a value must be supplied in the constructor call, and this in turn means a value must be supplied for the nodename argument that precedes it. Thus, with the above definition for GoForward, this expression is not legal:

  fwd: GoForward =C=> SayHello

  fwd: GoForward($,100) =C=> SayHello

#shortnodeclass GoForward(float distance=100) : WalkNode($,_distance,0,0,1) : DoStart
    cout << "Going forward by " << distance << " mm." << endl;

• A node class can have multiple parent classes. Just separate them by commas in the #nodeclass declararation.

• If you're uncertain about the effect of a nodeclass declaration, you can run the stateparser directly and look at the generated code. Suppose you've placed a node declaration in the file mycode.h.fsm. Then type the following to display the generated code:

  Tekkotsu/tools/stataparser mycode.h.fsm -

  The dash as second argument indicates that the output should be written to the console instead of to a file. If you omit the second argument, the output will be written to the file mycode.h.

• If your class contains pointer members, and you don't want to write explicit definitions for the copy constructor and assignment operator, use #nodeclass* or #shortnodeclass*. This variant supplies dummy prototypes for the copy constructor and assignment operator.