: Class StreamInputActorImpl

Overview

Package

Class

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: INNER | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

osl.manager.basic
Class StreamInputActorImpl

java.lang.Object
  |
  +--java.lang.Thread
        |
        +--osl.manager.ActorImpl
              |
              +--osl.manager.basic.StreamInputActorImpl

public class StreamInputActorImpl
extends ActorImpl
implements StreamInputActor

This class defines the implementation of an actor used to manage an input stream on behalf of external actors. We require an implementation (rather than an Actor) because if a security manager is running (i.e. startfoundry was specified with the -secure option), then user-written actors will not have direct access to several standard streams (e.g. System.out). Since instances of ActorImpl are privileged they may control such streams and provide their services to specific actors. The interface exported to external actors is defined by the StreamInputActor interface. In the current implementation, this actor will always use System.in as the encapsulated input stream.

Version:: $Revision: 1.2 $ ($Date: 1998/07/18 18:59:48 $)
See Also:: osl.manager.basic.StreamInputActor, Serialized Form

Field Summary
`protected WaitQueue`	`mailQueue` The queue which holds incoming requests.
`protected ActorManager`	`ourManager` The manager which manages this implementation.

Fields inherited from class osl.manager.ActorImpl

actorClass,  
classRef,  
context,  
extensionMethods,  
nextID,  
self

Fields inherited from class java.lang.Thread

MAX_PRIORITY,  
MIN_PRIORITY,  
NORM_PRIORITY

Constructor Summary
`StreamInputActorImpl()`

Method Summary
`protected void`	`actorDeliver(ActorMsgRequest msg)` This method is called by a manager to deliver a new message to the local actor.
`protected void`	`actorInitialize(ActorManager ourMgr, ActorName you, ActorCreateRequest req)` This method is called by a manager to initialize an actor implementation after it is instantiated.
`protected void`	`actorPostMigrateRebuild(ActorManager ourMgr)` This method is called by the new manager of an actor implementation just after migration has occurred.
`java.lang.Integer`	`available()` Return the number of bytes that can be read from the internal input stream without blocking.
`void`	`available(ActorName client, java.lang.String method)` Determine the number of bytes that can be read from the internal input stream without blocking, and send the result to the specified caller.
`void`	`close()` Close the internal input stream.
`protected ActorName`	`implCreate(ActorCreateRequest req)` Request a new actor to be created.
`protected void`	`implDestroy(java.lang.String reason)` Request to remove this actor from the system.
`protected java.lang.Object`	`implInvokeService(ServiceName name, java.lang.String meth, java.lang.Object[] args)` Request a service invocation on the named node service.
`protected void`	`implMigrate(ActorManagerName loc)` Request that this actor wishes to be migrated to a new location.
`protected java.lang.Object`	`implSend(ActorMsgRequest msg)` Request a message to be sent.
`void`	`mark(java.lang.Integer readlimit)` Mark the current position in the internal stream.
`java.lang.Boolean`	`markSupported()` Test if the internal input stream supports the mark and reset methods.
`void`	`markSupported(ActorName client, java.lang.String method)` Test if the internal input stream supports the mark and reset methods.
`java.lang.Integer`	`read()` Read the next byte of data from an input stream.
`void`	`read(ActorName client, java.lang.String method)` Read the next byte of data from an input stream and send it to a specified actor.
`void`	`read(ActorName client, java.lang.String method, java.lang.Integer max)` Read an array of bytes from the input stream and send them to a specified actor.
`java.lang.Byte[]`	`read(java.lang.Integer max)` Read an array of bytes from the input stream and return them to the caller.
`java.lang.Character[]`	`readln()` Read a line of characters from the internal input stream.
`void`	`readln(ActorName client, java.lang.String method)` Read a line of characters from the internal input stream.
`void`	`reset()` Reposition the internal stream to the position marked by a previous call to mark.
`void`	`run()` The main run loop for this implementation.
`void`	`skip(ActorName client, java.lang.String method, java.lang.Long n)` Skip over and discard n bytes of data from the input stream.
`java.lang.Long`	`skip(java.lang.Long n)` Skip over and discard n bytes of data from the input stream.

Methods inherited from class osl.manager.ActorImpl

buildAsynchException, 
finalize, 
formatAsynchException, 
implExtension, 
mgrActorCreate, 
mgrActorFatalError, 
mgrActorInvokeService, 
mgrActorMigrate, 
mgrActorSend, 
registerExtension, 
removeExtension, 
setCreatingThread, 
stampRequest

Methods inherited from class java.lang.Thread

activeCount, 
checkAccess, 
countStackFrames, 
currentThread, 
destroy, 
dumpStack, 
enumerate, 
getContextClassLoader, 
getName, 
getPriority, 
getThreadGroup, 
interrupt, 
interrupted, 
isAlive, 
isDaemon, 
isInterrupted, 
join, 
join, 
join, 
resume, 
setContextClassLoader, 
setDaemon, 
setName, 
setPriority, 
sleep, 
sleep, 
start, 
stop, 
stop, 
suspend, 
toString, 
yield

Methods inherited from class java.lang.Object

clone, 
equals, 
getClass, 
hashCode, 
notify, 
notifyAll, 
wait, 
wait, 
wait

Field Detail

ourManager

protected ActorManager ourManager

The manager which manages this implementation.

mailQueue

protected WaitQueue mailQueue

The queue which holds incoming requests.

Constructor Detail

StreamInputActorImpl

public StreamInputActorImpl()

Method Detail

actorInitialize

protected void actorInitialize(ActorManager ourMgr,
                               ActorName you,
                               ActorCreateRequest req)

This method is called by a manager to initialize an actor implementation after it is instantiated. The manager provides a reference to itself, a reference giving the name of the new actor, and a create request describing the new Actor that should be created and managed. After calling this method, a manager will call the run method in this class to start the actor executing. Note that the protection of this method prevents it from being called external to osl.manager. This was done to prevent arbitrary classes from initializing new actors. However, managers in different packages may invoke this method using implInitialize.

For this implementation, the manager reference and actor name are saved, but the actor create request is discarded since no internal actor is actually created.

Parameters:: ourMgr - The ActorManager which should be used by this actor implementation to invoke actor services.; you - The ActorName that should be used as the name of the new actor.; rtClass - The run-time Class of the user-written actor that should be instantiated by this implementation. This class will always be an extension of the Actor class.; initArgs - The array of arguments to pass to the constructor of the user-defined actor when it is instantiated.
Overrides:: actorInitialize in class ActorImpl
See Also:: ActorManager.implInitialize(osl.manager.ActorImpl, osl.manager.ActorName, osl.manager.ActorCreateRequest)

actorDeliver

protected void actorDeliver(ActorMsgRequest msg)

This method is called by a manager to deliver a new message to the local actor. This method is protected so that it has package level protection and therefore may not be invoked directly by user-written actor code.

For this implementation, we deposit the new message in our mail queue so that it can be processed in the main run loop.

Parameters:: msg - The ActorMsgRequest structure to be delivered. This structure must be maintained by the actor as it is required if an exception is returned to the manager.
Overrides:: actorDeliver in class ActorImpl

actorPostMigrateRebuild

protected void actorPostMigrateRebuild(ActorManager ourMgr)

This method is called by the new manager of an actor implementation just after migration has occurred. The implementation is expected to perform any re-initialization necessary after a migration (e.g. rebuilding transient fields). This method will be called before the implementations thread is restarted.

This method should never be called for this implementation as StreamInputActorImpls will never migrate. If this method IS called for some reason then a runtime exception is thrown.

Parameters:: ourMgr - A reference to the new manager of the implementation after migration has occurred.
Throws:: java.lang.RuntimeException - Thrown if this method is ever called.
Overrides:: actorPostMigrateRebuild in class ActorImpl

implSend

protected java.lang.Object implSend(ActorMsgRequest msg)
                             throws RemoteCodeException

Request a message to be sent. The message argument is forwarded to the manager. If the RPC field of the message is set to true then the caller is blocked while the RPC takes place. This method is protected so that it has package level protection and therefore may not be invoked directly by user-written actor code.