10.25.2.2 Slots

A slot description has the form

Visibility SlotName:SlotType = InitialValue

where Visibility and ‘= InitialValue’ are optional. Each slot of a class must have a distinct name, given by the atom SlotName. The Visibility, SlotType and InitialValue parts of the slot description are described separately.

Visibility

A slot’s visibility is either private, protected, or public. If its visibility is not specified, then the slot is private. The following example shows all four possibilities:

:- class example = [w:integer,
                    private   x:integer, 
                    protected y:integer,
                    public    z:integer] 

Slot z is public, y is protected, and both x and w are private.

Direct access to private slots is strictly limited to the methods of the class. Any other access to such slots must be accomplished through these methods. Making slots private will allow you later to change how you represent your class, adding and removing slots, without having to change any code that uses your class. You need only modify the methods of the class to accomodate that change. This is known as information hiding.

Protected slots are much like private slots, except that they can also be directly accessed by subclasses. This means that if you wish to modify the representation of your class, then you will need to examine not only the class itself, but also its subclasses.

Public slots, in contrast, can be accessed from anywhere. This is accomplished through automatically generated get and put methods named for the slot and taking one argument. In the example above, our example class would automatically support a get and put method named z/1. Note, however, that unlike other object oriented programming languages that support them, public slots in SICStus Objects do not violate information hiding. This is because you may easily replace a public slot with your own get and put methods of the same name. In this sense, a public slot is really only a protected slot with automatically generated methods to fetch and store its contents.

Within a method clause, any of the class’s slots can be accessed via the fetch_slot/2 and store_slot/2 predicates. These are the only way to access private and protected slots. They may be used to define get and put methods for the class, which provide controlled access to the protected slots. But, they can only be used within the method clauses for the class, and they can only refer to slots of the current class and protected and public slots of superclasses.

In the slot description, public, protected and private are used as prefix operators. The obj_decl module redefines the prefix operator public, as follows:

:- op(600, fy, [public]).

Unless you use the obsolete public/1 directive in your Prolog programs, this should cause no problems.

Types

A slot’s type restricts the kinds of values it may contain. The slot is specified in the slot description by one of the following Prolog terms with the corresponding meaning. Most of these will be familiar, but the last four, address, term, Class and pointer(Type), require some additional explanation:

integer

signed integer, large enough to hold a pointer

integer_64   since release 4.3

64-bit signed integer

integer_32

32-bit signed integer

integer_16

16-bit signed integer

integer_8

8-bit signed integer

unsigned

unsigned integer, large enough to hold a pointer

unsigned_64   since release 4.3

64-bit unsigned integer

unsigned_32

32-bit unsigned integer

unsigned_16

16-bit unsigned integer

unsigned_8

8-bit unsigned integer

float

64-bit floating point number

float_32

32-bit floating point number

atom

Prolog atom

address

Pointer. The address type is intended for use with foreign code. A slot of this type might store an address returned from a foreign function. That address might, in turn, be used in calling another foreign function. Hence, most Prolog programmers can safely ignore this type.

term

Prolog term. The term type is for general Prolog terms. Such a slot can hold any of the other types. However, if you know a slot will be used to hold only values of a particular type, then it is more efficient to specify that type in the class definition.

Storing a term containing free variables is similar to asserting a clause containing free variables into the Prolog database. The free variables in the term are replaced with new variables in the stored copy. And, when you fetch the term from the slot, you are really fetching a copy of the term, again with new variables.

Class

where Class is the name of a defined class. The class type is for any object in a class defined with SICStus Objects. Such a slot holds an object of its class or one of that class’s descendants, or the null object.

pointer(Type)

where Type is an atom. The pointer type is intended for use with the Structs Package. It is similar to the address type, except that access to this slot yields, and update to this slot expects, a term of arity 1 whose functor is Type and whose argument is the address. Again, most Prolog programmers can safely ignore this type.

Initial Values

A slot description may optionally specify an initial value for the slot. The initial value is the value of the slot in every instance of the class, when the object is first created. The initial value must be a constant of the correct type for the slot.

If an initial value is not specified, then a slot is initialized to a value that depends on its type. All numbers are initialized to 0, of the appropriate type. Atom and term slots are initialized to the empty atom (''). Addresses and pointers are initialized to null pointers. And, objects are initialized to the null object.

More complicated initialization—not the same constant for every instance of the class—must be performed by create methods, which are described later.

The null object

The null object is a special object that is not an instance of any class, but that can be stored in a slot intended for any class of object. This is very much like the NULL pointer in C. This is useful when you do not yet have an object to store in a particular slot.

In Prolog, the null is represented by the atom null.

Note that because the null object is not really an object of any class, you cannot determine its class with class_of/2. Unless noted otherwise, when we write of an object in this document, we do not include the null object.