Documentation Set for Swarm 2.2
Prev | Appendix B. Library Interface Conventions | Next

# B.4. GridTurtle example

An example will help illustrate the features of type definitions supported by the defobj library. Throughout documentation of the basic Swarm libraries, a series of running examples will be based on a simple type of object belonging to sample Swarm simulations. This type of object is an agent that move around on a two-dimensional grid, always moving in a current direction that it maintains internally. This agent is like a "turtle" of the original Logo system, except that its position is constrained to discrete integer values of its X-Y coordinates, and its direction is always one of the four orthogonal directions north, east, south, or west.

Following is a complete library header file for a library which defines such an object, called GridTurtle:

    /*
    Name:         GridTurtle.h
    Description:  object type for Swarm example programs
    Library:      grid
    */

    #import <defobj.h>

    @deftype GridTurtle <Create, Drop, CREATABLE>
    CREATING
    - (void)        setXLocMax: (int)xLocMax;
    - (void)        setYLocMax: (int)yLocMax;
    SETTING
    - (void)        setXLoc: (int)xLoc;
    - (void)        setYLoc: (int)yLoc;
    - (void)        setXLoc: xLoc setYLoc: yLoc;

    - (void)        setDirection: direction;
    USING
    - (int)         getXLoc;
    - (int)         getYLoc;

    -               getDirection;

    - (void)        move: (int)distance;
    - (void)        turn: (int)angle;  // angle measured in units of pi/2 (90 deg.)
    - (void)        print;
    @end

    id <Symbol> North, East, South, West;

    #import "grid.xt"

An object type is defined by an @deftype declaration. (Note: newer libraries, including objectbase and random, now follow the library interface conventions without using this special @deftype tag. Instead they use just an ordinary @protocol declaration, but otherwise they follow all the structure explained in this document.) The syntax of such declaration is identical to that of an Objective C @protocol definition, except for the entirely uppercase keywords (CREATABLE, CREATING, SETTING, USING) appearing in the GridTurtle example above. All these modifications of Objective C syntax are accomplished by simple preprocessor macros; no extensions to the language compiler are involved.

When this library header file is processed (by a special rule in a make file), an external object id with the name GridTurtle is automatically published. The name of a defined type becomes an ordinary object that accepts specific messages defined by the defobj library. The defobj library explains the details of such messages; the only purpose here is to explain the basic sections of a deftype declaration.

deftype declarations follow the syntax as Objective C protocols for inheriting messages from each other: a list of names enclosed in angle brackets (e.g., <Create, Drop, ...> above) gives the names of other declared types containing messages to be supported by the new type as well. (These types referenced here are defined by the imported file <defobj.h>.) Like protocols, full multiple inheritance of types is supported. The same messages may be inherited any number of times through any path with no different effect than if inherited or declared just once, so long as no conflicts occur in any of their argument or return types.

The CREATABLE tag appearing in the inherited type list above is a special type which defines no messages of its own, but merely marks the type as one which supports direct creation of instances of the type. Without this tag, the only role of a type is to define messages for inheritance by other types. With this tag, the global type object has a particular implementation that supports object creation using standard messages defined in defobj.

The declared messages of the type may be separated into sections marked by the special uppercase tags such as CREATING, SETTING, and USING above. (Currently, these are the only such tags which may occur.) These sections each define messages belonging to a particular defined "interface" of the object type, which are further combined into distinct "phases" of an object lifecycle supported by defobj messages. Further explanation of the interfaces and phases defined by this example are provided in the Usage Guide of the defobj library.

Prev | Home | Next
Object Type Definitions | Up | Global Object Symbols