A Brief Introduction To OOPNs

The OOPN formalism is characterized by a Smalltalk-based object-orientation enriched with concurrency and polymorphic transition execution, which allow for message sending, waiting for and accepting responses, creating new objects, and performing primitive computations.

OOPNs are based on viewing objects as active servers which offer reentrant services to other objects. Services provided by objects, as well as independent activities of objects, are described by Petri nets - services by method nets, object activities by object nets. Tokens in nets represent references to objects.

An OOPN consists of Petri nets organized in classes. Every class consists of an object net describing the internal activity of objects of this class and a set of dynamically instantiable method nets describing how these objects respond to messages. All method nets of a given class share access to the appropriate object net (places of the object net are accessible for transitions of method nets). Each method net has parameter places and a return place. Class inheritance is defined by the inheritance of object nets (Inherited transitions and places identified by their names can be redefined and new places or transitions can be added.), together with sets of method nets (The implementation of inherited methods can be changed and new methods can be added.). Classes can also contain special methods called synchronous ports which allow for synchronous interactions of objects.

Every object is either trivial (e.g. a number or a string) or it is an instance of some Petri net-described class consisting of one instance of the appropriate object net and several currently running instances of method nets. When an object receives a message, a new instance of the corresponding method net is created, parameters are put into the parameter places and the instance of the method net is being executed concurrently with all other net instances until the return place receives a token. Then the value of the token in the return place is passed to the message sender as the result of the requested service, and the instance of the method net is deleted. Message sending and object creations are specified as actions attached to transitions. Execution of transitions is polymorphic - invoked methods depend on classes of message receivers which are unknown at the compile time.

Summary

• PNtalk object is active object, i.e. it offers services for all objects and it can perform its own inner activity.
• Services (methods) for requested operations (messagses) as well as object activity are described by reentrant (invocable) Petri nets; services by method nets, object activity by object net.
• Tokens in nets represent references to objects.
• When an object is created, its object process (controlled by corresponding object net) starts to run.
• When an object receives a message requesting a service, it creates a new process for corresponding method.
• A process of method can cooperate with a process of the object (and change state of the object) by means of shared places which belong to the object net.
• Message sender can pass arguments (references to some objects) with the message; corresponding tokens appear in parameter places of corresponding method net.
• A process of the method ends when its return place receives a token; a value of the token is returned back to the message sender.
• PNtalk classes are defined incrementally using inheritance:
  • Method inheritance is the same as in Smalltalk: Method for a message is searched in its class, then in its superclass etc. In a class, new methods can be added. Inherited methods can be redefined.
  • Representation inheritance is based on the object net inheritance: Nodes (places and transitions) have names. In a class, new nodes can be added to the object net. Inherited nodes can be redefined: places can redefine initial marking, transitions can redefine their precinditions, postconditions, guard, and action.
• In addition to the above discussed objects, there are some special objects which are considered primitive (trivial). They allow atomic computations which are needed for Petri net evolution. Basic primitive objects are constants such as numbers, characters, symbols, and lists.