* * This is a package-private implementation class. * * @author Quickstone Technologies Limited */ // package-private. class TCPIPLinkServer extends LinkServer implements CSProcess { /*----------------------Constructors------------------------------------------*/ /** * Private constructor. To make life easier for you, you don't have to * call this. Just use the static start() method in this class and a * process will be created and executed for you. * * @see #start(ServerSocket) * * @param socket The ServerSocket to accept from */ private TCPIPLinkServer(ServerSocket serverSocket, boolean uniqueAddress) { super(new TCPIPProtocolID(), new TCPIPAddressID(serverSocket.getInetAddress(), serverSocket.getLocalPort(),uniqueAddress)); this.serverSocket = serverSocket; } /*----------------------Public Methods----------------------------------------*/ /** * Start accepting links and dealing with them. * This method runs forever. */ public void run() { try { Node.info.log(this, "TCP/IP V4 LinkServer listening on " + getLinkServerAddressID() + " Started"); while (true) { // Accept an incoming link Socket incoming = serverSocket.accept(); // Create a Link object to represent it. TCPIPLink link = new TCPIPLink(incoming, false); // spawn off the Link object to deal with it, but // let us continue in parallel. new ProcessManager(link).start(); } } catch (Exception ex) { // Will be IOException // warn but otherwise ignore Node.err.log(this, ex); } try { serverSocket.close(); } catch (Exception ignored) { } Node.info.log(this, "TCP/IP V4 LinkServer listening on " + getLinkServerAddressID() + " Ended"); } /*----------------------Non-public Methods------------------------------------*/ /** * Create a server on a specified NodeAddressID, and start it. The server * is spawned off in parallel, so this call returns immediately. * * This NEEDS to be overridden. * * @param addressID The NodeAddressID to accept from */ // package-private protected static LinkServer create(NodeAddressID addressID) { if(!(addressID instanceof TCPIPAddressID)) throw new IllegalArgumentException("Unable to start TCPIPLinkServer, wrong type of address."); TCPIPAddressID add = (TCPIPAddressID) addressID; InetAddress ipAdd = add.getHost(); int port = add.getPort(); TCPIPLinkServer ls; try { ServerSocket serverSocket = new ServerSocket(port, QUEUE_LENGTH, ipAdd); ls = new TCPIPLinkServer(serverSocket, addressID.isGloballyUnique()); new ProcessManager(ls).start(ProcessManager.PRIORITY_MAX); } catch(IOException e) { Node.info.log(TCPIPLinkServer.class, e.getMessage()); ls = null; } return ls; } /** * Stops the LinkServer. * * This NEEDS to be overridden. */ protected boolean stop() { try { Node.info.log(this, "Trying to stop TCP/IP V4 LinkServer listening on " + getLinkServerAddressID()); serverSocket.close(); } catch(IOException e) { e.printStackTrace(); } return true; } /*----------------------Attributes--------------------------------------------*/ /** * The socket to accept from. */ private final ServerSocket serverSocket; private static int QUEUE_LENGTH = 10; } jcsp-1.1-rc4.orig/src/org/jcsp/net/tcpip/TCPIPAddressID.java 0000644 0000000 0000000 00000017512 11105701167 020321 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.net.tcpip; import java.net.*; import org.jcsp.net.*; /** *
Provides a concrete implementation of the abstract NodeAddressID for use with the
* TCP/IP link protocol. A TCP/IP node address consists of an internet host address (IP address)
* and 16bit IP port number.
createAddressID
* method of TCPIPProtocolID.
*/
protected String getStringForm()
{
return stringForm;
}
/**
* Returns the ProtocolID for this address
*/
public ProtocolID getProtocolID()
{
return protocolID;
}
/**
* Returns the computer's IP address
*
* @return IP address of server.
*/
public final InetAddress getHost()
{
return host;
}
/**
* Returns the computer's port number for incoming link requests.
*
* @return Port number of server.
*/
public final int getPort()
{
return port;
}
/**
* Compares two TCPIPAddressID for equality.
*
* @return true iff obj is a non-null TCPIPAddressID for the same port &
* host, false otherwise.
*/
public final boolean equals(Object obj)
{
if ((obj == null) || !(obj instanceof TCPIPAddressID))
return false;
TCPIPAddressID other = (TCPIPAddressID)obj;
return (other.port == port) && (host.equals(other.host));
}
/**
* Returns a hashCode for this TCPIPAddressID
*
*/
public final int hashCode()
{
return host.hashCode() + (port << 16);
}
public boolean isGloballyUnique()
{
return isUnique;
}
/**
* Returns a string representation of this TCPIPAddressID, in the form
* "123.45.67.234:5678".
*
* @return A string representation of this ComputerID.
*/
public final String toString()
{
return host.getHostAddress() + ":" + port;
}
/*----------------------Attributes--------------------------------------------*/
private InetAddress host;
private final int port;
private ProtocolID protocolID = new TCPIPProtocolID();
private String stringForm;
private boolean isUnique = false;
} jcsp-1.1-rc4.orig/src/org/jcsp/net/Specification.java 0000644 0000000 0000000 00000007075 11105701167 017363 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.io.*;
/**
*
* @author Quickstone Technologies Limited.
*/
class Specification implements Serializable
{
Specification(String name, int intValue)
{
this.name = name;
this.intValue = intValue;
strValue = "";
dblValue = -1;
booValue = false;
type = Integer.TYPE;
}
Specification(String name, String strValue)
{
this.name = name;
this.strValue = strValue;
intValue = -1;
dblValue = -1;
booValue = false;
type = String.class;
}
Specification(String name, double dblValue)
{
this.name = name;
this.dblValue = dblValue;
intValue = -1;
strValue = "";
booValue = false;
type = Double.TYPE;
}
Specification(String name, boolean booValue)
{
this.name = name;
this.booValue = booValue;
intValue = -1;
strValue = "";
dblValue = -1;
type = Boolean.TYPE;
}
public boolean equals(Object o)
{
if(o == null || !(o instanceof Specification))
return false;
Specification other = (Specification) o;
return type.equals(other.type)
&& name.equals(other.name)
&& intValue == other.intValue
&& strValue.equals(other.strValue)
&& dblValue == other.dblValue
&& booValue == other.booValue;
}
public int hashCode()
{
return name.hashCode();
}
final Class type;
final String name;
final int intValue;
final String strValue;
final double dblValue;
final boolean booValue;
} jcsp-1.1-rc4.orig/src/org/jcsp/net/LinkLostException.java 0000644 0000000 0000000 00000005474 11105701167 020222 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
/**
* An exception caused by a link underlying a channel breaking.
*
* @author Quickstone Technologies Limited.
*/
public class LinkLostException extends RuntimeException
{
/**
* The object which threw this exception.
*/
Object source;
/**
* Get the object which threw this exception. This could be a channel
* or any other distributed construct.
*
* @return The object which broke.
*/
Object getSource()
{
return source;
}
/**
* Constructor.
*/
public LinkLostException(Object source)
{
this.source = source;
}
/**
* Constructor.
*
* @param description Description of the error.
*/
public LinkLostException(Object source, String description)
{
super(description);
this.source = source;
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NetBufferedChannelEndFactory.java 0000644 0000000 0000000 00000005455 11105701167 022244 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.util.ChannelDataStore;
/**
* This interface defines methods for constructing buffered
* Networked ChannelInput objects.
*
* @author Quickstone Technologies Limited
*/
public interface NetBufferedChannelEndFactory
{
/**
* Constructs a NetAltingChannelInput object.
*
* @param buffer the ChannelDataStore to use as a buffer.
* @return the constructed NetAltingChannelInput object.
*/
public NetAltingChannelInput createNet2One(ChannelDataStore buffer);
/**
* Constructs a NetSharedChannelInput object.
*
* @param buffer the ChannelDataStore to use as a buffer.
* @return the constructed NetSharedChannelInput object.
*/
public NetSharedChannelInput createNet2Any(ChannelDataStore buffer);
} jcsp-1.1-rc4.orig/src/org/jcsp/net/ProtocolID.java 0000644 0000000 0000000 00000014371 11105701167 016616 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.io.*;
import java.util.*;
/**
*
* Abstract class that identifies a protocol.
* Provides methods for obtaining the protocol's Builder to be
* installed in the LinkFactory, starting a LinkServer for this
* protocol and for creating a NodeAddressID for this protocol
* from a String.
*
* Protocols must not make use of the NodeID so that protocols can be installed before the node ID * is determined. The current definition of TCPIPv4 protocol meets this criteria. Such a change * will allow the UIFactory or other initialisation details to be obtained from a central server. *
* * @author Quickstone Technologies Limited */ public abstract class ProtocolID implements Serializable { /** * This tests whether another object is equal to this object. * TwoProtocolID objects are equal if their classes are the same.
* This is a default implementation, it is probably more efficient to
* override this with an implementation that uses the instanceof operator.
* @param o an object to compare with this object.
* @return true iff the supplied object's class is the same as
* the class of this object.
*/
public boolean equals(Object o)
{
Class thisClass = this.getClass();
Class otherClass = o.getClass();
return thisClass.equals(otherClass);
}
/**
* Returns a hash code for this object.
*
* @return the hash code for the object.
*/
public final int hashCode()
{
return this.getClass().hashCode();
}
/**
* * Not currently used. *
** This is envisaged to be used if a protocol that is in use and needs to be * removed sometime in the future. This will stop any further use of the * protocol. *
* * @return boolean indicating whether protocol is active. */ public abstract boolean isActive(); /** ** Returns whether the protocol requires user interaction in order for * data to be delivered. There could be a protocol that writes data * out to floppy disk or CD-R (see Tanenbaum's example of bandwidth and * lorry!). *
* * @return boolean indicating whether user interaction is required. */ public abstract boolean requiresUserInteraction(); /** * Sets the position of this protocol in the order of general preference. * * @param position the position of this protocol in the order. */ final void setPosition(int position) { this.position = position; } /** * Gets the position of this protocol in the order of preference. * * @return the order of preference as anint.
*/
public final int getPosition()
{
return position;
}
/**
* Obtains the Builder for this protocol. Provides a Hashtable that can
* can contain settings needed to construct the Link.
*
* @param settings Hashtable containing settings.
* @return the Builder for constructing Links.
*/
protected abstract LinkFactory.Builder getLinkBuilder(Hashtable settings);
/**
*
* Constructs, starts and returns a LinkServer on a
* specified NodeAddressID.
*
LinkServer
* @param addressID The address for the server to listen on.
* @throws IllegalArgumentException if the supplied NodeAddressID is invalid.
*/
protected abstract LinkServer startLinkServer(NodeAddressID addressID) throws IllegalArgumentException;
/**
* Constructs a NodeAddressID from a String.
*
* @return the constructed NodeAddressID
* @param stAddressID The address in String form.
* @param uniqueAddress boolean indicating whether address is unique.
* @throws IllegalArgumentException if the String supplied is invalid.
*/
protected abstract NodeAddressID createAddressID(String stAddressID, boolean uniqueAddress) throws IllegalArgumentException;
/**
* The position in the order of preference of protocols.
*/
private int position = 0;
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NetConnectionFactory.java 0000644 0000000 0000000 00000006566 11105701167 020705 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
/**
*
* This class should be implemented by classes wishing to act
* as factories for creating Networked ConnectionServer
* and ConnectionClient objects.
*
* An implementation is provided, see
* {@link StandardNetConnectionFactory}.
*
* Constructs a NetAltingConnectionServer object.
*
NetAltingConnectionServer object.
*/
public NetAltingConnectionServer createNet2One();
/**
*
* Constructs a NetSharedConnectionServer object.
*
NetSharedConnectionServer object.
*/
public NetSharedConnectionServer createNet2Any();
/**
*
* Constructs a NetAltingConnectionClient object.
*
NetAltingConnectionClient object.
*/
public NetAltingConnectionClient createOne2Net(NetChannelLocation serverLoc);
/**
*
* Constructs a NetSharedAltingConnectionClient object.
*
NetSharedAltingConnectionClient object.
*/
public NetSharedAltingConnectionClient createAny2Net(NetChannelLocation serverLoc);
} jcsp-1.1-rc4.orig/src/org/jcsp/net/ApplicationID.java 0000644 0000000 0000000 00000010736 11105701167 017261 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.io.*;
/**
* * A Class whose instances represent a unique identifier for a JCSP.NET application. * An application is defined as being a process network that forms a complete program. * Applications have a parent Node which is the Node on which the application was started. *
*
* For a full explanation, see {@link AbstractID}.
*
* Returns a String representation of this object.
* The current implemenation returns a human readable
* String which shows the application's home
* NodeID and the integer application id.
*
String representing this Application ID.
*/
public String toString()
{
return "Application " + " " + nodeID + " " + appID;
}
/**
*
* Compares the supplied Object with this
* ApplicationID.
*
Object to compare with
* this ApplicationID.
* @return true iff the parameter o is an
* ApplicationID that represents the
* same application as this object.
*/
public boolean equals(Object o)
{
if (o == null || !(o instanceof ApplicationID))
return false;
ApplicationID other = (ApplicationID)o;
if (nodeID.equals(other.nodeID))
return appID == other.appID;
return false;
}
/**
*
* Returns a hash code for this Object. Two equal
* ApplicationID objects return the same hash code.
*
int hash code.
*/
public int hashCode()
{
return nodeID.hashCode() + appID;
}
boolean onSameBranch(AbstractID abstractID)
{
if (abstractID == null)
return false;
if (abstractID instanceof ApplicationID)
return this.equals(abstractID);
return nodeID.onSameBranch(abstractID);
}
/**
* Returns the parent NodeID of this
* object.
*
* @return the parent NodeID.
*/
public AbstractID getParentID()
{
return nodeID;
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/LinkManager.java 0000644 0000000 0000000 00000066463 11105701167 017001 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.lang.*;
import org.jcsp.util.*;
import java.util.*;
/**
* This class manages the list of open links. It ensures that there is
* only ever one link between two given JCSP servers.
*
* @author Quickstone Technologies Limited.
*/
// package-private
class LinkManager implements CSProcess
{
/*-------------------Singleton Class Instance---------------------------------*/
private static LinkManager instance = new LinkManager();
/*-------------------Private Constructor--------------------------------------*/
LinkManager()
{
ProcessManager pm = new ProcessManager(loopbackLink);
pm.setPriority(ProcessManager.PRIORITY_MAX);
pm.start();
}
/*----------------------Attributes--------------------------------------------*/
/**
* The active links. This is a hashtable where the key is a
* NodeID and the value is a Link.
*
* @see NodeID
* @see Link
*/
private Hashtable linkHolders = new Hashtable();
/**
* This maps Link objects to a channel that is used to receive notification
* that the link has been established. This is necessary for when
* links are created to Nodes where the NodeID is not known. This means that
* a link holder cannnot be created as they are identified by the remote
* NodeID of the links they hold.
*
* This would typically be used when establishing a connection to the
* CNS Server as the NodeID would not be known until after the connection is
* made.
*/
//private Hashtable synchChannels = new Hashtable();
/**
* The LoopBackLink used for local connections.
*
*/
private LoopbackLink loopbackLink = new LoopbackLink();
private final Any2OneConnection registerConn = Connection.createAny2One();
private final Any2OneChannel requestLink = Channel.any2one();
private final Any2OneChannel lostLinkChan = Channel.any2one();
private final Any2OneChannel linkFailureChan = Channel.any2one();
private final Any2OneChannel checkForLink = Channel.any2one();
private final Any2OneChannel getNodeIDChan = Channel.any2one();
private final Any2OneChannel registerEventChannel = Channel.any2one();
private static final int ALT_LOST_LINK = 0;
private static final int ALT_LINK_FAIL = 1;
private static final int ALT_REG_CHAN = 2;
private static final int ALT_REQ_LINK = 3;
private static final int ALT_CHECK_FOR_LINK = 4;
/*----------------------Methods-----------------------------------------------*/
/** Used to run the
* Message to be transmitted. This is an abstract class containing
* only header information - you must subclass it to use it.
*
* This is a package-private implementation class.
*
* Creates an anonymous input channel.
*
* To create writers that write to this channel, you need to call
* getChannelName() to get a valid name for this channel. You
* will need to use some other means (e.g. a named channel) to pass
* the channel name to the writing computer.
*
* Creates an anonymous, buffered input channel.
*
* To create writers that write to this channel, you need to call
* getChannelName() to get a valid name for this channel. You
* will need to use some other means (e.g. a named channel) to pass
* the channel name to the writing computer.
*
* Instances of this class hold location information for a networked
*
* Instances of this class may either be constructed by the
*
* Constructor which takes the
* Constructor which takes a
* This constructor is intended to be used by code that wishes to connect
* to a
* Package private constructor which takes the
* Users of the
* When used like this, the class may seem to be the same as the
*
* This is a protected constructor which takes another
*
* Public accessor for the channel label property.
*
* Public accessor for the channel's address, if held.
*
* Public accessor for the channel label property.
*
* This method requests that the instance of this class refresh
* its information. This class does not actually do anything when
* this method is called, however, instances of subclasses may take the
* opportunity to refresh their data.
*
* An example, of when this might be useful is if this class were
* extended as part of a name service that resolves names to
*
* Returns a String ID for this
*
* This method does not need to be used by normal JCSP users.
*
* Returns a clone of the instance of this class. All mutable fields
* are also cloned.
*
* Returns whether this object is equal to another object.
*
* This method refreshes the fields in the instance of this object to
* equal the fields in the supplied object. Only members of the
*
* This method is used by the
* This should be used by sub-classes as they cannot override the
* equals method.
*
* Package level accessor for the channel's VCN if held.
* Users of
* Package level mutator for the channel's actual location details.
* The details can only be set if the current NodeID held is null.
*
* Note that this is merely a thread-safe wrapper around
* {@link One2NetChannel}
*
* @see One2NetChannel
* @author Quickstone Technologies Limited
*/
class Any2NetChannel implements NetSharedChannelOutput, Serializable
{
/***********Constructors******************************************************/
/**
* Equivalent to the
* Note that this is merely a thread-safe wrapper around
* {@link One2NetChannel#write(Object)} - see that method for full
* documentation.
*
* @param data The data to send over the channel. The object should implement the This is a package-private implementation class.
*
* @author Quickstone Technologies Limited
*/
// package-private
public class LinkLost
{
/**
* The broken Link's transmit channel.
*/
// package-private
final ChannelOutput txChannel;
/**
* The broken Link's computer address.
*/
// package-private
final NodeID address;
/**
* Constructor.
*
* @param conn The broken Link.
*/
// package-private
LinkLost(Link conn)
{
txChannel = conn.getTxChannel();
address = conn.getRemoteNodeID();
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/ 0000755 0000000 0000000 00000000000 11410045050 015342 5 ustar jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/OutputReconnectionManagerCNSImpl.java 0000644 0000000 0000000 00000025561 11105701167 024557 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import java.io.*;
import org.jcsp.lang.*;
import org.jcsp.net.*;
import org.jcsp.net.cns.*;
/**
* Implementation of the output reconnection manager that uses a CNS service to track channel ends.
* If this class is used for the output end, A server process for dispatching binary images of classes to nodes that do not hold suitable
* definitions locally. An instance of this process is started for a node by the Classes can be retrieved from individual .class files in the class path or from a
* Java archive. The current implementation does not support compressed archives. If a file from an
* archive is requested, the remote node will be sent a manifest listing all of the other classes
* available in the archive. This allows the remote node to better determine where to request classes
* from in the case of objects being passed through a lengthy pipeline of nodes. Once a remote node has requested a file from an archive the rest of the archive will be queued
* for dispatch to that node. This preemptive forwarding of information can give more reliable
* performance by increasing the likelihood of a node passing on all of the definitions its peers
* might require before it terminates. Attempts to load a class using the local class loader. If the class was not found locally, the
* class manager is queried - the class might have been dynamically loaded. If the class manager has
* an image for the file it is sent. If the class manager has marked the class as pending then it
* will issue a request to the originating node's JFTP process. If the class is loaded locally from a Java archive, a manifest is generated and returned with
* the class to the client. The other contents of the archive are then queued for transmission to
* the client. If the class was dynamically loaded by this node and a manifest was received, this
* manifest is forwarded to the client. Supports dynamic operations over the JCSP.NET infrastructure. These include dynamic oading of classes
when objects are sent to a node that does not already hold appropriate definitions and the migration of
channel ends between nodes without any loss of data. This package cannot be compiled or run using JDK1.1. This package is currently in a beta state and the API may be subject to changes. A filter to be plugged into the sending end of a channel if dynamic class transfer is to be supported
* over the channel. The receiving end of the channel should have a Instances of this class will be created by the A process for retrieving and registering classes that cannot be found locally. A single instance
* of this process runs, with other components in the dynamic class loading infrastructure invoking
* the public methods to request the loading of a class. When a class is requested, the system class loader will be tried first. If this fails, a cache
* of classes received dynamically will be tried. If this fails, and a {@link NodeClassLoader} has
* already been started for communication with the remote node, it will be used to retrieve the class
* file from that node. If a Marks a class as scheduled for later arrival. This is called when a The original manifest reply is also associated with the class so that this can be forwarded to
* other class loaders replicating the behaviour of the original JFTP process that loaded the class
* from disk. Marks a class as arrived after it was previously marked as pending. This is called when a
* Attempts to load the class from a remote node if it has previously been marked as pending. The
* class loader associated with the class by a call to If this method issues a call to a class loader this may block until the class has arrived. This
* may take a large amount of time if the class has to be routed through a chain of JFTP processes
* and class loaders.
* This factory constructs buffered
* See {@link NetLabelledChannelEndFactory} for an explanation of
* labelled VCN's.
*
* An abstract class that is sub-classed by classes whose instances
* should be networked channel ends that can be used as an
*
* This class does not need to be sub-classed by JCSP users.
*
* Constructs a channel end and takes the actual channel to use
* to deliver the data.
*
* Constructs a channel end without supplying the actual channel to
* use.
This is main package for JCSP.NET.
Before any JCSP.NET constructs can be used, the JCSP Node must
be initialized. See the
Networked channels can be constructed using the
See the {@link org.jcsp.net.cns} package for
information on using named channels.
This is a package-private implementation class.
*
* @author Quickstone Technologies Limited
*/
// package-private
abstract class ConnectionMessage extends Message
{
/**
* A request from client to server to open().
*
* This is a package-private implementation class.
*
*/
// package-private
static final class Open extends ConnectionMessage
{
/**
* @serial
*/
Object data;
}
/**
* A ping() from server to client.
*
* This is a package-private implementation class.
*
*/
// package-private
static final class Ping extends ConnectionMessage
{
/**
* @serial
*/
Object data;
}
/**
* A pong() from client to server.
*
* This is a package-private implementation class.
*
*/
// package-private
static final class Pong extends ConnectionMessage
{
/**
* @serial
*/
Object data;
}
/**
* A close() from client to server to open().
*
* This is a package-private implementation class.
*
*/
// package-private
static final class Close extends ConnectionMessage
{
/**
* @serial
*/
Object data;
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/SerializedObject.java 0000644 0000000 0000000 00000017210 11105701167 020015 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.io.*;
/**
*
* @author Quickstone Technologies Limited.
*/
class SerializedObject implements Externalizable
{
/*-------------------Constructors---------------------------------------------*/
/**
* This is the public used constructor. It takes an object and attempts
* to serialize it.
*
* @parma obj the Object to Serialize.
* @throws NotSerializableException If obj is not Serializable.
* @throws IOException if an IO error occurs during Serialization,
* should not happen unless there is a bug.
*/
public SerializedObject(Object obj, boolean storeToString) throws NotSerializableException, IOException
{
if(obj == null)
{
serializedData = null;
if (storeToString)
objectToString = "null";
return;
}
if (storeToString)
objectToString = obj.toString();
AccesibleByteArrayOutputStream serializedDataDestination = new AccesibleByteArrayOutputStream();
ObjectOutputStream objOut = new ObjectOutputStream(serializedDataDestination);
objOut.writeObject(obj);
objOut.flush();
serializedData = serializedDataDestination.getByteArray();
try
{
serializedDataDestination.close();
objOut.close();
}
catch(IOException e)
{
e.printStackTrace();
}
}
/**
* A private constructor used during the deserialization process of this
* object. Externalizable objects require a no-arg constructor so a
* replacement object is serialized in this object's place. On
* deserialization, this object is reconstructed using this constructor.
*
* @param data a byte[] containing the serialized data of the object
* that this object is holding.
* @param objectToString The toString value of the stored object.
*/
SerializedObject(byte[] data, String objectToString)
{
this.serializedData = data;
this.objectToString = objectToString;
}
/*-------------------Public Methods-------------------------------------------*/
public byte[] getSerializedData()
{
return serializedData;
}
public Object get() throws ClassNotFoundException, IOException
{
return get(new BasicInputStreamFactory());
}
public Object get(InputStreamFactory factory) throws ClassNotFoundException, IOException
{
if (serializedData == null)
return null;
ByteArrayInputStream serializedDataSource = new ByteArrayInputStream(serializedData);
ObjectInput objIn = factory.create(serializedDataSource);
Object obj = objIn.readObject();
try
{
serializedDataSource.close();
objIn.close();
}
catch(IOException e)
{
e.printStackTrace();
}
return obj;
}
public String getObjectToString()
{
if (objectToString == null)
return "";
return objectToString;
}
public void writeExternal(ObjectOutput out) throws IOException
{
}
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
{
}
public Object writeReplace() throws ObjectStreamException
{
ExtClass e = new ExtClass();
e.serializedData = serializedData;
e.objectToString = objectToString;
return e;
}
/*-------------------Attributes-----------------------------------------------*/
private byte[] serializedData;
private String objectToString = null;
/*-------------------Inner Classes--------------------------------------------*/
/**
* This class exists purely for performance reasons. It provides an
* accessor to the internal byte[] and means that it does not need to
* be copied.
*/
private static class AccesibleByteArrayOutputStream extends ByteArrayOutputStream
{
public byte[] getByteArray()
{
return buf;
}
}
public interface InputStreamFactory
{
public ObjectInput create(InputStream in) throws IOException;
}
private class BasicInputStreamFactory implements InputStreamFactory
{
public ObjectInput create(InputStream in) throws IOException
{
return new ObjectInputStream(in);
}
}
/**
* This class exists because the main class cannot have a no-arg
* constructor as required by externalizable.
*
* On serialization, this object replaces the SerializedObject.
*/
private static class ExtClass implements Externalizable
{
public ExtClass()
{}
public void writeExternal(ObjectOutput out) throws IOException
{
if(serializedData == null)
out.writeInt(0);
else
{
out.writeInt(serializedData.length);
out.write(serializedData, 0, serializedData.length);
}
out.writeObject(objectToString);
}
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
{
int arrayLength = in.readInt();
if(arrayLength > 0)
{
serializedData = new byte[arrayLength];
in.readFully(serializedData);
}
else
serializedData = null;
objectToString = (String)in.readObject();
}
public Object readResolve() throws ObjectStreamException
{
return new SerializedObject(serializedData, objectToString);
}
public byte[] serializedData;
public String objectToString = null;
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/ServiceUserObject.java 0000644 0000000 0000000 00000004312 11105701167 020160 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
/**
* An Interface which does not define any methods but
* is used as a way of indicating that a class is used
* for accessing non-admin functionality provided by
* a service.
*
* @author Quickstone Technologies Limited
*/
public interface ServiceUserObject
{
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NetAltingConnectionClient.java 0000644 0000000 0000000 00000010140 11105701167 021632 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.lang.AltingConnectionClientImpl;
/**
*
* Instances of this class are
* Instances of this class are not guaranteed to be safe to use
* by muliple concurrent processes. See
*
* Instances can be constructed by using a
*
* This class is an abstract class that all JCSP.NET protocol implementations
* must implement. Concrete implementations of the
* During handshaking, the
*
* When a
*
* A constructor that must be called by sub-classes.
*
* Establishes a connection to the peer node. Called when the process is started unless
*
* Allocates the resources necessary for the actual connection. Called as the first part
* of the handshaking process. This is called internally from the class'
* Deallocates any resources allocated by
* Sends the ID of this node to the peer process and receives its ID. It is only necessary to
* send this node's ID if
* A public accessor for enquiring as to whether this
* This is used by concrete
* This should be called during the handshaking process. The
* The method will start a testing process and then return. The concrete implementation
* of
* Once the calling process has finished looping through the array, it should perform a read from the channel
* supplied as the
* This is called during handshaking in order to
* register the link with the local
* Called to inform the local
* Currently, this should be called if the link fails once
* it has been registered but before the handshaking is complete.
*
* This should be called once to notify users of the link that the link has been dropped.
* The method returns the number of channels that are using the link that has been dropped.
* Implementations should read from
* This is an example:
*
* Compares another object with this object. This implementation
* returns
* Returns an
* Main process for the link, containing generic code that makes calls on
* the abstract methods that should be implemented by a concrete subclass.
* The subclass will be required to
* Does handshaking. Checks that the other side is a JCSP.net server
* of the same version, then decides whether or not this link is a
* duplicate of an existing link. If the versions match and there is
* no link to the other server, then the link is registered with the
* LinkManager, true is returned, and the link is ready for real
* data. Otherwise, the link is closed and false is returned.
*
* This method contains generic code. Calls are made on abstract methods
* that a concrete subclass must implement to provide link functionality.
*
* This returns the
* This class is a Factory that construct a unique identify
* for this Node. There is only ever one Node per JVM.
*
* This class can subclassed and the subclass can be set to be
* used in place of this class. See the documentation for the
*
* Returns a Serializable object that is a unique identifier for this
* Node. The object returned should support the
*
* This takes a String[] and returns a String that can be converted
* back into an identical String[] using the stringToArray method.
*
* The intended purpose of this is to possibly aid in implementing the
* getStringForm() method of the abstract NodeAddressID class.
*
* This takes a String in the form of that returned from the
* arrayToString method and returns a String[].
*
* The intended purpose of this is to possibly aid in implementing the
* getAddressIDFromString() method of the abstract NodeAddressID class.
* Manages the output of diagnostic messages to one or more devices. Instances of this class represent
* a log output device to which diagnostic or error messages can be written. The instance can be tied to
* an actual device such as a file or the standard I/O streams provided by the All messages must be signed by an application class and may also contain a severity level. The higher
* the number the less severe the problem. The output generated can be controlled by setting the maximum level
* that should be reported. Thus, essential output should be written at level 1. Less severe and verbose
* output should be written at higher levels depending on the granularity of information required when
* testing a program. The default logging level is 5. That is, for all classes only messages up to level 5 by default will
* be displayed. Messages from the infrastructure classes are written to the loggers Alternative implementations of this class may instead write to a system event log or format the
* information in manners tailored to particular debugging environments. Creates a new This will allocate a logger with the name To obtain a reference to this logger. The default device can take one of three reserved values: If none of these values match it is assumed to be a filename. Returns a named logger within the system. Refer to the constructor for an example of its use. Sets the current output device for this logger. For example, to suppress infrastructure messages: Sets the current logging level for a given class (and its subclasses). Only messages generated by
* that class (or its subclasses) with a lesser level will be output. Provides a basic security authority based on unique names. No passwords are used - a user is
* identified by a name which is guarded by a minimal protection scheme. This class is supplied as
* an example of implementing a security authority and not a robust implementation suitable for long
* term use. Initializes the service, setting a current user and the list of permitted users from the XML
* configuration file. For example: This sets the current user to be "foo@bar.com" but will allow responses from users "a" and "b". This package contains the files specifically for link security implementing various authentication schemes. See Thrown by the security authority implementations if the credentials supplied are not correct or
* another error occurs as a result of user parameters. Uniquely identifies an authenticated user. An instance of a Uniquely identifies a user. Instances of user IDs are specific to a given authority which is responsible
* for allocating them. No methods are defined because the way in which IDs are specified may vary. For
* example not all systems may identify users with a unique string based user name. Defines the service for dealing with authenticating users via a challenge/response scheme. Currently
* only one user may be logged onto the security authority at any one time. The currently logged on user
* will be used for creating the responses to challenges. Any number of users may be regarded as 'permitted'
* and any response from one of these will be considered valid. An instance of the security authority service can be used to generate concrete user IDs and tokens
* when users log on. This might be a purely internally resolved scheme or perhaps be linked to information
* from a system level domain (eg the user's logon account). To negotiate starting a link, the security authorities at each end should create challenges to send.
* The peer nodes will create responses from these challenges which indicate the log in of the user at that
* node. The security authority creating the challenge can then be used to validate the response determining
* whether the user generating the response is permitted to connect to this node. For example: To set the current user, ie the one which will create the response, use the To set the users which are currently permitted, ie will be considered to have generated a valid
* response the Creates and returns a new challenge object. The challenge should be used as soon as possible and
* only once as it may be logged by the authority, timestamped or protected in some other way. The
* caller should retain a copy for use in the Determines if a response is valid for the given challenge. The challenge must have been generated
* by a call to
* This class is used to hold settings that can be passed to
* services when they are initialized. Two types of settings can
* be held. The basic type of settings that can be held are
*
* The class also has a field for storing the name of the Service. This can
* be obtained by calling the
* This class that is used for initializing and
* managing the local JCSP.NET Node. A JCSP Node is a Java Virtual Machine
* that has been initialized to form part of a JCSP.NET network. By this
* definition, only one instance of this class is ever required on any
* JVM. Therefore this class is a singleton class.To obtain the instance
* of this class, use the
* LinkManager.
*/
public void run()
{
Node.info.log(this, "Running");
//Start a process to hand event channel registration and
//distribution of events
final Any2OneChannel sendEvent = Channel.any2one(new Buffer(10));
CSProcess eventProc = new CSProcess()
{
public void run()
{
Alternative alt = new Alternative(new Guard[] {registerEventChannel.in(), sendEvent.in()});
Vector eventChans = new Vector();
while (true)
{
switch(alt.fairSelect())
{
case 0:
eventChans.add(registerEventChannel.in().read());
break;
case 1:
final ChannelOutput[] chans = new ChannelOutput[eventChans.size()];
final Object eventToSend = sendEvent.in().read();
eventChans.toArray(chans);
new ProcessManager(new CSProcess()
{
public void run()
{
//the channels have infinite buffers
//so ok to just use one thread.
for (int i=0; iLinkManager and returns.
*/
public void start()
{
new ProcessManager(this).start();
}
/**
* Get the singleton instance of LinkManager.
*
* @return The singleton LinkManager object.
*/
// package-private
static LinkManager getInstance()
{
return instance;
}
/**
* Register a Link in the database. Prevents duplicates.
* Returns true if there was no prior entry for that NodeID, and one
* was added. (In that case it has also notified any waiting processes).
* Returns false (and does not change the database) if there is an
* existing entry.
*
* @return true iff there was no prior entry for that NodeID
*/
//package-private - only called from Link.
boolean registerLink(Link conn)
{
Node.info.log(this, "register link " + conn);
ConnectionClient cc = registerConn.client();
cc.request(conn);
return ((Boolean)cc.reply()).booleanValue();
}
void registerFailure(Link conn)
{
Node.err.log(this, "Link failed to be established: " + conn);
linkFailureChan.out().write(conn);
}
/**
* Get a channel to use to send to a remote PC. Will block (possibly
* forever) while the link is being established.
*
* @param target The system to connect to.
* @return The Channel to use to send to the requested computer.
* @throws IllegalStateException If init() has not been called.
*/
// package-private
ChannelOutput getTxChannel(NodeID target)
{
return getLink(target, null).getTxChannel();
}
ChannelOutput getTxChannel(NodeID target, Profile linkProfile)
{
return getLink(target, linkProfile).getTxChannel();
}
/**
* This is used to get a Link when no details are known about the other
* Node except for one of its addresses. A typical situation when this
* would be used is to connect to the CNS.
*
* @param targetAddress The address to which to create a link.
* @return the ChannelOuput that writes to the link.
*/
ChannelOutput getTxChannel(NodeAddressID targetAddress)
{
Node.getInstance().checkInitialized();
Link link = LinkFactory.getInstance().makeLink(targetAddress);
if(link != null)
{
NodeID remoteNodeID = link.obtainNodeID();
if(remoteNodeID != null)
{
return getTxChannel(remoteNodeID);
}
}
return null;
}
/**
* Get a Link to a remote PC. Will block (possibly forever) while
* the link is being established.
*
* @param target The system to connect to.
* @return The Link to the requested computer.
* @throws IllegalStateException If init() has not been called.
*/
private Link getLink(NodeID target, Profile linkProfile)
{
Node.getInstance().checkInitialized();
if(Node.getInstance().isThisNode(target))
//attempt to get a link to the local Node - return the LoopbackLink
return loopbackLink;
One2OneChannel channel = Channel.one2one(new InfiniteBuffer());
requestLink.out().write(new LinkRequest(channel.out(), target, linkProfile));
Link conn = null;
Object obj = channel.in().read();
if(obj instanceof Link)
conn = (Link) obj;
else if(obj instanceof ProfileMatchFailureException)
throw new IllegalStateException("No matching link exists.");
else
throw new IllegalStateException("No matching link exists.");
return conn;
}
/**
* Called by a Link to indicate the link broke.
*
* @param conn The broken link.
*/
int lostLink(Link conn)
{
lostLinkChan.out().write(conn);
return IndexManager.getInstance().broadcastLinkLost(new LinkLost(conn));
}
/**
* This method tests whether a link exists to
* a specified remote Node in this LinkManager.
*
* @param otherNode The NodeID of a remote Node to check
* the existance
* @return true iff a link currently exists to
* the specified remote Node.
*/
boolean linkExists(NodeID otherNode)
{
Node.getInstance().checkInitialized();
One2OneChannel channel = Channel.one2one(new InfiniteBuffer());
checkForLink.out().write(new LinkCheck(channel.out(), otherNode));
return (channel.in().read() != null);
}
AltingChannelInput getLinkLostEventChannel()
{
Node.getInstance().checkInitialized();
final One2OneChannel eventChan = Channel.one2one(new InfiniteBuffer());
registerEventChannel.out().write(eventChan.out());
//this should be a Safe channel
return eventChan.in();
}
/*----------------------Inner Classes-----------------------------------------*/
private static class LinksToNodeHolder
{
public LinksToNodeHolder(NodeID target)
{
this.target = target;
}
public Link getLink(Profile profile)
{
if(profile == null)
{
if(linkWithNoSpecifiedFacilities != null)
return linkWithNoSpecifiedFacilities;
}
else
{
Iterator it = links.iterator();
while(it.hasNext())
{
Link l = (Link) it.next();
//test whether the link meets the profile's requirements
Specification[] linkSpecs = l.getSpecifications();
int matches = profile.matches(linkSpecs);
//if so, return it
if(matches == 1)
return l;
else if(!profile.requiresExactMatch() && matches == 0)
return l;
}
}
return null;
}
public NodeID getTarget()
{
return target;
}
/**
* This sends the supplied link to any processes that are waiting for
* matching link. If there were some processes waiting or the
* addIfNoQueue parameter was true, then the link is
* added to this link manager.
*
* @param link the Link to add.
* @param addIfNoQueue boolean inidicating whether to add the link
* if there were no queued processes.
*
* @return the number of processes to which this link was sent.
*/
public int addLink(Link link, boolean addIfNoQueue)
{
Specification[] specs = link.getSpecifications();
int noNotified = notifyQueuedProcesses(specs, link);
if(noNotified > 0 || addIfNoQueue)
{
//if link has not specs or it uses the favoured protocol
//set it as the the link with no specified facilities
if(specs == null || specs.length == 0 || link.getProtocolID().getPosition() == 0)
linkWithNoSpecifiedFacilities = link;
links.add(link);
}
return noNotified;
}
public int notifyQueuedProcesses(Profile profile, Object toSend)
{
if(profile == null)
profile = Profile.getAlwaysMatchProfile();
Object queue = waiting.get(profile);
int notifyCount = 0;
if (queue != null)
{
if (queue instanceof Vector)
{
Vector v = (Vector) queue;
for (int i = 0; i < v.size(); i++)
{
ChannelOutput ch = ((ChannelOutput)v.elementAt(i));
ch.write(toSend);
}
}
else
{
ChannelOutput ch = ((ChannelOutput)queue);
ch.write(toSend);
}
notifyCount++;
waiting.remove(profile);
}
return notifyCount;
}
/**
* This takes a set of link specifications, looks through the set of
* queues, checks whether the specifications meet requirements of
* the profile of a queue, and if so, sends the supplied Link to the
* processes in that queue.
*
* The method returns the number of queues that were notified.
*
* @param specs an array of Specifcation objects that
* the link provides.
* @param linkToSend the link to send to the queued processes.
*
* @return the number of queues that were notified.
*/
public int notifyQueuedProcesses(Specification[] specs, Link linkToSend)
{
int notifyCount = 0;
Iterator it = waiting.keySet().iterator();
while(it.hasNext())
{
Profile profile = (Profile) it.next();
//check whether the specs match the profile
int matchValue = 0;
if (profile != null)
matchValue = profile.matches(specs);
Object toSend = null;
if(profile == null || matchValue == 1 ||(matchValue == 0 && !profile.requiresExactMatch()))
{
notifyCount++;
toSend = linkToSend;
}
else if(profile != null)
{
if(linkToSend.getProfile().equals(profile))
toSend = new ProfileMatchFailureException();
}
if(toSend != null)
{
//the profile matches the specs
if(profile == null)
profile = Profile.getAlwaysMatchProfile();
Object queue = waiting.get(profile);
if (queue != null)
{
if (queue instanceof Vector)
{
Vector v = (Vector) queue;
for (int i = 0; i < v.size(); i++)
{
ChannelOutput ch = ((ChannelOutput)v.elementAt(i));
ch.write(toSend);
}
}
else
{
ChannelOutput ch = ((ChannelOutput)queue);
ch.write(toSend);
}
}
it.remove();
}
}
return notifyCount;
}
public void removeLink(Link conn)
{
links.remove(conn);
}
/**
* This method allows processes to join a queue waiting for a link
* to a Node (with a known NodeID) to be established. An infinite
* buffered channel is supplied. When it is known that a link has
* been created or failed to be created, notification can be sent down
* the supplied channel to the waiting process.
*
* There is one queue per link required matching matching a given
* profile. When a link is established, the profile of each queue
* is tested against the link and, if the profile matches, then all
* queued processes are notified. This can mean that multiple links to
* a remote Node might be established but by the time a link has been
* established, there may be no processes waiting for it as other links
* may have met their requirements.
*
* @param channel the channel to put in the queue.
* @param profile the profile that the required link must meet.
*
* @return a boolean inidicating whether the channel is the first
* in the queue and hence the link needs to be initiated.
*/
public boolean joinQueue(ChannelOutput channel, Profile profile)
{
boolean initiate = false;
Link link = getLink(profile);
if(profile == null)
profile = Profile.getAlwaysMatchProfile();
if(link != null)
channel.write(link);
else if (waiting.containsKey(profile))
{
Object o = waiting.get(profile);
Vector v;
if (o instanceof Vector)
v = (Vector) o;
else
{
v = new Vector();
v.add(o);
}
v.add(channel);
waiting.put(profile, v);
initiate = false;
}
else
{
waiting.put(profile, channel);
initiate = true;
}
return initiate;
}
private NodeID target;
private HashSet links = new HashSet();
/**
* A link with no special facilities. This is so that if no features
* are required then no iteration will be needed.
*
*/
private Link linkWithNoSpecifiedFacilities = null;
/**
* The processes waiting for a link.
* The key is the FacilitiesRequired of the link we're waiting for,
* the value is the channel to the waiting process
* (or a Vector of these). When the link is available, we notify the
* process(es) by sending the Link down the channel(s).
*/
private Hashtable waiting = new Hashtable();
}
private static class ProfileMatchFailureException extends Exception
{
public ProfileMatchFailureException()
{
}
public ProfileMatchFailureException(String msg)
{
super(msg);
}
}
public static class LinkEstablishmentException extends RuntimeException
{
private LinkEstablishmentException(String msg, LinksToNodeHolder lh,
Profile profile)
{
super(msg);
this.lh = lh;
this.profile = profile;
}
private LinksToNodeHolder lh;
private Profile profile;
}
private static class LinkRequest
{
LinkRequest(ChannelOutput replyChan, NodeID target, Profile linkProfile)
{
this.replyChan = replyChan;
this.target = target;
this.linkProfile = linkProfile;
}
final ChannelOutput replyChan;
final NodeID target;
final Profile linkProfile;
}
private static class LinkCheck
{
LinkCheck(ChannelOutput replyChan, NodeID target)
{
this.replyChan = replyChan;
this.target = target;
}
final ChannelOutput replyChan;
final NodeID target;
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/Message.java 0000644 0000000 0000000 00000007520 11105701167 016162 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.io.Serializable;
import org.jcsp.lang.ChannelOutput;
/**
* Object to compare with this Object.
* @return true iff obj is a non-null ChannelID which represents the
* same channel.
*/
public final boolean equals(Object obj)
{
if ((obj == null) || !(obj instanceof ChannelID))
return false;
ChannelID other = (ChannelID)obj;
return (index == other.index && (nodeID.equals(other.getNodeID())));
}
/** Returns a human readable string representation of the current instance of this class.
* @return a human readable String object.
*/
public String toString()
{
return nodeID + "--" + index;
}
/*-------------------Private Attributes---------------------------------------*/
private NodeID nodeID;
private long index;
private static final String STRING_FORM_PREFIX = "ChannelID:";
} jcsp-1.1-rc4.orig/src/org/jcsp/net/StandardNetChannelEndFactory.java 0000644 0000000 0000000 00000012042 11105701167 022250 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.util.ChannelDataStore;
/**
* A standard implementation of the JCSP.NET
* Networked channel factory interaces.
*
* @author Quickstone Technologies Limited
*/
public class StandardNetChannelEndFactory
implements NetChannelEndFactory, NetLabelledChannelEndFactory, NetBufferedChannelEndFactory, NetLabelledBufferedChannelEndFactory
{
private static StandardNetChannelEndFactory instance = new StandardNetChannelEndFactory();
private final Profile linkProfile;
public StandardNetChannelEndFactory()
{
linkProfile = null;
}
/**
* Creates a factory that creates links using a given profile rather than the default one.
*/
public StandardNetChannelEndFactory(Profile profile)
{
linkProfile = profile;
}
public static StandardNetChannelEndFactory getDefaultInstance()
{
return instance;
}
/**
* @see org.jcsp.net.NetChannelEndFactory#createNet2One()
*/
public NetAltingChannelInput createNet2One()
{
return Net2OneChannel.create();
}
/**
* @see org.jcsp.net.NetLabelledChannelEndFactory#createNet2One(String)
*/
public NetAltingChannelInput createNet2One(String label)
{
return Net2OneChannel.create(label);
}
/**
* @see org.jcsp.net.NetBufferedChannelEndFactory#createNet2One(ChannelDataStore)
*/
public NetAltingChannelInput createNet2One(ChannelDataStore buffer)
{
return Net2OneChannel.create(buffer);
}
/**
* @see org.jcsp.net.NetLabelledBufferedChannelEndFactory#createNet2One(String, ChannelDataStore)
*/
public NetAltingChannelInput createNet2One(String label, ChannelDataStore buffer)
{
return Net2OneChannel.create(label, buffer);
}
/**
* @see org.jcsp.net.NetChannelEndFactory#createNet2Any()
*/
public NetSharedChannelInput createNet2Any()
{
return new Net2AnyChannel();
}
/**
* @see org.jcsp.net.NetLabelledChannelEndFactory#createNet2Any(String)
*/
public NetSharedChannelInput createNet2Any(String label)
{
return new Net2AnyChannel(label);
}
/**
* @see org.jcsp.net.NetBufferedChannelEndFactory#createNet2Any(ChannelDataStore)
*/
public NetSharedChannelInput createNet2Any(ChannelDataStore buffer)
{
return new Net2AnyChannel(buffer);
}
/**
* @see org.jcsp.net.NetLabelledBufferedChannelEndFactory#createNet2Any(String, ChannelDataStore)
*/
public NetSharedChannelInput createNet2Any(String label, ChannelDataStore buffer)
{
return new Net2AnyChannel(label, buffer);
}
/**
* @see org.jcsp.net.NetChannelEndFactory#createOne2Net(NetChannelLocation)
*/
public NetChannelOutput createOne2Net(NetChannelLocation loc)
{
return new One2NetChannel(loc, linkProfile);
}
/**
* @see org.jcsp.net.NetChannelEndFactory#createAny2Net(NetChannelLocation)
*/
public NetSharedChannelOutput createAny2Net(NetChannelLocation loc)
{
return new Any2NetChannel(loc, linkProfile);
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NetChannelLocation.java 0000644 0000000 0000000 00000036354 11105701167 020315 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.io.Serializable;
/**
* ChannelInput object. Instances of the class hold sufficient
* information for a networked ChannelOutput object to establish
* a connection to the networked ChannelInput object.
* jcsp.net user or by the networking infrastructure.
* NodeID of the Node hosting
* the networked ChannelInput object and the label assigned
* to the channel's Virtual Channel Number (VCN).
* NodeID of the Node hosting the
* read end of the channel.
* @param channelLabel the label assigned to the channel's Virtual
* Channel Number (VCN).
*/
public NetChannelLocation(NodeID channelNode, String channelLabel) throws IllegalArgumentException
{
if (channelNode == null || channelLabel == null)
throw new IllegalArgumentException ("A null parameter supplied");
this.channelLabel = channelLabel;
this.vcn = IndexManager.getInvalidVCN();
this.channelNode = channelNode;
this.channelAddress = null;
}
/**
* NodeAddressID on which the
* channel's Node is listening and the label assigned to the channel's
* Virtual Channel Number (VCN).
* ChannelInput running on a Node to which a
* Link has not yet been established. An address of the Node
* must be known by some means. For example, with a JCSP network running
* over TCP/IP, a program may prompt the user for an IP address to which
* to connect.
* NodeAddressID on which the channel's
* Node is listening.
* @param channelLabel the label assigned to the channel's VCN.
*/
public NetChannelLocation(NodeAddressID channelAddress, String channelLabel) throws IllegalArgumentException
{
if (channelAddress == null || channelLabel == null)
throw new IllegalArgumentException("A null parameter supplied");
this.channelLabel = channelLabel;
this.vcn = IndexManager.getInvalidVCN();
this.channelNode = null;
this.channelAddress = channelAddress;
}
/**
* NodeID of the
* Node hosting the networked ChannelInput object and a
* long holding the VCN of the channel.
* jcsp.net package cannot use this constructor.
* It is intended to be used by the infrastructure for creating an instance
* of the class in order to return it to the user.
* ChannelID class, however, this class is publicly
* visible outside the jcsp.net.
* NodeID of the Node hosting the
* read end of the channel.
* @param vcn the VCN of the channel
*
*/
NetChannelLocation(NodeID channelNode, long vcn) throws IllegalArgumentException
{
if (channelNode == null || !IndexManager.checkIndexIsValid(vcn))
throw new IllegalArgumentException("A null NodeID or invalid VCN was supplied");
this.channelLabel = null;
this.vcn = vcn;
this.channelNode = channelNode;
this.channelAddress = null;
}
/**
* NetChannelLocation object and "clones" it into this one.
* This allows sub-classes to adopt the field values of an instance of
* this class by passing a reference of it to this constructor.
* NetChannelLocation to "clone"
* into this one.
* @throws IllegalArgumentException iff the parameter is null.
*/
protected NetChannelLocation(NetChannelLocation other) throws IllegalArgumentException
{
refreshFrom(other);
}
/*----------------Fields-----------------------------------------------------*/
/**
* The label, if any, assigned to a channel's VCN.
*/
private String channelLabel;
/**
* The VCN of a channel, if known.
*/
private long vcn;
/**
* The NodeID of the channel's Node.
* This should be null if channelAddress is
* not null.
*/
private NodeID channelNode;
/**
* The NodeAddressID on which the channel's Node is listening.
* This should be null if channelNode is
* not null.
*/
private NodeAddressID channelAddress;
/*----------------Public Methods---------------------------------------------*/
/**
* null.
*
*/
public final String getChannelLabel()
{
return channelLabel;
}
/**
* NodeAddressID on which the channel's Node is
* listening. If the channel's Node's NodeID is
* known, then this will return null.
*
*/
public final NodeAddressID getChannelAddress()
{
return channelAddress;
}
/**
* NodeID of the channel's Node, if known,
* else null.
*
*/
public final NodeID getChannelNodeID()
{
return channelNode;
}
/**
* NetChannelLocation objects. If a user of an instance
* of this extended version wanted to check that the data were still
* up to date, it would call this method which would then check the
* information with a name service.
* true if any information has changed, otherwise
* false.
*
*
*/
public boolean refresh()
{
//does not do anything - this is for subclasses to implement
return false;
}
/* It is not necessary to be able to create a labelled VCN for a channel that will migrate. Labelled
* VCNs should only be used as a bootstrapping mechanism (eg for an alternative CNS service). If there
* is a possibility of a channel end moving then the CNS should be used.
*/
/**
* NetChannelLocation object.
* true iff the supplied object is equal.
*/
public final boolean equals(Object o)
{
if (o == null || !(o instanceof NetChannelLocation))
return false;
NetChannelLocation other = (NetChannelLocation) o;
boolean equal = true;
if (this.channelAddress != null && other.channelAddress != null)
equal = channelAddress.equals(other.channelAddress);
else if (!(this.channelAddress == null && other.channelAddress == null))
equal = false;
if (equal)
{
if (this.channelLabel != null && other.channelLabel != null)
equal = channelLabel.equals(other.channelLabel);
else if (!(this.channelLabel == null && other.channelLabel == null))
equal = false;
}
if (equal)
{
if (this.channelNode != null && other.channelNode != null)
equal = channelNode.equals(other.channelNode);
else if (!(this.channelNode == null && other.channelNode == null))
equal = false;
}
return equal && this.vcn == other.vcn && checkEqual(other);
}
/**
* Return a hashcode for this object.
*
* @return the int hash code.
*/
public final int hashCode()
{
return (this.channelNode != null)
? this.channelNode.hashCode() + (int) this.vcn
: this.channelAddress.hashCode() + this.channelLabel.hashCode();
}
/*----------------Protected Methods------------------------------------------*/
/**
* NetChannelLocation class are copied and not members
* added by sub-classes.
* NetChannelLocation to "clone"
* into this one.
* @throws IllegalArgumentException iff the parameter is null.
*/
protected final void refreshFrom(NetChannelLocation other) throws IllegalArgumentException
{
this.channelAddress = other.channelAddress;
this.channelLabel = other.channelLabel;
this.channelNode = other.channelNode;
this.vcn = other.vcn;
}
/**
* equals(Object) method
* to determine whether another object is equal to the one on which
* it is invoked.
* NetChannelLocation object to
* compare with this object.
* @return true if the other object is equal to this one.
*/
protected boolean checkEqual(NetChannelLocation other)
{
return true;
}
/*----------------Package level Methods--------------------------------------*/
/**
* jcsp.net should not have any control over VCN
* allocation so this accessor is not publicly accessible.
* NodeID of the channel.
* @param vcn the VCN of the channel.
*/
void setLocationDetails(NodeID nodeID, long vcn)
{
if (this.channelNode == null)
{
this.channelNode = nodeID;
this.vcn = vcn;
this.channelLabel = null;
this.channelAddress = null;
}
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/Any2NetChannel.java 0000644 0000000 0000000 00000013642 11105701167 017351 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.io.Serializable;
/**
* A channel for network output (TX). This is a "Any2Net" channel,
* which can be safely used by multiple writers.
* (NetChannelLocation) constructor of
* One2NetChannel.
*
* @see One2NetChannel
*/
public Any2NetChannel(NetChannelLocation channelLocation)
{
impl = new One2NetChannel(channelLocation);
}
/**
* Equivalent to the (NetChannelLocation, boolean) constructor
* of One2NetChannel.
*
* @see One2NetChannel
*/
public Any2NetChannel(NetChannelLocation channelLocation, boolean acknowledged)
{
impl = new One2NetChannel(channelLocation, acknowledged);
}
/**
* Equivalent to the (NetChannelLocation, Profile) constructor
* of One2NetChannel.
*
* @see One2NetChannel
*/
public Any2NetChannel(NetChannelLocation channelLocation, Profile linkProfile)
{
impl = new One2NetChannel(channelLocation, linkProfile);
}
/**
* Equivalent to the (NetChannelLocation, boolean, Profile)
* constructor of One2NetChannel.
*
* @see One2NetChannel
*/
public Any2NetChannel(NetChannelLocation channelLocation, boolean acknowledged, Profile linkProfile)
{
impl = new One2NetChannel(channelLocation, acknowledged, linkProfile);
}
/***********Private fields****************************************************/
/**
* Implementation
*/
private One2NetChannel impl;
/***********Public Methods****************************************************/
/**
* Output data to this channel. The data must be Serializable.
* Serializable interface in order to be sent over a network.
*/
public void write(Object data)
{
synchronized (impl)
{
impl.write(data);
}
}
/**
* Public accessor for obtaining the location of the read
* end of this channel.
*
* @return a NetChannelLocation object containing
* information needed to connect to
*/
public NetChannelLocation getChannelLocation()
{
return impl.getChannelLocation();
}
/**
* Requests that the channel recreates itself and reconnects to the
* other end of the channel.
*/
public void recreate()
{
synchronized (impl)
{
impl.recreate();
}
}
/**
* Requests that the channel recreates itself and reconnects
* to the other end of the channel. A new reader location
* must be supplied.
*
* @param loc the new location of the reader.
*/
public void recreate(NetChannelLocation loc)
{
synchronized (impl)
{
impl.recreate(loc);
}
}
/**
* Destroys the write end of a channel and frees any resources
* used within the JCSP networking infrastructure.
*
*/
public void destroyWriter()
{
synchronized (impl)
{
impl.destroyWriter();
}
}
public Class getFactoryClass()
{
return StandardNetChannelEndFactory.class;
}
/**
* Currently, network channels are unpoisonable so this method has no effect.
*/
public void poison(int strength) {
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NodeFactory.java 0000644 0000000 0000000 00000005160 11105701167 017011 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.io.*;
/**
* Node initialisation factory interface. A specific initialisation can be written by implementing
* this interface and passing an instance to the factoryInit method of
* Node.
*
* @author Quickstone Technologies Limited
*/
public interface NodeFactory extends Serializable
{
/*
* Initialises the node passed and returns the resulting NodeKey for the caller
* to subsequently use.
*
* @return the NodeKey of the Node or null
* if initialization failed.
*/
public NodeKey initNode(Node node, Node.Attributes attribs) throws NodeInitFailedException;
} jcsp-1.1-rc4.orig/src/org/jcsp/net/LinkLost.java 0000644 0000000 0000000 00000005217 11105701167 016336 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.lang.ChannelOutput;
/**
* Message warning that a Link broke.
*
* InputReconnectionManagerCNSImpl should be
* used at the input end.
*
* @author Quickstone Technologies Limited
*/
/* NOTE:
* The reconnection manager can be created with a cnsServiceName for channels that do not use the
* default CNS service. For channels using the default CNS service, cnsServiceName should be null
* and not set to the default service name. Any code in this class requiring behaviours from the CNS
* service should check the value of this attribute and call the default CNS directly if it is null
* and resolve the service name otherwise. This gives an efficiency gain.
*
* The CNS service name is tracked so that channels registered with a non-default CNS under one JVM
* will not become mapped to the default CNS under peer JVMs following communication of a channel end.
*
* If the user passes an invalid service name to the constructor, an exception will only be raised when
* a channel movement occurs (a NullPointerException). A possible modification would be to look up the
* service name at construction time and raise an exception if it does not exist.
*
* Doesn't work for non-acknowledged channels. Either warn users of this or provide factory methods
* for migratable channels that ensures the local writing end is acknowledged.
*/
class OutputReconnectionManagerCNSImpl implements OutputReconnectionManager
{
/**
* Underlying networked channel output end.
*/
private transient NetChannelOutput chanOut;
/**
* Constant specifying the maximum number of retry attempts before aborting a write operation.
*/
private final int maxAttemptCount = 10;
/**
* true iff the object can be serialized and sent (migrated) to another node.
*/
private transient boolean serializable = false;
/**
* Name of the CNS service to use.
*/
private String cnsServiceName;
/**
* Constructs a new OutputReconnectionManagerCNSImpl with the given underlying
* networked channel output end. The default CNS service name will be used.
*
* @param out underlying networked channel end.
*/
public OutputReconnectionManagerCNSImpl(NetChannelOutput out)
{
this(out, null);
}
/**
* Constructs a new OutputReconnectionManagerCNSImpl with the given underlying
* networked channel output end using a specific CNS service.
*
* @param out the underlying networked channel end.
* @param cnsServiceName name of the CNS service to use.
*/
public OutputReconnectionManagerCNSImpl(NetChannelOutput out, String cnsServiceName)
{
super();
this.chanOut = out;
this.cnsServiceName = cnsServiceName;
}
/**
* @see org.jcsp.net.dynamic.OutputReconnectionManager#getOutputChannel()
*/
public NetChannelOutput getOutputChannel()
{
if(chanOut == null)
return null;
return new NetChannelOutput()
{
public void write(Object value)
{
try
{
chanOut.write(value);
}
catch(LinkLostException e)
{
dealWithWriteError(value, e);
}
catch (ReaderIndexException e)
{
dealWithWriteError(value, e);
}
catch(ChannelDataRejectedException e)
{
dealWithWriteError(value, e);
}
}
public NetChannelLocation getChannelLocation()
{
return chanOut.getChannelLocation();
}
public void recreate()
{
chanOut.recreate();
}
public void recreate(NetChannelLocation newLoc)
{
chanOut.recreate(newLoc);
}
public void destroyWriter()
{
chanOut.destroyWriter();
}
public Class getFactoryClass()
{
return null;
}
/**
* Currently, network channels are unpoisonable so this method has no effect.
*/
public void poison(int strength) {
}
};
}
/**
* Attempts to resolve the new channel location. This method is called when a write error occurs
* because the destination is no longer valid. The CNS service is queried to find out where the
* other channel end moved to. A number of attempts to write to the new location are made. If these
* fail, the channel is recreated. If the number of retry attempts exceeds the limit set by
* maxAttemptCount the write is considered to have failed and the original exception
* is rethrown.
*
* @param value the data value that the user was trying to write and that should be written.
* @param e the exception originally raised to be thrown if the channel cannot be reconnected.
*/
private void dealWithWriteError(Object value, RuntimeException e)
{
boolean written = false;
int attemptCount = 1;
if (!(this.chanOut.getChannelLocation() instanceof CNSNetChannelLocation))
{
//the channel did not obtain location information from the CNS
String cnsRegisteredName = InputReconnectionManagerCNSImpl.anonymousCnsNamePrefix +
chanOut.getChannelLocation().getStringID();
NetChannelLocation newLoc = (cnsServiceName == null)
? CNS.resolve(cnsRegisteredName)
: ((CNSUser)Node.getInstance().getServiceUserObject(cnsServiceName))
.resolve(cnsRegisteredName);
chanOut.recreate(newLoc);
}
else
chanOut.recreate();
while((!written) && (attemptCount < maxAttemptCount))
{
try
{
chanOut.write(value);
written = true;
}
catch (LinkLostException e2)
{
chanOut.recreate();
attemptCount++;
}
catch (ReaderIndexException e2)
{
chanOut.recreate();
attemptCount++;
}
catch (ChannelDataRejectedException e2)
{
chanOut.recreate();
attemptCount++;
}
}
if(!written)
throw e;
}
/**
* @see org.jcsp.net.dynamic.OutputReconnectionManager#prepareToMove()
*/
public void prepareToMove()
{
if(serializable)
return;
if(chanOut != null)
serializable = true;
}
/**
* Serializes this object to the output stream. Before moving this channel end, prepareToMove
* should be called.
*
* @param out destination stream to serialize to.
* @throws IOException if there is a problem with the output stream.
*/
private void writeObject(ObjectOutputStream out) throws IOException
{
if(!serializable)
throw (new NotSerializableException(this.getClass().getName()));
if(chanOut != null)
{
if(chanOut instanceof Serializable)
{
out.writeInt(1);
out.writeObject(chanOut);
//free up resources in JCSP networked infrastructure
this.chanOut.destroyWriter();
}
else
throw (new NotSerializableException(this.getClass().getName()));
}
out.writeInt(3);
}
/**
* Deserializes this object from an input stream.
*
* @param in input stream to read the object from.
* @throws IOException if there is a problem with the input stream.
* @throws ClassNotFoundException if the class definition for the channel implementation cannot be
* found. This is only likely to occur if there are different versions
* of the infrastructure library on each node.
*/
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
{
int i = in.readInt();
if(i < 3)
{
switch(i)
{
case 1:
{
chanOut = (NetChannelOutput)in.readObject();
i = in.readInt();
break;
}
}
}
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/MigratableChannelOutputImpl.java 0000644 0000000 0000000 00000017113 11105701167 023624 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import java.io.IOException;
import java.util.Vector;
import org.jcsp.net.NetChannelLocation;
import org.jcsp.net.NetChannelOutput;
import org.jcsp.util.filter.Filter;
import org.jcsp.util.filter.FilteredChannelOutput;
/**
* Implements of a migratable networked channel output end.
*
* @author Quickstone Technologies Limited
*/
class MigratableChannelOutputImpl implements MigratableChannelOutput
{
/**
* The output reconnection manager for the channel.
*/
private OutputReconnectionManager mgr;
/**
* The actual networked output channel end.
*/
private transient NetChannelOutput actualOut;
/**
* The filtered channel end.
*/
private transient FilteredChannelOutput filteredOut;
/**
* The filters applied to the channel.
*/
private Vector filters = null;
/**
* MigratableChannelOutputImpl objects constructed with
* this constructor make use of the default channel name service.
*
* @param out the underlying networked channel output.
*/
public MigratableChannelOutputImpl(NetChannelOutput out)
{
this(new OutputReconnectionManagerCNSImpl(out));
}
/**
* Constructs a new MigratableChannelOutputImpl with the given reconnection manager.
*
* @param mgr the reconnection manager to use for the channel.
*/
public MigratableChannelOutputImpl(OutputReconnectionManager mgr)
{
super();
this.mgr = mgr;
actualOut = mgr.getOutputChannel();
if (actualOut == null)
throw new NullPointerException("Output channel provided is null");
filteredOut = MigratableAltingChannelInputImpl.FACTORY.createFiltered(actualOut);
}
/**
* @see org.jcsp.net.dynamic.MigratableChannelOutput#prepareToMove()
*/
public void prepareToMove()
{
mgr.prepareToMove();
}
/**
* @see org.jcsp.net.NetChannelOutput#recreate()
*/
public void recreate()
{
actualOut.recreate();
}
/**
* @see org.jcsp.net.NetChannelOutput#recreate(NetChannelLocation)
*/
public void recreate(NetChannelLocation newLoc)
{
actualOut.recreate(newLoc);
}
/**
* @see org.jcsp.net.NetChannelOutput#destroyWriter()
*/
public void destroyWriter()
{
actualOut.destroyWriter();
}
/**
* @see org.jcsp.lang.ChannelOutput#write(Object)
*/
public void write(Object object)
{
if(actualOut == null)
{
actualOut = mgr.getOutputChannel();
if (actualOut == null)
throw new NullPointerException("Output channel provided is null");
filteredOut = MigratableAltingChannelInputImpl.FACTORY.createFiltered(actualOut);
}
filteredOut.write(object);
}
/**
* @see org.jcsp.net.Networked#getChannelLocation()
*/
public NetChannelLocation getChannelLocation()
{
return actualOut.getChannelLocation();
}
public Class getFactoryClass()
{
return null;
}
/**
* @see org.jcsp.util.filter.WriteFiltered#addWriteFilter(Filter)
*/
public void addWriteFilter(Filter filter)
{
if (filteredOut == null && filters != null)
filters.addElement(filter);
filteredOut.addWriteFilter(filter);
}
/**
* @see org.jcsp.util.filter.WriteFiltered#addWriteFilter(Filter, int)
*/
public void addWriteFilter(Filter filter, int index)
{
if (filteredOut == null && filters != null)
filters.add(index, filter);
filteredOut.addWriteFilter(filter, index);
}
/**
* @see org.jcsp.util.filter.WriteFiltered#removeWriteFilter(Filter)
*/
public void removeWriteFilter(Filter filter)
{
if (filteredOut == null && filters != null)
filters.remove(filter);
filteredOut.removeWriteFilter(filter);
}
/**
* @see org.jcsp.util.filter.WriteFiltered#removeWriteFilter(int)
*/
public void removeWriteFilter(int index)
{
if (filteredOut == null && filters != null)
filters.remove(index);
filteredOut.removeWriteFilter(index);
}
/**
* @see org.jcsp.util.filter.WriteFiltered#getWriteFilter(int)
*/
public Filter getWriteFilter(int index)
{
if (filteredOut == null && filters != null)
return (Filter)filters.elementAt(index);
return filteredOut.getWriteFilter(index);
}
/**
* @see org.jcsp.util.filter.WriteFiltered#getWriteFilterCount()
*/
public int getWriteFilterCount()
{
if (filteredOut == null && filters != null)
return filters.size();
return filteredOut.getWriteFilterCount();
}
private void writeObject(java.io.ObjectOutputStream out) throws IOException
{
//the filtered channel input object used by this class is a
//transient field. This code extracts the filters from the
//filter channel input and stores them into a Filter[] field.
//They are resinserted into a new filtered channel input on the
//first call to read()
if (filteredOut != null)
{
filters = new Vector(filteredOut.getWriteFilterCount());
for (int i=0; i < filteredOut.getWriteFilterCount(); i++)
filters.addElement(filteredOut.getWriteFilter(i));
}
//writes all non-transient variables to the output stream
out.defaultWriteObject();
}
/**
* Currently, network channels are unpoisonable so this method has no effect.
*/
public void poison(int strength) {
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/JFTP.java 0000644 0000000 0000000 00000053022 11105701167 016763 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import java.io.*;
import java.net.*;
import java.util.*;
import java.util.jar.*;
import java.util.zip.*;
import org.jcsp.lang.*;
import org.jcsp.net.*;
/**
* DynamicClassLoader
* service. A request channel is connected to this process through which remote nodes can request
* images of classes.req channel. Once a request is
* received, a process will be spawned to complete the operation and allow another node to be
* serviced. Where possible, requests for the same class are combined so that it is only loaded
* once.
*/
public void run()
{
final One2OneChannel toQueueFlusher = Channel.one2one(), fromQueueFlusher = Channel.one2one();
final AltingChannelInput notifyIn = classNotify.in(), queueIn = classQueue.in(), flushNotifyIn = fromQueueFlusher.in();
final ChannelOutput notifyOut = classNotify.out(), queueOut = classQueue.out();
// This process will be sent class names from the output queue. It will look up the
// class file and pass the result back on the notify channel. Any nodes that are marked
// as needing this file will then be sent it.
new ProcessManager(new QueuedClassLoaderProcess(toQueueFlusher.in(), notifyOut, queueOut, fromQueueFlusher.out())).start();
final Alternative alt = new Alternative(new Guard[] { queueIn, notifyIn, req, flushNotifyIn, new Skip() });
final boolean cond[] = new boolean[] { true, true, true, true, true };
boolean queueEnable = true;
int queueCount = 0;
while(true)
{
try
{
cond[4] = queueEnable && (queueCount > 0);
switch (alt.priSelect(cond))
{
case 0 :
{
// Request added to queue. The class request has not actually been issued by
// a node yet. It has been generated by the loader as the node has requested
// another class from the same archive.
ClassRequest cr = (ClassRequest)queueIn.read();
ChanSet cs = (ChanSet)outputQueue.get(cr.className);
if (cs == null)
{
cs = new ChanSet(cr.replyChan);
outputQueue.put(cr.className, cs);
queueCount++;
}
else
cs.addRequest(cr.replyChan);
break;
}
case 1 :
{
// Notification of class loaded
// Send the class to all waiting processes. The class has now been loaded.
// All nodes that requested the class (or were marked as wanting it as a
// result of a manifest check) are sent it and the class is removed from the
// output queue.
ClassReply cr = (ClassReply)notifyIn.read();
ChanSet cs = (ChanSet)outputQueue.remove(cr.className);
cs.writeToAll(cr);
break;
}
case 2 :
{
// Request for a class
// Tag the node onto an existing request if there is one. Start a new thread
// to load the class. Starting a new thread solves the priority problem. A
// thread is not started if the class is already being processed by another
// unless a manifest is requested. If a thread is not started, the requesting
// node will receive the data when the other thread sends it on the notify
// channel.
final ClassRequest cr = (ClassRequest) req.read();
Node.info.log(this, "JFTP Received a request for " + cr.className);
ChanSet cs = (ChanSet)outputQueue.get(cr.className);
final boolean loadManifest, loadClass;
if (cs == null)
{
// No one else is waiting for the class, so create a response object
// and start a process to go and get the class
cs = new ChanSet(cr.replyChan);
loadClass = true;
loadManifest = ((cr.flags & CR_WANT_MANIFEST) != 0);
outputQueue.put(cr.className, cs);
}
else
{
cs.addRequest(cr.replyChan);
if (cs.isBeingProcessed())
{
if ((cr.flags & CR_WANT_MANIFEST) != 0)
{
loadClass = false;
loadManifest = true;
}
else
loadClass = loadManifest = false;
}
else
{
loadClass = true;
loadManifest = ((cr.flags & CR_WANT_MANIFEST) != 0);
}
}
if (loadClass || loadManifest)
{
cs.nowBeingProcessed();
new ProcessManager
(new CSProcess()
{
public void run()
{
findAndLoadClass(cr.className, loadClass, loadManifest, cr.replyChan, notifyOut, queueOut);
}
}).start();
}
break;
}
case 3 :
{
// Previous queued retrieval has completed; allow another
flushNotifyIn.read();
queueEnable = true;
break;
}
case 4 :
{
// Try and push some data
queueEnable = false; // suppress this guard until operation completed
// by process sending a message on notify channel
Enumeration e = outputQueue.keys();
String className = null;
ChanSet cs = null;
// Find a class that isn't being loaded for anyone
do
{
if (!e.hasMoreElements())
{
cs = null;
break;
}
className = (String)e.nextElement();
cs = (ChanSet)outputQueue.get(className);
} while (cs.isBeingProcessed());
if (cs == null)
{
queueCount = 0;
break;
}
else
queueCount--;
cs.nowBeingProcessed();
toQueueFlusher.out().write(className);
// When the queued class loader process finishes this class it will send a
// value on the flushNotify channel which will reenable this guard.
break;
}
}
}
catch (Exception e)
{
Node.err.log(this, "Error ignored");
Node.err.log(this, e);
}
}
}
/**
* Child process spawned by the run() method of JFTP to retrieve a class
* that has been queued for output to another node.
*/
private class QueuedClassLoaderProcess implements CSProcess
{
private final ChannelInput classIn;
private final ChannelOutput notifyOut;
private final ChannelOutput queueOut;
private final ChannelOutput flushOut;
public QueuedClassLoaderProcess(ChannelInput classIn, ChannelOutput notifyOut,
ChannelOutput queueOut, ChannelOutput flushOut)
{
this.classIn = classIn;
this.notifyOut = notifyOut;
this.queueOut = queueOut;
this.flushOut = flushOut;
}
public void run()
{
while (true)
{
String cn = (String)classIn.read();
findAndLoadClass(cn, true, false, null, notifyOut, queueOut);
flushOut.write(null);
}
}
}
/**
* ClassReply is sent on this channel for dispatch to all clients needing it.
* @param queueFurtherRequest if loading from an archive, new class requests are generated for the client on this channel.
*/
private void findAndLoadClass(String className, boolean wantClass, boolean wantManifest, ChannelOutput toRequestingClient,
ChannelOutput notifyOthers, ChannelOutput queueFurtherRequest)
{
Node.info.log(this, "Beginning " + ((toRequestingClient == null) ? "preemptive " : "") + "load for " + className);
try
{
String filename = className.replace('.', File.separatorChar) + ".class";
URL url = classLoader.getResource(filename);
if (url != null)
{
if (wantManifest)
{
String uStr = url.toString();
if (uStr.startsWith("jar:file:"))
{
// This is a JAR file - create and send a manifest
try
{
uStr = uStr.substring(9, uStr.indexOf('!'));
JarFile jf = new JarFile(uStr);
Enumeration e = jf.entries();
String[] manifest = new String[jf.size()];
int index = 0;
for (int i = 0; i < manifest.length; i++)
{
String n = ((ZipEntry)e.nextElement()).getName();
if (n.endsWith(".class"))
{
String cn = n.substring(0, n.length() - 6);
queueFurtherRequest.write(new ClassRequest(cn, toRequestingClient, CR_WANT_CLASS));
manifest[index++] = cn;
}
}
toRequestingClient.write(new JarManifestReply(manifest));
}
catch (IOException e)
{
}
}
}
if (wantClass)
{
// Get the single file requested
InputStream fileFound = url.openStream();
int size = fileFound.available();
byte[] fileBytes = new byte[size];
fileFound.read(fileBytes, 0, size);
// Dispatch the file to all waiting processes
notifyOthers.write(new ClassReply(className, fileBytes));
}
}
else
{
// Not held locally; perhaps our class manager has it ...
JarManifestReply jmr = cm.checkForPendingClass(className);
byte[] fileBytes = cm.getClassBytes(className);
if (fileBytes != null)
{
if ((jmr != null) && (wantManifest))
{
// Forward manifest of other files from the same source
for (int i = 0; i < jmr.elements.length; i++)
if (jmr.elements[i] != null)
queueFurtherRequest.write(new ClassRequest(jmr.elements[i], toRequestingClient, CR_WANT_CLASS));
toRequestingClient.write(jmr);
}
if (wantClass)
// Dispatch the file to all waiting processes
notifyOthers.write(new ClassReply(className, fileBytes));
}
else
{
if (wantClass)
// Dispatch the error to all waiting processes
notifyOthers.write(new ClassReply(className, null));
}
}
}
catch (Throwable e)
{
if (wantClass)
// Dispatch the error to all waiting processes
notifyOthers.write(new ClassReply(className, null));
}
}
/**
* Child processes spawned to load classes from disk or from another node pass the loaded data on
* this channel to the main process fror forwarding to the requesting clients.
*/
private final Any2OneChannel classNotify = Channel.any2one();
/**
* Child processes spawned to load classes from Java archives will create additional requests on
* this channel to queue other files from the archive to be sent to a client.
*/
private final Any2OneChannel classQueue = Channel.any2one();
/**
* Incoming requests from the clients.
*/
private final AltingChannelInput req;
/**
* The default class loader to get locally held classes from.
*/
private final ClassLoader classLoader;
/**
* The local class manager for tracking classes that were dynamically loaded by this node.
*/
private final ClassManager cm;
/**
* Queues (and combines) requests for classes by clients. Associates String class
* names with ChanSet objects that contain the ClassRequest objects.
*/
private final Hashtable outputQueue = new Hashtable();
/**
* Flag for indicating in a ClassRequest that a manifest is required.
*/
public static final int CR_WANT_MANIFEST = 0x0001;
/**
* Flag for indicating in a ClassRequest that the class image is required.
*/
public static final int CR_WANT_CLASS = 0x0002;
/**
* Implementation of a set type structure for holding ChannelOutput objects with
* a flag to indicate that the request set is currently being processed.
*/
private static class ChanSet
{
/**
* Holds the ChannelOutput objects.
*/
private Vector set;
/**
* true if a class is currently being loaded.
*/
private boolean beingProcessed;
/**
* Constructs a new ChanSet with an initial entry in the set.
*/
public ChanSet(ChannelOutput out)
{
set = new Vector(1);
set.addElement(out);
beingProcessed = false;
}
/**
* Sets the flag to indicate that a class is currently being loaded.
*/
public void nowBeingProcessed()
{
beingProcessed = true;
}
/**
* Returns true if a class is being loaded by another thread.
*/
public boolean isBeingProcessed()
{
return beingProcessed;
}
/**
* Adds a request (the channel to reply on) to the set.
*
* @param out channel to send the reply on.
*/
public void addRequest(ChannelOutput out)
{
for (int i = set.size() - 1; i >= 0; i--)
if (set.elementAt(i) == out)
return;
set.addElement(out);
}
/**
* Broadcast the reply to all of the clients in the set.
*
* @param reply the message to send.
*/
public void writeToAll(ClassReply reply)
{
for (Enumeration e = set.elements(); e.hasMoreElements(); )
{
ChannelOutput out = (ChannelOutput)e.nextElement();
out.write(reply);
}
}
}
/**
* Represents a class request, indicating the class required, the channel to reply to the client
* on and the flags to indicate whether a manifest is also wanted.
*/
static class ClassRequest implements Serializable
{
public ClassRequest(String className, ChannelOutput replyChan, int flags)
{
this.className = className;
this.replyChan = replyChan;
this.flags = flags;
}
public final String className;
public final ChannelOutput replyChan;
public final int flags;
}
/**
* Represents a reply to a client for a loaded class, giving the class name and binary image.
*/
static class ClassReply implements Serializable
{
public ClassReply(String className, byte[] fileBytes)
{
this.className = className;
this.fileBytes = fileBytes;
}
public final String className;
public final byte[] fileBytes;
}
/**
* Represents a reply to a client detailing a manifest of an archive.
*/
static class JarManifestReply implements Serializable
{
public JarManifestReply(String[] elements)
{
this.elements = elements;
}
public final String[] elements;
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/SerializedData.java 0000644 0000000 0000000 00000023357 11105701167 021115 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import java.io.*;
/**
* Serialized form of an object as as part of a DynamicClassLoaderMessage. The object is
* serialized to a byte array for transfer to another node. This will allow the message to be
* deserialized to obtain the JFTP reference even if the class held here is not available. When the
* relevant class has been loaded the data from the byte array can be deserialized.
*
* @author Quickstone Technologies Limited
*/
class SerializedData implements Externalizable
{
/*-------------------Constructors---------------------------------------------*/
/**
* This is the public used constructor. It takes an object and attempts
* to serialize it.
*
* @param obj the Object to Serialize.
* @param storeToString if true will create a string representation of the serialized object.
* @throws NotSerializableException If obj is not Serializable.
* @throws IOException if an IO error occurs during Serialization,
* should not happen unless there is a bug.
*/
public SerializedData(Object obj, boolean storeToString) throws NotSerializableException, IOException
{
if(obj == null)
{
serializedData = null;
if (storeToString)
objectToString = "null";
return;
}
if (storeToString)
objectToString = obj.toString();
AccesibleByteArrayOutputStream serializedDataDestination = new AccesibleByteArrayOutputStream();
ObjectOutputStream objOut = new ObjectOutputStream(serializedDataDestination);
objOut.writeObject(obj);
objOut.flush();
serializedData = serializedDataDestination.getByteArray();
try
{
serializedDataDestination.close();
objOut.close();
}
catch(IOException e)
{
e.printStackTrace();
}
}
/**
* A private constructor used during the deserialization process of this
* object. Externalizable objects require a no-arg constructor so a
* replacement object is serialized in this object's place. On
* deserialization, this object is reconstructed using this constructor.
*
* @param data a byte[] containing the serialized data of the object
* that this object is holding.
* @param objectToString The toString value of the stored object.
*/
SerializedData(byte[] data, String objectToString)
{
this.serializedData = data;
this.objectToString = objectToString;
}
/*-------------------Public Methods-------------------------------------------*/
/**
* Returns the binary serialized object.
*/
public byte[] getSerializedData()
{
return serializedData;
}
/**
* Deserializes the object from the byte[] array and returns it.
*
* @throws ClassNotFoundException if the class is not available locally and should be requested.
* @throws IOException if there is a problem with the stream.
*/
public Object get() throws ClassNotFoundException, IOException
{
return get(new BasicInputStreamFactory());
}
/**
* Deserializes the object from the byte[] array and returns it.
*
* @param factory the factory for creating the input stream.
* @throws ClassNotFoundException if the class is not available locally and should be requested.
* @throws IOException if there is a problem with the stream.
*/
public Object get(InputStreamFactory factory) throws ClassNotFoundException, IOException
{
if (serializedData == null)
return null;
ByteArrayInputStream serializedDataSource = new ByteArrayInputStream(serializedData);
ObjectInput objIn = factory.create(serializedDataSource);
Object obj = objIn.readObject();
try
{
serializedDataSource.close();
objIn.close();
}
catch(IOException e)
{
e.printStackTrace();
}
return obj;
}
/**
* Returns the string form of an object.
*/
public String getObjectToString()
{
if(objectToString == null)
return "";
return objectToString;
}
public void writeExternal(ObjectOutput out) throws IOException
{
}
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
{
}
/**
* Replaces this object with another during serialization.
*
* @return the replacement.
*/
public Object writeReplace() throws ObjectStreamException
{
ExtClass e = new ExtClass();
e.serializedData = serializedData;
e.objectToString = objectToString;
return e;
}
/*-------------------Attributes-----------------------------------------------*/
/**
* The binary form of the object in this message.
*/
private byte[] serializedData;
/**
* The string representation of the object.
*/
private String objectToString = null;
/*-------------------Inner Classes--------------------------------------------*/
/**
* This class exists purely for performance reasons. It provides an
* accessor to the internal byte[] and means that it does not need to
* be copied.
*/
private static class AccesibleByteArrayOutputStream extends ByteArrayOutputStream
{
public byte[] getByteArray()
{
return buf;
}
}
/**
* Factory for creating object input streams.
*
* @author Quickstone Technologies Limited
*/
public interface InputStreamFactory
{
/**
* Creates an object input stream based on the given input stream.
*/
public ObjectInput create(InputStream in) throws IOException;
}
/**
* Implementation of the InputStreamFactory to create a ObjectInputStream.
*
* @author Quickstone Technologies Limited
*/
private class BasicInputStreamFactory implements InputStreamFactory
{
/**
* Creates an ObjectInputStream over the top of the given input stream.
*/
public ObjectInput create(InputStream in) throws IOException
{
return new ObjectInputStream(in);
}
}
/**
* This class exists because the main class cannot have a no-arg
* constructor as required by externalizable.
*
* On serialization, this object replaces the SerializedObject.
*/
private static class ExtClass implements Externalizable
{
/**
* Constructs a new instance of this class.
*/
public ExtClass()
{}
public void writeExternal(ObjectOutput out) throws IOException
{
if(serializedData == null)
out.writeInt(0);
else
{
out.writeInt(serializedData.length);
out.write(serializedData, 0, serializedData.length);
}
out.writeObject(objectToString);
}
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
{
int arrayLength = in.readInt();
if (arrayLength > 0)
{
serializedData = new byte[arrayLength];
in.readFully(serializedData);
}
else
serializedData = null;
objectToString = (String)in.readObject();
}
public Object readResolve() throws ObjectStreamException
{
return new SerializedData(serializedData, objectToString);
}
/**
* Binary serialized form of the object.
*/
public byte[] serializedData;
/**
* String representation of the object.
*/
public String objectToString = null;
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/MigratableChannelEndFactory.java 0000644 0000000 0000000 00000007175 11105701167 023547 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import org.jcsp.net.*;
/**
* Factory for creating networked migratable channel ends. An instance of this can be created and
* the methods used. Alternatively the static methods in MigratableChannelEnd can be
* used to create the channel ends.
*
* @author Quickstone Technologies Limited
*/
public class MigratableChannelEndFactory implements NetChannelEndFactory
{
/**
* Default channel factory for creating the underlying channels.
*/
private static NetChannelEndFactory FACTORY = StandardNetChannelEndFactory.getDefaultInstance();
/**
* Constructs a new MigratableChannelEndFactory.
*/
public MigratableChannelEndFactory()
{
super();
}
/**
* @see org.jcsp.net.NetChannelEndFactory#createNet2One()
*/
public NetAltingChannelInput createNet2One()
{
return new MigratableAltingChannelInputImpl(FACTORY.createNet2One());
}
/**
* @see org.jcsp.net.NetChannelEndFactory#createNet2Any()
*/
public NetSharedChannelInput createNet2Any()
{
throw new UnsupportedOperationException("Cannot create a shared migratable channel");
}
/**
* @see org.jcsp.net.NetChannelEndFactory#createOne2Net(NetChannelLocation)
*/
public NetChannelOutput createOne2Net(NetChannelLocation loc)
{
return new MigratableChannelOutputImpl(FACTORY.createOne2Net(loc));
}
/**
* @see org.jcsp.net.NetChannelEndFactory#createAny2Net(NetChannelLocation)
*/
public NetSharedChannelOutput createAny2Net(NetChannelLocation loc)
{
throw new UnsupportedOperationException("Cannot create a shared migratable channel");
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/MigratableAltingChannelInputImpl.java 0000644 0000000 0000000 00000017552 11105701167 024571 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import java.io.*;
import java.util.Vector;
import org.jcsp.net.*;
import org.jcsp.util.filter.*;
/**
* Implements a migratable input channel end that can be used in an Alternative.
*
* @author Quickstone Technologies Limited
*/
class MigratableAltingChannelInputImpl extends MigratableAltingChannelInput
{
/**
* Factory for creating filtered channel ends.
*/
static FilteredChannelEndFactory FACTORY = new FilteredChannelEndFactory();
/**
* The actual channel input. This should not be read from.
* Use the filteredIn channel.
*
*/
private transient NetAltingChannelInput actualIn;
/**
* A filtered channel input wrapper that wraps the actualIn
* channel.
*
*/
private transient FilteredChannelInput filteredIn;
/**
* The reconnection manager for the channel.
*/
private InputReconnectionManager mgr;
/**
* A Vector of Filter objects that is used during
* serialization.
*
*/
private Vector filters = null;
/**
* Constructor for MigratableAltingChannelInputImpl.
* This takes a NetAltingChannelInput and constructs
* a default InputReconnectionManager object and then uses
* the constructor taking a single InputReconnectionManager
* object.
*
* MigratableAltingChannelInputImpl objects constructed with
* this constructor make use of the default channel name service.
*
* @param in the actual NetAltingChannelInput object to
* use.
*/
public MigratableAltingChannelInputImpl(NetAltingChannelInput in)
{
this(new InputReconnectionManagerCNSImpl(in));
}
/**
* Constructs a new MigratableAltingChannelInputImpl with a specified reconnection
* manager object. This should have been given the channel when it was constructed.
*
* @param mgr the reconnection manager.
*/
public MigratableAltingChannelInputImpl(InputReconnectionManager mgr)
{
super(mgr.getInputChannel());
actualIn = mgr.getInputChannel();
if (actualIn == null)
throw new NullPointerException("Input channel provided is null");
filteredIn = FACTORY.createFiltered(actualIn);
this.mgr = mgr;
}
/**
* @see org.jcsp.net.Networked#getChannelLocation()
*/
public NetChannelLocation getChannelLocation()
{
return this.mgr.getCurrentLocation();
}
/**
* Reads an object from the underlying channel.
*
* @return the object read.
*/
public Object read()
{
if(filteredIn == null)
{
actualIn = mgr.getInputChannel();
super.setChannel(actualIn);
filteredIn = FACTORY.createFiltered(actualIn);
if (filters != null)
{
for (int i=0; i < filters.size(); i++)
filteredIn.addReadFilter((Filter)filters.elementAt(i));
filters = null;
}
}
Object o = filteredIn.read();
return o;
}
/**
* @see org.jcsp.util.filter.ReadFiltered#addReadFilter(Filter)
*/
public void addReadFilter(Filter filter)
{
filteredIn.addReadFilter(filter);
}
/**
* @see org.jcsp.util.filter.ReadFiltered#addReadFilter(Filter, int)
*/
public void addReadFilter(Filter filter, int index)
{
filteredIn.addReadFilter(filter, index);
}
/**
* @see org.jcsp.util.filter.ReadFiltered#removeReadFilter(Filter)
*/
public void removeReadFilter(Filter filter)
{
filteredIn.removeReadFilter(filter);
}
/**
* @see org.jcsp.util.filter.ReadFiltered#removeReadFilter(int)
*/
public void removeReadFilter(int index)
{
filteredIn.removeReadFilter(index);
}
/**
* @see org.jcsp.util.filter.ReadFiltered#getReadFilter(int)
*/
public Filter getReadFilter(int index)
{
return filteredIn.getReadFilter(index);
}
/**
* @see org.jcsp.util.filter.ReadFiltered#getReadFilterCount()
*/
public int getReadFilterCount()
{
return filteredIn.getReadFilterCount();
}
/**
* @see org.jcsp.net.NetChannelInputManager#destroyReader()
*/
public void destroyReader()
{
actualIn.destroyReader();
}
/**
* Returns null.
*/
public Class getFactoryClass()
{
return null;
}
/**
* @see org.jcsp.dynamic.MigratableChannelInput#prepareToMove()
*/
public void prepareToMove()
{
mgr.prepareToMove();
}
/**
* When serializing object to the output stream, the filters from the underlying channel are
* extracted so that they too get serialized.
*
* @param out the stream to write the object to.
*/
private void writeObject(ObjectOutputStream out) throws IOException
{
//the filtered channel input object used by this class is a
//transient field. This code extracts the filters from the
//filter channel input and stores them into a Filter[] field.
//They are resinserted into a new filtered channel input on the
//first call to read()
if (filteredIn != null)
{
filters = new Vector(filteredIn.getReadFilterCount());
for (int i=0; i < filteredIn.getReadFilterCount(); i++)
filters.addElement(filteredIn.getReadFilter(i));
}
//writes all non-transient variables to the output stream
out.defaultWriteObject();
}
/**
* Reads the serialized object from an input stream. The default read implementation is used.
*
* @param in object source stream.
*/
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
{
in.defaultReadObject();
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/MigratableChannelInput.java 0000644 0000000 0000000 00000004450 11105701167 022601 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import org.jcsp.net.*;
import org.jcsp.util.filter.*;
/**
* A migratable networked input channel end.
*
* @author Quickstone Technologies Limited
*/
public interface MigratableChannelInput extends NetChannelInput, FilteredChannelInput
{
/**
* Prepares the channel end for movement to another node.
*/
public void prepareToMove();
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/NodeClassLoader.java 0000644 0000000 0000000 00000025601 11105701167 021224 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import java.util.*;
import org.jcsp.lang.*;
import org.jcsp.net.*;
/**
* Custom class loader for retrieving class files from a JFTP process on another node. Each instance
* will spawn a child process that will keep running. When a class is requested from the loader, it
* will synchronize with the child process which will contact a JFTP process and wait for data. When
* the class arrives the original caller will resume and register the class. Using a separate thread
* allows the JFTP process to push other classes to the class loader. Any classes pushed in this manner
* will be registered when the next class is requested from the class loader.
*
* @author Quickstone Technologies Limited
*/
class NodeClassLoader extends ClassLoader
{
/* loadClass in ClassLoader is synchronized so there can only ever be one pending class
* request. If further classes are pushed to the loader thread it will keep them in a collection
* until another request arrives. The next request will return an array of JFTP replies for
* classes to be registered. This array will include the actual one requested if it is available.
*/
/**
* Child process to communicate with the JFTP process, issuing requests to it and waiting for
* replies.
*/
private static class LoaderThread implements CSProcess
{
/**
* Constructs a new LoaderThread.
*
* @param sourceChannelLocation location of a JFTP process request channel.
* @param classRequest requests for classes will be received on this channel.
* @param classResponse when classes have arrived they will be passed out on this channel.
* @param deferredLoader the class loader that owns this process which will be associated with
* pending classes found in a manifest response.
* @param classManager the class manager for managing classes dynamically loaded by this node.
*/
public LoaderThread(NetChannelLocation sourceChannelLocation, AltingChannelInput classRequest,
ChannelOutput classResponse, ClassLoader deferredLoader, ClassManager classManager)
{
this.sourceChannelLocation = sourceChannelLocation;
this.classRequest = classRequest;
this.classResponse = classResponse;
this.deferredLoader = deferredLoader;
this.classManager = classManager;
}
/**
* Main process loop, servicing requests for classes from this node and receiving class replies
* from the JFTP process of a remote node.
*/
public void run()
{
try
{
NetChannelOutput out = NetChannelEnd.createOne2Net(sourceChannelLocation);
NetAltingChannelInput classIn = NetChannelEnd.createNet2One();
NetChannelOutput classOut = NetChannelEnd.createOne2Net(classIn.getChannelLocation());
Alternative alt = new Alternative(new Guard[] { classIn, classRequest });
LinkedList classesToRegister = new LinkedList();
String classPending = null;
Node.info.log(this, "Node class loader for " + sourceChannelLocation + " started");
while (true)
{
if (alt.priSelect() == 0)
{
Object objReply = classIn.read();
if (objReply instanceof JFTP.ClassReply)
{
JFTP.ClassReply cr = (JFTP.ClassReply)objReply;
classesToRegister.add(cr);
Node.info.log(this, "Definition for " + cr.className + " has arrived");
// Notify a waiting thread
if (classPending != null)
{
if (classPending.equals(cr.className))
{
classResponse.write(classesToRegister.toArray());
classesToRegister.clear();
classPending = null;
}
}
}
else if (objReply instanceof JFTP.JarManifestReply)
{
// Mark classes as pending ...
JFTP.JarManifestReply jmr = (JFTP.JarManifestReply)objReply;
for (int i = 0; i < jmr.elements.length; i++)
if (jmr.elements[i] != null)
classManager.classPending(jmr.elements[i], deferredLoader, jmr);
}
}
else
{
// A request to retrieve a class has arrived
classPending = (String)classRequest.read();
int mode = JFTP.CR_WANT_CLASS;
if (!classManager.pendingClassManifestAvailable(classPending))
mode |= JFTP.CR_WANT_MANIFEST;
// Issue request to source node
out.write(new JFTP.ClassRequest(classPending, classOut, mode));
}
}
}
catch (Exception e)
{
Node.err.log(this, e);
}
finally
{
Node.info.log(this, "Node class loader for " + sourceChannelLocation + " terminated");
}
}
/**
* Location of a JFTP process request channel.
*/
private final NetChannelLocation sourceChannelLocation;
/**
* Requests for classes will be received on this channel.
*/
private final AltingChannelInput classRequest;
/**
* When classes have arrived they will be passed out on this channel.
*/
private final ChannelOutput classResponse;
/**
* The class loader owning this process which should be associated with classes marked as
* pending.
*/
private final ClassLoader deferredLoader;
/**
* The class manager for managing classes dynamically loaded by this node.
*/
private final ClassManager classManager;
}
/**
* Constructs a new NodeClassLoader for loading classes held by a JFTP process at
* another node. On construction a child thread is spawned.
*
* @param sourceChannelLocation location of the request channel of a remote JFTP process.
* @param cm class manager responsible for dynamically loaded classes at this node.
*/
public NodeClassLoader(NetChannelLocation sourceChannelLocation, ClassManager cm)
{
new ProcessManager(new LoaderThread(sourceChannelLocation, classReq.in(), classResp.out(), this, cm)).start();
classManager = cm;
}
/**
* Issues a request to the child process to get a class definition from the remote JFTP process.
* If the JFTP process has been pushing class definitions to this node the child process may return
* multiple results. One of them will be the requested class. All will be registered and a note
* is taken of the one requested so that it can be returned.
*
* @param name name of the class to load.
* @return the class instance.
* @throws ClassNotFoundException if the remote node did not have the class.
*/
public Class findClass(String name) throws ClassNotFoundException
{
// Request the class from the loader thread
classReq.out().write(name);
Object[] replies = (Object[])classResp.in().read();
// Register all of the classes returned by the loader
Class found = null;
for (int i = 0; i < replies.length; i++)
{
JFTP.ClassReply reply = (JFTP.ClassReply)replies[i];
if (reply.fileBytes != null)
{
Class cls;
try
{
cls = defineClass(reply.className, reply.fileBytes, 0, reply.fileBytes.length);
classManager.registerClass(cls, reply.fileBytes);
}
catch (LinkageError e)
{
cls = loadClass(reply.className);
}
// Take note of the one actually requested
if (reply.className.equals(name)) found = cls;
}
else
Node.info.log(this, "Class " + reply.className + " not available at source node");
}
if (found == null)
throw new ClassNotFoundException("Class " + name + " not found.");
return found;
}
/**
* Channel for passing requests from the findClass method to the child process.
*/
private final One2OneChannel classReq = Channel.one2one();
/**
* Channel for returning data from the child process to the findClass method.
*/
private final One2OneChannel classResp = Channel.one2one();
/**
* The class manager responsible for managing dynamically loaded classes at this node.
*/
private final ClassManager classManager;
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/NamedMigratableChannelEndFactory.java 0000644 0000000 0000000 00000006746 11105701167 024517 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import org.jcsp.net.cns.NameAccessLevel;
/**
* Factory interface for creating migratable networked channel input ends using a CNS service.
*
* @author Quickstone Technologies Limited
*/
public interface NamedMigratableChannelEndFactory
{
/**
* Creates a named migratable networked channel input end that can be used as a guard in an Alternative.
*
* @param name the name to use.
* @return the created channel end.
*/
public MigratableAltingChannelInput createNet2One(String name);
/**
* Creates a named migratable networked channel input end that can be used as a guard in an Alternative.
*
* @param name the name to use.
* @param nameAccessLevel the namespace to declare the name within.
* @return the created channel end.
*/
public MigratableAltingChannelInput createNet2One(String name, NameAccessLevel nameAccessLevel);
/**
* Creates a networked migratable channel output end connected to the input end created with the given name.
*
* @param name the name the input end was created with.
* @return the created channel end.
*/
public MigratableChannelOutput createOne2Net(String name);
/**
* Creates a networked migratable channel output end connected to the input end created with the given name.
*
* @param name the name the input end was created with.
* @return the created channel end.
*/
public MigratableChannelOutput createOne2Net(String name, NameAccessLevel accessLevel);
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/package.html 0000644 0000000 0000000 00000000667 10520670125 017644 0 ustar
NamedMigratableChannelEndFactoryImpl for use with the given
* CNS service name.
*
* @param cnsServiceName the name of the CNS service to use.
*/
public NamedMigratableChannelEndFactoryImpl(String cnsServiceName)
{
super();
factoryToUse = StandardNetChannelEndFactory.getDefaultInstance();
this.cnsServiceName = cnsServiceName;
cnsUser = (CNSUser)Node.getInstance().getServiceUserObject(cnsServiceName);
}
/**
* Constructs a new NamedMigratableChannelEndFactoryImpl using the default CNS
* service name.
*/
public NamedMigratableChannelEndFactoryImpl()
{
this(CNSService.CNS_DEFAULT_SERVICE_NAME);
}
/**
* @see org.jcsp.net.dynamic.NamedMigratableChannelEndFactory#createNet2One(String)
*/
public MigratableAltingChannelInput createNet2One(String name)
{
return createNet2One(name, null);
}
/**
* @see org.jcsp.net.dynamic.NamedMigratableChannelEndFactory#createNet2One(String, NameAccessLevel)
*/
public MigratableAltingChannelInput createNet2One(String name, NameAccessLevel nameAccessLevel)
{
NetAltingChannelInput chanIn = factoryToUse.createNet2One();
ChannelNameKey key = (nameAccessLevel != null)
? cnsUser.register(chanIn, name, nameAccessLevel)
: cnsUser.register(chanIn, name);
InputReconnectionManager mgr = new InputReconnectionManagerCNSImpl(chanIn, name, nameAccessLevel, key, cnsServiceName);
return new MigratableAltingChannelInputImpl(mgr);
}
/**
* @see org.jcsp.net.dynamic.NamedMigratableChannelEndFactory#createOne2Net(String)
*/
public MigratableChannelOutput createOne2Net(String name)
{
return createOne2Net(name);
}
/**
* @see org.jcsp.net.dynamic.NamedMigratableChannelEndFactory#createOne2Net(String, NameAccessLevel)
*/
public MigratableChannelOutput createOne2Net(String name, NameAccessLevel accessLevel)
{
NetChannelLocation loc = (accessLevel != null)
? cnsUser.resolve(name)
: cnsUser.resolve(name, accessLevel);
return new MigratableChannelOutputImpl(factoryToUse.createOne2Net(loc));
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/NotNameableNetChannelLocation.java 0000644 0000000 0000000 00000005454 11105701167 024044 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import org.jcsp.net.NetChannelLocation;
import org.jcsp.net.cns.LocationNotCNSRegisterable;
/**
* Instances of this class take another NetChannelLocation
* object and effectivly "clone" its attributes. The CNS will not
* register channels at these locations due to this class implementing
* the LocationNotCNSRegisterable interface.
*
* @author Quickstone Technologies Limited
*/
class NotNameableNetChannelLocation extends NetChannelLocation implements LocationNotCNSRegisterable
{
/**
* Constructor which takes another NetChannelLocation
* object to "copy".
*
* @param other
* @throws IllegalArgumentException if super class constructor throws it.
*/
public NotNameableNetChannelLocation(NetChannelLocation other) throws IllegalArgumentException
{
super(other);
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/DataSerializationFilter.java 0000644 0000000 0000000 00000007542 11105701167 023003 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import java.io.*;
import org.jcsp.net.*;
import org.jcsp.util.filter.*;
/**
* DeserializeChannelFilter
* plugged in. Any objects send by this filter will be wrapped in a DynamicClassLoaderMessage
* object which includes the NetChannelLocation of a channel for the local node's JFTP
* service.DynamicClassLoader service and should
* be obtained via its getTxFilter method.DataSerializationFilter object.
*
* @param senderLoc the location of the JFTP service's request channel.
*/
//public DataSerializationFilter(ClassManager cm, NetChannelLocation senderLoc) {
public DataSerializationFilter(NetChannelLocation senderLoc)
{
this.senderLoc = senderLoc;
}
/**
* Wraps the object in a DynamicClassLoaderMessage complete with the JFTP channel
* location passed to the filter's constructor.
*
* @param obj the object to wrap up
* @return the wrapped object
*/
public Object filter(Object obj)
{
try
{
obj = new DynamicClassLoaderMessage(obj, senderLoc);
}
catch (NotSerializableException e)
{
throw new RuntimeException("Unable to serialize " + obj);
}
catch (IOException e)
{
throw new RuntimeException("IOException while trying to serialize " + obj);
}
return obj;
}
/**
* Location of the JFTP service's request channel.
*/
private NetChannelLocation senderLoc;
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/InputReconnectionManagerCNSImpl.java 0000644 0000000 0000000 00000034522 11105701167 024353 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import org.jcsp.net.*;
import org.jcsp.net.cns.*;
import java.io.*;
import java.lang.reflect.*;
/**
* Implementation of the InputReconnectionManager to work with a CNS service for resolution
* of the channel's current location.
*
* @author Quickstone Technologies Limited
*/
class InputReconnectionManagerCNSImpl implements InputReconnectionManager
{
/**
* The underlying input channel end.
*/
private NetAltingChannelInput chanIn;
/**
* The factory class used to create the channel end.
*/
Class channelFactoryClass = null;
/**
* Identification of the CNS service to use.
*/
private String cnsServiceNameToUse = null;
/**
* Name registered with the CNS.
*/
private String cnsRegisteredName = null;
/**
* NameAccessLevel used to register the name against with the CNS.
*/
private NameAccessLevel cnsRegisteredNameAccessLevel = null;
/**
* The name key allocated to the channel.
*/
private ChannelNameKey key = null;
/**
* True if the channel end has been prepared for serialization (migration).
*/
private transient boolean serializable = false;
/**
* Current location of the channel.
*/
private transient NetChannelLocation cnsNetChannelLocation = null;
/**
* Constant for representing a possible channel state.
*/
private static final int MSG_CHAN_SERIALIZABLE = 1;
/**
* Constant for representing a possible channel state.
*/
private static final int MSG_CHAN_NETWORKED = 2;
/**
* Constant for representing a possible channel state.
*/
private static final int MSG_TERMINATE = 3;
/**
* Unique prefix to use when registering channels with the CNS. It is assumed that only the
* reconnection managers will be using channels with names of this form.
*/
static final String anonymousCnsNamePrefix = "org.jcsp.net.cns ANON";
/**
* Constructs a new InputReconnectionManagerCNSImpl for use with the given input
* channel. The default CNS service name will be used.
*
* @param chanIn the input channel end.
*/
public InputReconnectionManagerCNSImpl(NetAltingChannelInput chanIn)
{
this(chanIn, null);
}
/**
* Constructs a new InputReconnectionManagerCNSImpl for use with the given input
* channel and a specific CNS service.
*
* @param chanIn the input channel end.
* @param cnsServiceName name of the CNS service to use.
*/
public InputReconnectionManagerCNSImpl(NetAltingChannelInput chanIn, String cnsServiceName)
{
super();
this.chanIn = chanIn;
this.cnsServiceNameToUse = cnsServiceName;
}
/**
* Constructs a new InputReconnectionManagerCNSImpl for use with CNS registered
* channels using NameAccessLevel application isolation. The default CNS service name
* is used.
*
* @param chanIn the input channel end.
* @param name the CNS registered name of the channel.
* @param accessLevel the application isolation level.
* @param key the allocated channel key.
*/
public InputReconnectionManagerCNSImpl(NetAltingChannelInput chanIn, String name,
NameAccessLevel accessLevel, ChannelNameKey key)
{
this(chanIn, name, accessLevel, key, null);
}
/**
* Constructs a new InputReconnectionManagerCNSImpl for use with CNS registered
* channels.
*
* @param chanIn the input channel end.
* @param name the CNS registered name of the channel.
* @param accessLevel the application isolation level.
* @param key the allocated channel key.
* @param cnsServiceName name of the CNS service to use.
*/
public InputReconnectionManagerCNSImpl(NetAltingChannelInput chanIn, String name, NameAccessLevel accessLevel,
ChannelNameKey key, String cnsServiceName)
{
this.chanIn = chanIn;
this.key = key;
this.cnsRegisteredName = name;
this.cnsRegisteredNameAccessLevel = accessLevel;
this.cnsServiceNameToUse = cnsServiceName;
}
/**
* Obtain the NetAltingChannelInput object to use.
*
* After serialization, the first call to this method will reconstruct
* the channel and register it with the CNS.
*
* If there is a problem while trying to construct a channel,
* a ChannelEndContructionException will be thrown.
*
* @see org.jcsp.net.dynamic.InputReconnectionManager#getInputChannel()
*/
public NetAltingChannelInput getInputChannel()
{
if (chanIn == null)
{
try
{
Constructor c = channelFactoryClass.getConstructor(new Class[]{});
Method createMethod = null;
Method[] createMethods = channelFactoryClass.getMethods();
for (int j=0; jgetInputChannel() has not been called.
*
* @see org.jcsp.net.dynamic.InputReconnectionManager#prepareToMove()
*/
public void prepareToMove()
{
if(serializable)
return;
if (cnsRegisteredName == null)
{
//channel is anonymous or name is not known
//need to register a name
try
{
NetChannelLocation loc = chanIn.getChannelLocation();
cnsRegisteredName = anonymousCnsNamePrefix + loc.getStringID();
cnsRegisteredNameAccessLevel = NameAccessLevel.GLOBAL_ACCESS_LEVEL;
key = cnsServiceNameToUse == null
? CNS.leaseChannelName(cnsRegisteredName, cnsRegisteredNameAccessLevel, null)
: ((CNSUser)Node.getInstance().getServiceUserObject(cnsServiceNameToUse))
.leaseChannelName(cnsRegisteredName, cnsRegisteredNameAccessLevel, null);
serializable = true;
}
catch (Exception e)
{
cnsRegisteredName = null;
cnsRegisteredNameAccessLevel = null;
key = null;
return;
}
}
else
{
//name is registered - lease it!
try
{
key = cnsServiceNameToUse == null
? CNS.leaseChannelName(cnsRegisteredName, cnsRegisteredNameAccessLevel, key)
: ((CNSUser) Node.getInstance().getServiceUserObject(cnsServiceNameToUse))
.leaseChannelName(cnsRegisteredName, cnsRegisteredNameAccessLevel, key);
serializable = true;
}
catch (Exception e)
{
return;
}
}
if (serializable)
chanIn.destroyReader();
}
/**
* Serialization method to write this object to a stream.
*
* @param out destination stream to serialize to.
*/
private void writeObject(ObjectOutputStream out) throws IOException
{
if(!serializable)
throw (new NotSerializableException(getClass().getName()));
if(chanIn != null)
{
if (chanIn instanceof Serializable)
{
//channel is serializable so serialize it!
out.writeInt(MSG_CHAN_SERIALIZABLE);
out.writeObject(chanIn);
}
else
{
out.writeInt(MSG_CHAN_NETWORKED);
out.writeObject(chanIn.getFactoryClass());
out.writeObject(cnsRegisteredName);
out.writeObject(cnsRegisteredNameAccessLevel);
out.writeObject(key);
out.writeObject(cnsServiceNameToUse);
}
}
else
{
out.writeInt(MSG_CHAN_NETWORKED);
out.writeObject(channelFactoryClass);
out.writeObject(cnsRegisteredName);
out.writeObject(cnsRegisteredNameAccessLevel);
out.writeObject(key);
out.writeObject(cnsServiceNameToUse);
}
out.writeInt(MSG_TERMINATE);
}
/**
* Serialization method to read this object from a stream.
*
* @param in the source stream.
*/
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException
{
int i = in.readInt();
if(i < MSG_TERMINATE)
{
switch(i)
{
case MSG_CHAN_SERIALIZABLE:
chanIn = (NetAltingChannelInput)in.readObject();
break;
case MSG_CHAN_NETWORKED:
//the channel does not get constructed here
//this is done in the getInputChannel() method
channelFactoryClass = (Class)in.readObject();
cnsRegisteredName = (String)in.readObject();
cnsRegisteredNameAccessLevel = (NameAccessLevel)in.readObject();
key = (ChannelNameKey) in.readObject();
cnsServiceNameToUse = (String) in.readObject();
//this gets set to false in the getInputChannel() method
serializable = true;
break;
}
//read the terminate msg
in.readInt();
}
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/ChannelEndContructionException.java 0000644 0000000 0000000 00000006500 11105701167 024325 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
/**
* Thrown when a reconnection mannager is unable to recreate the underlying channel.
*
* @author Quickstone Technologies Limited
*/
public class ChannelEndContructionException extends RuntimeException
{
/**
* Constructs a ChannelEndConstructionException without a detail message or cause.
*/
public ChannelEndContructionException()
{
super();
}
/**
* Constructs a ChannelEndConstructionException with a detail message.
*
* @param message the detail message indicating why the exception was raised.
*/
public ChannelEndContructionException(String message)
{
super(message);
}
/**
* Constructs a ChannelEndContructionException with a detail message and underlying
* cause.
*
* @param message the detail message.
* @param cause the exception that was caught while trying to perform the construction operation.
*/
public ChannelEndContructionException(String message, Throwable cause)
{
super(message, cause);
}
/**
* Constructs a ChannelEndConstructionException with a cause indicator.
*
* @param cause the exception that was caught while trying to perform the construction operation.
*/
public ChannelEndContructionException(Throwable cause)
{
super(cause);
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/MigratableChannelEnd.java 0000644 0000000 0000000 00000011662 11105701167 022213 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import org.jcsp.net.*;
import org.jcsp.net.cns.*;
/**
* Static factory for creating migratable channel ends.
*
* @author Quickstone Technologies Limited
*/
public class MigratableChannelEnd
{
/**
* Standard factory for anonymous channel ends.
*/
private static MigratableChannelEndFactory FACTORY = new MigratableChannelEndFactory();
/**
* Factory for named channel ends.
*/
private static NamedMigratableChannelEndFactory NAMED_FACTORY = new NamedMigratableChannelEndFactoryImpl();
/**
* Creates a new MigratableChannelEnd object. This is private to prevent any
* instances from being created. This class contains only static methods.
*/
private MigratableChannelEnd()
{
super();
}
/**
* Creates an anonymous migratable channel input.
*
* @return the created channel end.
*/
public static MigratableAltingChannelInput createNet2One()
{
return (MigratableAltingChannelInput) FACTORY.createNet2One();
}
/**
* Creates a migratable channel output to a given location.
*
* @param loc location of the input end of the channel.
* @return the created channel end.
*/
public static MigratableChannelOutput createOne2Net(NetChannelLocation loc)
{
return (MigratableChannelOutput) FACTORY.createOne2Net(loc);
}
/**
* Creates a named migratable channel input using the default namespace.
*
* @param name the name of the channel to register with the CNS.
* @return the created channel end.
*/
public static MigratableAltingChannelInput createNet2One(String name)
{
return createNet2One(name, null);
}
/**
* Creates a named migratable channel input within the given namespace.
*
* @param name the name of the channel to register with the CNS.
* @param nameAccessLevel the namespace to register the name within.
* @return the created channel end.
*/
public static MigratableAltingChannelInput createNet2One(String name, NameAccessLevel nameAccessLevel)
{
return NAMED_FACTORY.createNet2One(name, nameAccessLevel);
}
/**
* Creates a migratable channel output to a named channel within the default namespace.
*
* @param name the name of the channel as registered with the CNS.
* @return the created channel end.
*/
public static MigratableChannelOutput createOne2Net(String name)
{
return createOne2Net(name, null);
}
/**
* Creates a migratable channel output to a named channel within a given namespace.
*
* @param name the name of the channel as registered with the CNS.
* @param nameAccessLevel the namespace the name is registered within.
* @return the created channel end.
*/
public static MigratableChannelOutput createOne2Net(String name, NameAccessLevel nameAccessLevel)
{
return NAMED_FACTORY.createOne2Net(name, nameAccessLevel);
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/DynamicClassLoader.java 0000644 0000000 0000000 00000020631 11105701167 021721 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import java.io.*;
import org.jcsp.lang.*;
import org.jcsp.net.*;
import org.jcsp.util.filter.*;
/**
* A service implementation for supporting dynamic class transfer at a node. When started, JFTP server
* and ClassMananger processes will be spawned and send/receive filters created. To support
* dynamic class loading over a given channel, plug the TX filter into the sending end and the RX filter
* into the receiving end. The channel can then be used normally.
*
* @author Quickstone Technologies Limited
*/
public class DynamicClassLoader implements Service
{
/**
* Starts the dynamic loader service by spawning ClassManager and JFTP
* processes.
*
* @return true if the service started successfully.
*/
public boolean start()
{
cm = new ClassManager();
new ProcessManager(cm).start();
channelRxFilter = new DeserializeChannelFilter(cm);
NetAltingChannelInput requests = NetChannelEnd.createNet2One();
JFTP localFileService = new JFTP(ClassLoader.getSystemClassLoader(), requests, cm);
new ProcessManager(localFileService).start();
this.channelTxFilter = new DataSerializationFilter(requests.getChannelLocation());
running = true;
Node.info.log(this, "Dynamic Class Loading Service Started");
return running;
}
/**
* Stops the dynamic loader service.
*/
public boolean stop()
{
return false;
}
/**
* Initializes the dynamic loader service.
*/
public boolean init(ServiceSettings settings)
{
return true;
}
/**
* Returns true iff the service is running.
*/
public boolean isRunning()
{
return running;
}
/**
* Returns the service user object.
*/
public ServiceUserObject getUserObject() throws SecurityException
{
return new DynamicClassLoaderUserObject();
}
/**
* Returns the TX filter to be used at the sending end of a channel if dynamic class loading is to
* be supported over that channel. If there is a TX filter at the sending end, there must be a RX
* filter at the receiving end.
*/
public Filter getChannelTxFilter()
{
return channelTxFilter;
}
/**
* Returns the RX filter to be used at the receiving end of a channel if dynamic class loading is to
* be supported over that channel. The filter returned is safe to use if there is no TX filter at
* the sending end.
*/
public Filter getChannelRxFilter()
{
return channelRxFilter;
}
/**
* An alternative RX filter that does not support dynamic class loading but will properly
* unmarshal objects wrapped up by a TX filter.
*/
public static Filter getNonDynamicClassLoadingRxFilter()
{
return nonDynamicClassLoadingRxFilter;
}
/**
* User interface to obtain the TX and RX filters from the service once it has been started.
*/
public class DynamicClassLoaderUserObject implements ServiceUserObject
{
/**
* Constructs a new DynamicClassLoaderUserObject.
*/
private DynamicClassLoaderUserObject()
{
}
/**
* Returns the TX filter to be used at the sending end of a channel if dynamic class laoding is
* to be supported over that channel. If there is a TX filter at the sending end, there must be
* a RX filter at the receiving end.
*/
public Filter getChannelTxFilter()
{
return channelTxFilter;
}
/**
* Returns the RX filter to be used at the receiving end of a channel if dynamic class loading
* is to be supported over that channel. The filter returned is safe to use if there is no
* TX filter at the sending end.
*/
public Filter getChannelRxFilter()
{
return channelRxFilter;
}
}
/**
* Stores the current state of the service.
*/
private boolean running = false;
/**
* The TX filter created when the service started, returned by getChannelTxFilter.
*/
private DataSerializationFilter channelTxFilter = null;
/**
* The RX filter created when the service started, returned by getChannelRxFilter.
*/
private DeserializeChannelFilter channelRxFilter = null;
/**
* The class manager process started by the service.
*/
private ClassManager cm;
/**
* Default service name.
*/
public static final String name = "dynamic_class_loading";
/**
* The alternative RX filter that does not support dynamic class loading, returned by
* getNonDynamicClassLoadingRxFilter.
*/
private static Filter nonDynamicClassLoadingRxFilter = new Filter()
{
public Object filter(Object data)
{
if (data instanceof DynamicClassLoaderMessage)
{
try
{
return ((DynamicClassLoaderMessage) data).get(null);
}
catch (ClassNotFoundException e)
{
Node.err.log(this, e);
}
catch (IOException e)
{
Node.err.log(this, e);
}
}
return data;
}
};
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/InputReconnectionManager.java 0000644 0000000 0000000 00000005312 11105701167 023160 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import org.jcsp.net.*;
import java.io.Serializable;
/**
* Receiving end of a migratable channel. The underlying channel can be obtained by the
* getInputChannel method and used like any other channel. Before migrating the channel,
* the prepareToMove method must be called.
*
* @author Quickstone Technologies Limited
*/
public interface InputReconnectionManager extends Serializable
{
/**
* Returns the underlying input channel.
*/
public NetAltingChannelInput getInputChannel();
/**
* Returns the current location of the channel.
*/
public NetChannelLocation getCurrentLocation();
/**
* Prepares the channel for a transfer between nodes.
*/
public void prepareToMove();
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/MigratableAltingChannelInput.java 0000644 0000000 0000000 00000005425 11105701167 023743 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import java.io.Serializable;
import org.jcsp.net.*;
import org.jcsp.util.filter.FilteredChannelInput;
/**
* A migratable input channel end that can be used as a guard within an Alternative.
*
* @author Quickstone Technologies Limited
*/
public abstract class MigratableAltingChannelInput
extends NetAltingChannelInput
implements MigratableChannelInput, FilteredChannelInput, Serializable
{
/**
* Constructs a new MigratableAltingChannelInput for the underlying channel.
*
* @param channel the underlying channel.
*/
protected MigratableAltingChannelInput(NetAltingChannelInput channel)
{
super(channel);
}
/**
* Constructs a new MigratableAltingChannelInput.
*/
protected MigratableAltingChannelInput()
{
super();
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/MigratableChannelOutput.java 0000644 0000000 0000000 00000004547 11105701167 023011 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import java.io.Serializable;
import org.jcsp.net.NetChannelOutput;
import org.jcsp.util.filter.*;
/**
* A migratable networked channel output end.
*
* @author Quickstone Technologies Limited
*/
public interface MigratableChannelOutput extends NetChannelOutput, FilteredChannelOutput, Serializable
{
/**
* Prepares the channel end for movement to another node.
*/
public void prepareToMove();
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/ChannelEndNotMoveableException.java 0000644 0000000 0000000 00000006315 11105701167 024235 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
/**
* Thrown when a channel end cannot be moved.
*
* @author Quickstone Technologies Limited
*/
public class ChannelEndNotMoveableException extends RuntimeException
{
/**
* Constructs a new ChannelEndNotMoveableException without a detail message or
* cause.
*/
public ChannelEndNotMoveableException()
{
super();
}
/**
* Constructs a new ChannelEndNotMoveableException with a detail message.
*
* @param message the detail message.
*/
public ChannelEndNotMoveableException(String message)
{
super(message);
}
/**
* Constructs a new ChannelEndNotMoveableException with a detail message and
* underlying cause exception.
*
* @param message the detail message.
* @param cause the exception that caused this one to be raised.
*/
public ChannelEndNotMoveableException(String message, Throwable cause)
{
super(message, cause);
}
/**
* Constructs a new ChannelEndNotMoveableException with a cause exception.
*
* @param cause the exception that caused this one to be raised.
*/
public ChannelEndNotMoveableException(Throwable cause)
{
super(cause);
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/ClassManager.java 0000644 0000000 0000000 00000035750 11105701167 020570 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import java.util.*;
import org.jcsp.lang.*;
import org.jcsp.net.*;
/**
* NodeClassLoader has not been started, one will be created
* and used for all subsequent requests to be issued to the remote node.NodeClassLoader
* receives a JarManifestReply from a remote node to indicate that requests for the
* class should be directed to that class loader. If a JFTP process receives a request for a
* class that is not held locally it will check the set of pending classes to determine the class
* loader that it should invoke to retrieve the class.NodeClassLoader has received a class as a result of an issued request or a JFTP
* process push.checkForPendingClass which will also issue a request to load
* the class from the remote node.
*
* @param className the name of the class to check.
*/
public boolean pendingClassManifestAvailable(String className)
{
synchronized (classPendings)
{
return classManifests.get(className) != null;
}
}
/**
* classPending will be used. If
* there is no associated class loader, no action is taken. If there is a manifest reply associated
* with the class this will be returned for possible forwarding to another node.cls parameter but possibly a different class if
* one has already been registered by another class loader.
*/
public Class registerClass(Class cls, byte[] fileBytes)
{
classRegChan.out().write(cls);
Class classToReturn = (Class) classRegReplyChan.in().read();
if (cls == classToReturn && fileBytes != null)
{
RegisteredClass rc = new RegisteredClass();
rc.name = classToReturn.getName();
classFiles.put(rc, fileBytes);
}
return classToReturn;
}
/**
* Gets the binary image for a given class.
*
* @param name name of the class.
* @return the binary image registered by a call to registerClass.
*/
public byte[] getClassBytes(String name)
{
RegisteredClass rc = new RegisteredClass();
rc.name = name;
byte[] fileBytes = (byte[]) classFiles.get(rc);
return fileBytes;
}
/**
* Used to pass requests to the main process thread from calls to the getClass method.
*/
private Any2OneChannel classReqs = Channel.any2one();
/**
* Used to pass requests to the main process thread from calls to the registerClass
* method.
*/
private Any2OneChannel classRegChan = Channel.any2one();
/**
* Used to pass replies from the main process thread to callers of the registerClass
* method.
*/
private One2OneChannel classRegReplyChan = Channel.one2one();
/**
* A local reference to the system class loader. This is held as an attribute so that it would be
* possible to change the class loader that this process tries by default when resolving classes.
*/
private ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
/**
* Maps RegisteredClass objects to byte[] binary images.
*/
private Hashtable classes = new Hashtable();
/**
* Maps NetChannelLocation objects to NodeClassLoader objects to use to
* retrieve classes from that node.
*/
private Hashtable classLoaders = new Hashtable();
// source chan -> class loader
/**
* Maps String class names to byte[] binary images.
*/
private Hashtable classFiles = new Hashtable(); // name -> binary
/**
* Maps String class names to NodeClassLoader objects to use to retrieve
* them.
*/
private Hashtable classPendings = new Hashtable(); // name -> class loader
/**
* Maps String class names to JarManifestReply objects.
*/
private Hashtable classManifests = new Hashtable();
// name -> manifest reply
/**
* Marshals a set of parameters for passing information between getClass and the
* main process thread.
*/
private static class ClassRequest
{
public ClassRequest(String name, NetChannelLocation classSourceChannelLoc, ChannelOutput replyChan)
{
this.name = name;
this.classSourceChannelLoc = classSourceChannelLoc;
this.replyChan = replyChan;
}
//public final long serialVersionID;
public final String name;
public final NetChannelLocation classSourceChannelLoc;
public final ChannelOutput replyChan;
}
/**
* Used in the classes hash table to represent class names. The current implementation
* just represents a class name, however it could be modified to include version numbers and
* distinguish classes with the same name but different implementations.
*/
private static class RegisteredClass implements Cloneable
{
public boolean equals(Object o)
{
if (o == null || !(o instanceof RegisteredClass))
return false;
RegisteredClass other = (RegisteredClass) o;
return name.equals(other.name);
}
public int hashCode()
{
return (int) /*version +*/
name.hashCode();
}
public Object clone() throws CloneNotSupportedException
{
return super.clone();
}
public String name;
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/DeserializeChannelFilter.java 0000644 0000000 0000000 00000011504 11105701167 023116 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import java.io.*;
import org.jcsp.util.filter.*;
import org.jcsp.net.*;
/** This class is used in the dynamic class loading mechanism.
* Instances of the class extract Message objects from SerializedMessage objects.
* Dynamic class loading can be enabled by using the constructor which takes a ClassManager.
* If dynamic class loading is enabled and a DynamicClassLoaderMessage is filtered, the ClassManager object is supplied to the Message object and the underlying message extracted.
* Any classes that need loading from the remote Node are requested and loaded as necessary.
*
* @author Quickstone Technologies Limited
*/
class DeserializeChannelFilter implements Filter
{
/**
* Constructs a new DeserializeChannelFilter with a reference to a class manager.
*
* @param cm the class manager to use for received classes.
*/
DeserializeChannelFilter(ClassManager cm)
{
this.cm = cm;
this.dynamic = true;
}
/**
* Constructs a new DeserializeChannelFilter with dynamic loading disabled.
*/
DeserializeChannelFilter()
{
this.dynamic = false;
}
/** This method takes an object and substitutes it for another object based upon the following rules:
*
* If the object is an instance of the DynamicClassLoaderMessage class and dynamic class loading is enabled,
* then the filter will return the object returned by the supplied object's get method. A ClassManager will be
* supplied to the method.
*
* If the object is an instance of the SerializedMessage class then the object's get
* method will be called. The message being held by the SerializedMessage will be deserialized
* but classes will not be dynamically loaded.
*
* If the object is not a SerializedMessage object, then the object itself will be returned without
* modification.
* @param object The object to filter.
* @return the substituted object.
*/
public Object filter(Object object)
{
try
{
if (dynamic && object instanceof DynamicClassLoaderMessage)
return ((DynamicClassLoaderMessage)object).get(cm);
else
return object;
}
catch (ClassNotFoundException e)
{
Node.err.log(this, e);
}
catch (IOException e)
{
Node.err.log(this, e);
}
//return object at the moment decide later - this is only prototype version
return object;
}
/**
* The class manger to use for classes dynamically received.
*/
private ClassManager cm;
/**
* Set to true if dynamic class loading is enabled. If false, no filtering rules are applied.
*/
private boolean dynamic;
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/DynamicClassLoaderMessage.java 0000644 0000000 0000000 00000016027 11105701167 023232 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import java.io.*;
import org.jcsp.lang.*;
import org.jcsp.net.*;
/**
* Wraps an object when it is being sent over a channel by the DataSerializationFilter so
* that it includes a NetChannelLocation referring to the JFTP request channel to service
* requests for the class's binary image if it is not held at the receiving end.
*
* @author Quickstone Technologies Limited
*/
class DynamicClassLoaderMessage implements Serializable
{
/**
* Creates a new DynamicClassLoaderMessage encapsulating the given object.
*
* @param data the actual user object being sent.
* @param classSourceChannelLoc the request channel of the JFTP process.
*/
public DynamicClassLoaderMessage(Object data, NetChannelLocation classSourceChannelLoc)
throws NotSerializableException, IOException
{
this.classSourceChannelLoc = classSourceChannelLoc;
this.createTime = System.currentTimeMillis();
this.serializedData = new SerializedData(data,false);
}
/**
* Creation timestamp.
*/
private long createTime;
/**
* Diagnostic string identifying the message by timestamp.
*/
public String toString()
{
return "DynamicClassLoaderMessage " + createTime;
}
/**
* Public accessor to deserialize and retrieve the object using the specified
* ClassManager.
*
* @param cm the class manager to use.
* @return the user object passed in this message.
*/
public Object get(ClassManager cm) throws ClassNotFoundException, IOException
{
//JA - probably don't want to create a new factory each time
if (cm != null)
{
Object g = serializedData.get(new AdvancedInputStreamFactory(cm));
return g;
}
return serializedData.get();
}
/**
* Sets the class loader to use when deserializing the object.
*
* @param classLoader the new class loader.
*/
public void setClassLoader(ClassLoader classLoader)
{
this.classLoaderToUse = classLoader;
}
/**
* The class loader to use when deserializing the object. This is not sent as part of the message -
* it is for use by methods invoked by the receiver.
*/
private transient ClassLoader classLoaderToUse = null;
/**
* The location of the request channel of the sender's JFTP process.
*/
private final NetChannelLocation classSourceChannelLoc;
/**
* The serialized form of the user object being sent.
*/
private SerializedData serializedData;
/**
* This allows a custom ClassLoader to be used to resolve the object
* being deserialized.
*
* @author Jo Aldous
*/
private class AdvancedObjectInputStream extends ObjectInputStream
{
/**
* Constructs a new AdvancedObjectInputStream.
*
* @param cm the class manager process at this node.
* @param in the underlying input stream to read data from.
*/
public AdvancedObjectInputStream(ClassManager cm, InputStream in) throws IOException
{
super(in);
this.cm = cm;
}
/**
* Attempts to resolve the class requested using the class manager. If this fails an exception
* is raised.
*
* @param v indicates the class to resolve.
* @throws IOException if there is a problem with the underlying stream.
* @throws ClassNotFoundException if the class could not be resolved.
* @return the resolved class.
*/
protected Class resolveClass(ObjectStreamClass v) throws IOException, ClassNotFoundException
{
One2OneChannel in = Channel.one2one();
cm.getClass(v.getName(), classSourceChannelLoc, in.out());
Object reply = in.in().read();
if(reply instanceof Class)
return (Class) reply;
throw new ClassNotFoundException(v.getName());
}
/**
* The class manager to use when resolving a class.
*/
private ClassManager cm;
}
/**
* Factory for creating instances of AdvancedObjectInputStream bound to a given
* class manager.
*/
private class AdvancedInputStreamFactory implements SerializedData.InputStreamFactory
{
/**
* Constructs a new factory for the given class manager. All streams created by this factory
* will be associated with this class manager.
*
* @param cm class manager to associate will all created streams.
*/
AdvancedInputStreamFactory(ClassManager cm)
{
this.cm = cm;
}
/**
* Creates a new input stream.
*
* @param in the underlying input stream.
*/
public ObjectInput create(InputStream in) throws IOException
{
return new AdvancedObjectInputStream(cm, in);
}
/**
* The class manager to associate with all created input streams.
*/
private ClassManager cm;
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/dynamic/OutputReconnectionManager.java 0000644 0000000 0000000 00000005154 11105701167 023365 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.dynamic;
import java.io.Serializable;
import org.jcsp.net.*;
/**
* Writing end of a migratable channel. The underlying channel end can be obtained by a call to
* getOutputChannel and used like any other channel. Before transfering the channel end
* to another node the prepareToMove() method must be called.
*
* @author Quickstone Technologies Limited
*/
public interface OutputReconnectionManager extends Serializable
{
/**
* Returns the underlying channel output end.
*/
public NetChannelOutput getOutputChannel();
/**
* Prepares the channel end for transfer to another node.
*/
public void prepareToMove();
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NetLabelledBufferedChannelEndFactory.java 0000644 0000000 0000000 00000006304 11105701167 023663 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.util.ChannelDataStore;
/**
* NetChannelInput
* objects which have labelled VCN's.
* NetAltingChannelInput which
* has a VCN assigned with the specified label.
*
* @param label the label to apply to the channel's VCN.
* @param buffer the ChannelDataStore to use.
*
* @return the constructed NetAltingChannelInput
* object.
*/
public NetAltingChannelInput createNet2One(String label, ChannelDataStore buffer);
/**
* Constructs a buffered NetSharedChannelInput which
* has a VCN assigned with the specified label.
*
* @param label the label to apply to the channel's VCN.
* @param buffer the ChannelDataStore to use.
*
* @return the constructed NetSharedChannelInput
* object.
*/
public NetSharedChannelInput createNet2Any(String label, ChannelDataStore buffer);
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NetAltingChannelInput.java 0000644 0000000 0000000 00000005750 11105701167 020777 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.lang.*;
/**
* {@link AltingChannelInput} objects.
* setChannel(AltingChannelInput) should be called
* before the channel end is actually used.
* SharedConnectionServer objects which accept
* connections from clients from over a JCSP.NET network.
*
* @author Quickstone Technologies Limited
*/
public interface NetSharedConnectionServer extends SharedConnectionServer, NetConnectionServer
{
} jcsp-1.1-rc4.orig/src/org/jcsp/net/package.html 0000644 0000000 0000000 00000001011 11077376055 016215 0 ustar
{@link org.jcsp.net.Node} class for
more information.
{@link org.jcsp.net.NetChannelEnd} class or by using
{@link org.jcsp.net.StandardNetChannelEndFactory}.
AltingConnectionClient
* objects which connect to ConnectionServer objects
* over a JCSP.NET network.
* {@link NetSharedAltingConnectionClient}.
* {@link NetConnectionFactory} or by
* using the {@link NetConnection} class.
* NetChannelLocation
* object.
*/
public NetChannelLocation getChannelLocation()
{
return this.location;
}
/**
* Destroys the client and frees any resources used
* in the JCSP.NET infrastructure.
*
*/
public void destroyClient()
{
fromServer.destroyReader();
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/Link.java 0000644 0000000 0000000 00000114401 11105701167 015470 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.io.*;
import org.jcsp.lang.*;
import org.jcsp.net.settings.*;
import org.jcsp.util.filter.*;
import org.jcsp.net.security.*;
import java.util.*;
// package-private
/**
* Link class
* must provide the mechanism for sending data to remote Nodes and receiving
* data back. When a concrete implementation of link is initiated by calling
* the run() method, it must inititate a handshaking procedure
* and call certain protected methods in this abstract class.
* runTests(ChannelInput, ChannelOutput, boolean) should be called.
* See the documentation for this method for a full explanation.
* Link receives an object from over the network
* it should deliver the object to its destination by calling the
* deliverReceivedObject(Object) method.
* Link implementations obtain objects to send to the remote
* Node by reading from the protected txChannel object.
* ProtocolID object for identifying the protocol that is implementing the Link.
* @param client Indicates whether this is the client (true) or server (false) end of the connection.
* @param connected true if a connection is already established; otherwise connect() will later be called
*/
public Link(ProtocolID protocolID, boolean client, boolean connected)
{
this.protocolID = protocolID;
this.client = client;
this.connected = connected;
Service svc = Node.getInstance().getServiceManager().getService("security");
if (svc != null)
securityAuthority = (SecurityAuthority)svc.getUserObject();
}
/*----------------------Abstract Methods--------------------------------------*/
/**
* connected was true in the constructor. This is called internally from this
* class' run method - do not call it.
* handshake
* method - do not call it.
* createResources. Called in the event of
* an error during handshaking or when the link is dropped. An implementation of this method
* must cope with being called multiple times without an intervening call to createResources.
* sendNodeID is true. The remoteNodeID
* attribute should be set to the ID of the remote node if received. This is called internally
* during handshaking - do not call it.
* run method - do not call it directly.
*
*
*/
protected void runTxRxLoop() throws Exception
{
throw new NoSuchMethodException("runTxRxLoop");
}
/**
* Waits for numRepliesOutstanding instances of LinkLost
* to arrive from the txChannel. This is called internally from this class'
* run method - do not call it directly.
*
* @param numRepliesOutstanding LinkLost instances to wait for.
*/
protected void waitForReplies(int numAcknowledgements) throws Exception
{
throw new NoSuchMethodException("waitForReplies");
}
/**
* Writes a test object to the underlying connection. Called internally during handshaking
* - do not call it directly. The value written must be delivered by readTestObject
* at the remote node.
*
* @param obj object to be written
*/
protected void writeTestObject(Object obj) throws Exception
{
throw new NoSuchMethodException("writeTestObject");
}
/**
* Reads a test object from the underlying connection. Called internally during handshaking
* - do not call it directly. It must deliver the value passed to writeTestObject
* at the peer node.
*
* @return the object received.
*/
protected Object readTestObject() throws Exception
{
throw new NoSuchMethodException("readTestObject");
}
/**
* Writes a boolean link decision as to whether the other node has the option to keep or discard
* the link. Called internally during handshaking - do not call it directly. The value written
* must be delivered by readLinkDecision at the peer node.
*
* @param use decision result
*/
protected void writeLinkDecision(boolean use) throws Exception
{
throw new NoSuchMethodException("writeLinkDecision");
}
/**
* Reads a boolean link decision as to whether this node can keep or discard the link. Called
* internally during handshaking - do not call it directly. It must return the value passed to
* writeLinkDecision at the peer node.
*
* @return decision result
*/
protected boolean readLinkDecision() throws Exception
{
throw new NoSuchMethodException("readLinkDecision");
}
/*----------------------Concrete Methods--------------------------------------*/
/**
* Adds a transmission filter. This filter will run in the thread that is
* trying to send something over this Link.
*
* @param filter the filter.
* @param index the index position of the filter.
*/
void addTxFilter(Filter filter, int index)
{
txChannel.outFilter().addWriteFilter(filter, index);
}
/**
* Removes a transmission filter.
*
* @param filter the filter to remove.
*/
void removeTxFilter(Filter filter)
{
txChannel.outFilter().removeWriteFilter(filter);
}
/**
* Gets the number of installed transmission filters.
*
* @return the number of transmission filters installed.
*/
int getTxFilterCount()
{
return txChannel.outFilter().getWriteFilterCount();
}
/**
* Returns the other computer's ID.
*
* This method is safe to call while the process is running, however
* it will return null if the other computer has not yet identified
* itself.
*
* @return ID of connected computer.
*/
// package-private
protected NodeID getRemoteNodeID()
{
return this.remoteNodeID;
}
/** A protected accessor for obtaining the identifier of the protocol implementing this Link object.
* @return the ProtocolID of the protocol implementing this Link.
*/
protected ProtocolID getProtocolID()
{
return this.protocolID;
}
void setProfile(Profile profile)
{
this.profile = profile;
}
Profile getProfile()
{
return this.profile;
}
/**
* Returns channel to use for transmitting.
*
* This method is safe to call while the process is running. May block
* for if handshaking is still in progress.
*
* When written to, if the object supplied is not Serializable then an
* IllegalArgumentException Runtime exception.
*
* @return Channel you should send data to if you want to transmit on
* this Connection.
*/
// protected - to be used by this package and sub-classes
protected ChannelOutput getTxChannel()
{
return txChannel.out();
}
/**
* A protected method for concrete implementations of this class to call when they received a an object from the remote Node. This method delivers the message to its destination (a Channel, Connection etc.).
* @param obj the object to deliver.
*/
protected void deliverReceivedObject(Object obj)
{
if (!(obj instanceof Message))
{
if (obj instanceof Challenge)
// the other end is using security and we aren't
txChannel.out().write(null);
else
Node.err.log(this, "call to deliverReceivedObject without a valid Message");
return;
}
Message msg = (Message) obj;
if (msg instanceof Message.PingMessage)
txChannel.out().write(Message.PING_REPLY_MESSAGE);
else if (msg instanceof Message.PingReplyMessage)
pingReplyChan.out().write(msg);
else
{
// this is a little hack so that LoopbackLinks deliver the correct node IDs
if ((msg.sourceID = remoteNodeID) == null)
msg.sourceID = remoteNodeID = getRemoteNodeID();
msg.txReplyChannel = txChannel.out();
ChannelOutput out = null;
if (IndexManager.checkIndexIsValid(msg.destIndex))
out = im.getRxChannel(msg.destIndex);
else if (msg.destVCNLabel != null)
out = im.getRxChannel(msg.destVCNLabel);
if (out != null)
{
try
{
out.write(msg);
}
catch (PoisonException e)
{
Node.info.log(this, "BOUNCING Message");
msg.bounce(getTxChannel());
//log this properly
Node.info.log(this, "Unable to deliver message " + msg + " Channel was poisoned: " + e);
}
}
else if (!(msg instanceof Message.BounceMessage))
{
Node.info.log(this, "BOUNCING Message");
//Do not do this if recieved an InvalidChannelIndexMessage
//there could be continually bounced back replies
msg.bounce(getTxChannel());
}
else
Node.err.log(this, "BOUNCED message with invalid destination index");
}
}
Specification[] getSpecifications()
{
return specifications;
}
void setSpecifications(Specification[] specifications)
{
Comparator c = new Comparator()
{
public int compare(Object o1, Object o2)
{
Specification s1 = (Specification) o1;
Specification s2 = (Specification) o2;
return s1.name.compareTo(s2.name);
}
};
Arrays.sort(specifications, c);
this.specifications = specifications;
}
/**
* A public accessor for obtaining the ping time between the local Node and this Link's remote Node.
* @return the ping time as a long.
*/
public long getPingTime()
{
return pingTime;
}
/**
* Performs a ping on the link.
*
* @return the ping time in ms.
*/
public synchronized long ping()
{
long startTime = System.currentTimeMillis();
txChannel.out().write(Message.PING_MESSAGE);
pingReplyChan.in().read();
long endTime = System.currentTimeMillis();
this.pingTime = endTime - startTime;
return pingTime;
}
/**
* Link object has performed a ping test.
* true iff a ping test has been performed.
*/
public boolean performedPingTest()
{
return performedPingTest;
}
/**
* Link implementations before calling the runTests method.
* When tests are run, a series of messages are exchanged between both sides of the link. This allows
* the link to perform its tests using a single thread.
* boolean indicating whether this Link object is the client side of the link.
* If this object is the client then the parameter should be true.
* @return an array of boolean values indicating the sequence of when to read and when to transmit.
*/
protected boolean[] getReadSequence(boolean client)
{
if (client)
return new boolean[] { false, true, false, true, false };
return new boolean[] { true, false, true, false, true };
}
/**
* in parameter should be
* a ChannelInput that reads from a process that receives object from the remote Node.
* The out parameter is a ChannelOutput that, when written
* to, will transmit the object to the remote Node. The client parameter should be true
* iff the current Link is acting as a client side link (if it establishes the initial connection).
* Link that calls this method should call the getReadSequence(boolean) method
* before calling this method. Once this method has returned, the calling process should loop through the
* returned array of boolean values. If the value is true, the process should wait to recieve
* an object from over the network and then send it down the channel supplied as the in parameter.
* If the value is false, the process should read from the channel supplied as the out
* parameter and then send the object it receives over the network.
* out channel.
* This is some example code for what concrete implementations of Link need to do:
*
* One2OneChannel fromTestProcess = Channel.one2one();
* One2OneChannel toTestProcess = Channel.one2one();
* boolean[] readSequence = super.getReadSequence(client);
* super.runTests(toTestProcess.in(), fromTestProcess.out(), client);
* try {
* for(int i=0; iChannelInput that the test process can use
* to receive objects from over the network.
* @param out a ChannelOutput that the test process
* should use to send objects over the network.
* @param client a boolean that is true iff this Link object
* is the object that established the connection to the remote Node.
*/
private void runTestProcess(final ChannelInput in, final ChannelOutput out, final boolean client)
{
new ProcessManager(new CSProcess()
{
public void run()
{
if (client)
{
//check other side is ready
out.write(new LinkTest());
LinkTest returned = (LinkTest) in.read();
if ((returned != null) && (returned.counter == 1))
{
returned.counter++;
long txTime = System.currentTimeMillis();
out.write(returned);
returned = (LinkTest) in.read();
long rxTime = System.currentTimeMillis();
if ((returned != null) && (returned.counter == 3))
{
returned.counter++;
out.write(returned);
performedPingTest = true;
pingTime = rxTime - txTime;
}
}
}
else
{
LinkTest received = (LinkTest) in.read();
if ((received != null) && (received.counter == 0))
{
received.counter++;
out.write(received);
//both sides at this stage - now perform test
received = (LinkTest) in.read();
if ((received != null) && (received.counter == 2))
{
received.counter++;
//reply straight away
long txTime = System.currentTimeMillis();
out.write(received);
received = (LinkTest) in.read();
long rxTime = System.currentTimeMillis();
if ((received != null)
&& (received.counter == 4))
{
performedPingTest = true;
pingTime = rxTime - txTime;
}
}
}
}
out.write(null);
}
}).start();
}
/**
* LinkManager. It returns true
* if the link is successfully registered.
* true iff the link is successfully registered.
*/
private boolean registerLink()
{
Specification[] specifications = ProtocolManager.getInstance().getProtocolSpecifications(protocolID);
if (specifications != null)
{
Specification[] specificationsClone = (Specification[])specifications.clone();
//update the ping value
for (int i = 0; i < specificationsClone.length; i++)
{
if (specificationsClone[i].name.equals(XMLConfigConstants.SPEC_NAME_PING))
{
specificationsClone[i] = new Specification(specificationsClone[i].name, (int)getPingTime());
break;
}
}
setSpecifications(specificationsClone);
}
return LinkManager.getInstance().registerLink(this);
}
/**
* LinkManager that
* this link has failed.
* txChannel the number of times returned
* by this method.
*
* int numRepliesOutstanding = super.lostLink();
* while (numRepliesOutstanding > 0) {
* Object obj = txChannel.read();
* if (obj instanceof LinkLost) {
* numRepliesOutstanding--;
* }
* }
*
* @return an int indicating the number of channels that are using the link.
*/
private int lostLink()
{
return LinkManager.getInstance().lostLink(this);
}
/**
* true iff the supplied object is the same
* instance object as this object.
* true iff the parameter equals this object.
*/
public final boolean equals(Object o)
{
return o == this;
}
/**
* int hash code for this Link.
* The current implementation just uses the instance from Object.
* int hash code.
*/
public final int hashCode()
{
return super.hashCode();
}
/**
* connect() if it hasn't
* done so, perform handshaking, runTxRxLoop() and then
* waitForReplies() to acknowledge link termination.
* NodeID of the remote Node to which this
* link is connected. If a connection has not already been established,
* this method may connect to the remote Node and request its
* NodeID and then drop the connection.
* NodeID object.
*/
public final NodeID obtainNodeID()
{
if (getRemoteNodeID() != null)
return getRemoteNodeID();
if (client)
{
sendNodeID = false;
try
{
run();
}
catch (Exception e)
{ /*ignored*/
}
//set sendNodeID back to true just in case this Link is later used
//in the normal way
sendNodeID = true;
return remoteNodeID;
}
return null;
}
/*----------------------Attributes--------------------------------------------*/
/** Handshake result code - a problem occurred */
private static final int HS_ERROR = -1;
/** Handshake result code - temporary link */
private static final int HS_TEMPORARY = 0;
/** Handshake result code - permanant link ok */
private static final int HS_OK = 1;
/** True if connect() has been called or the underlying connection is already
* open. False otherwise.
*/
private boolean connected = false;
/** True if this is a client during handshaking, false if it is the server. */
private boolean client;
private IndexManager im = IndexManager.getInstance();
/**
* The channel used for TX over the link.
*
* In the future, this might be made private.
* It is recommended that implementations use the
* getTxChannel() to obtain the channel.
*
* Protocol implementations should NOT alter any of the
* filters on this channel.
*/
protected FilteredAny2OneChannel txChannel = FilteredChannel.createAny2One();
/**
* This indicates whether to send the local Node's address during the
* handshaking process. If not then the link is only for obtaining the
* remote Node's NodeID and will be shutdown.
*/
//private boolean sendNodeID = true;
/**
* The remote NodeID. The subclass must set this during exchangeNodeIDs.
*/
protected NodeID remoteNodeID;
/**
* True if the subclass must pass the ID of this node to the peer node.
*/
protected boolean sendNodeID = true;
private ProtocolID protocolID;
private Specification[] specifications;
private boolean performedPingTest = false;
private long pingTime = -1;
private Profile profile = null;
private One2OneChannel pingReplyChan = Channel.one2one();
private SecurityAuthority securityAuthority = null;
private static class LinkTest implements Serializable
{
int counter = 0;
private byte[] bytes = new byte[4096];
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/net/UIFactory.java 0000644 0000000 0000000 00000005317 11105701167 016445 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
/**
* Node class.
* equals(Object) and hashCode() methods
* of Object.
* System class.Node.info and
* Node.err which are by default connected to System.out and System.in
* respectively.Logger with a given name. The name assigned is arbitrary but allows the
* logger to be uniquely identified by name. For example instead of assigning a static reference
* somewhere to always refer to a logger, one can be named and resolved dynamically:
* public static void main (String[] args) {
* new Logger ("errors", "stderr");
* }
*
*
* errors connected to System.err.
* Elsewhere in the program one can write:
* Logger.getLogger ("errors")
*
*
*
*
*
* System.out.System.err.
* Node.info.setDevice (null);
*
*
* @param device the new device to use.
*/
public void setDevice(String device)
{
output = null;
if (device == null)
output = null;
else if (device.equals("stderr"))
output = System.err;
else if (device.equals("stdout"))
output = System.out;
else
try
{
output = new PrintStream(new FileOutputStream(device));
}
catch (IOException e)
{
// Not really appropriate if the error log fails :(
Node.err.log(this, "Unable to open device '" + device + "' for " + name + " log - " + e.getMessage());
}
}
/**
* createChallenge.
* @param r the response generated by the other authority.
* @return true if the response is permitted.
*/
public synchronized boolean validateResponse(Challenge c, Response r)
{
Node.info.log(this, "validating response to " + c.hashCode());
if ((c == null) || (r == null) || (!(c instanceof SimpleChallenge)) || (!(r instanceof SimpleResponse)))
{
Node.info.log(this, "not a valid response/challenge object (null)");
return false;
}
SimpleChallenge _c = (SimpleChallenge)c;
SimpleResponse _r = (SimpleResponse)r;
// Check the length is correct
if ((_c.data.length != CHALLENGE_LENGTH) || (_r.data.length != CHALLENGE_LENGTH))
{
Node.info.log(this, "not a valid response/challenge object (length invalid)");
return false;
}
// Check it is recent (allow 1 minute earlier; no future time)
long tNow = System.currentTimeMillis();
if ((_c.timestamp < tNow - 60000) || (_c.timestamp > tNow))
{
Node.info.log(this, "timestamp invalid");
return false;
}
// Look up the users permitted to access this node (ie connect to it)
byte[] data = new byte[CHALLENGE_LENGTH];
for (Enumeration e = allowedUsers.elements(); e.hasMoreElements(); )
{
SimpleUserID uID = (SimpleUserID)e.nextElement();
createResponse(_c, uID, data);
boolean match = true;
for (int i = 0; i < CHALLENGE_LENGTH; i++)
{
if (data[i] != _r.data[i])
{
match = false;
break;
}
}
if (match)
return true;
}
return false;
}
/**
* Creates a response to the challenge based on the currently logged in user.
*
* @param c the challenge to respond to.
* @return the response.
*/
public synchronized Response createResponse(Challenge c)
{
Node.info.log(this, "creating response to challenge " + c.hashCode());
if (currentUser == null)
throw new RuntimeException("No user is currently logged in");
if ((c == null) || (!(c instanceof SimpleChallenge)))
throw new RuntimeException("Invalid challenge for this security authority");
SimpleChallenge _c = (SimpleChallenge)c;
if (_c.data.length != CHALLENGE_LENGTH)
throw new RuntimeException("Invalid challenge for this security authority");
byte[] data = new byte[CHALLENGE_LENGTH];
createResponse(_c, (SimpleUserID)currentUser.getUserID(), data);
return new SimpleResponse(data);
}
/**
* Sets the currently logged on user. If there is already a user logged in, they are logged off.
*
* @param u the user's token.
*/
public synchronized void logonUser(UserToken u) throws AccessDeniedException
{
if (currentUser != null)
logoffUser();
if ((u == null) || (!(u instanceof SimpleUserToken)))
throw accessDenied("invalid user token");
currentUser = u;
permitUserAccess(u.getUserID());
}
/**
* Clears the currently logged on user. After this call the createResponse method will
* fail until another user is logged in.
*/
public synchronized void logoffUser()
{
if (currentUser == null)
throw new RuntimeException("There is no current user");
try
{
denyUserAccess(currentUser.getUserID());
}
catch (AccessDeniedException e)
{
// no action
}
currentUser = null;
}
/**
* Adds a user to the set of permitted users.
*
* @param u the user ID to add.
* @throws AccessDeniedException if the ID was not allocated by this authority.
*/
public synchronized void permitUserAccess(UserID u) throws AccessDeniedException
{
if ((u == null) || (!(u instanceof SimpleUserID)))
throw accessDenied("invalid user ID");
allowedUsers.addElement(u);
}
/**
* Removes a user from the set of permitted users.
*
* @param u the user ID to remove.
* @throws AccessDeniedException if the ID was not allocated by this authority.
*/
public synchronized void denyUserAccess(UserID u) throws AccessDeniedException
{
if ((u == null) || (!(u instanceof SimpleUserID)))
throw accessDenied("invalid user ID");
allowedUsers.removeElement(u);
}
// Methods from Service ///////////////////////////////////////////////////////////////////
/**
* Sets the service running.
*
* @return true - this service can always start.
*/
public boolean start()
{
Node.info.log(this, "service starting");
serviceRunning = true;
return true;
}
/**
* Stops the service.
*
* @return true - this service can always stop.
*/
public boolean stop()
{
Node.info.log(this, "service stopping");
serviceRunning = false;
return true;
}
/**
* Returns true iff the service is running.
*/
public boolean isRunning()
{
return serviceRunning;
}
/**
*
* <SERVICE ...>
* <SETTING name="logonUser" value="foo@bar.com"/>
* <SETTING name="permitUser0" value="a"/>
* <SETTING name="permitUser1" value="b"/>
* </SETTING>
*
*
* {@link org.jcsp.net.security.SecurityAuthority} for information on the service.SecurityAuthority will be
* able to create a user token from a user ID. To do so may require additional information such as passwords
* or other authentication details. It is the responsibility of the authority to do the authentication and
* only supply a token instance if the credentials are okay.
* // Node 1 // Node 2
* SecurityAuthority sa = ...; SecurityAuthority sa = ...;
*
* Challenge c = sa.createChallenge (); // receive a challenge 'c' and send the response
* // send 'c' to the other node and receive 'r' Challenge c = ...;
* Response r = ...; Response r = sa.createResponse (c);
*
* if (sa.validateResponse (c, r)) {
* // access is permitted
* } else {
* // access is denied
* }
*
*
* logonUser
* method. Obtaining a concrete user token is the responsibility of the concrete implementation. Similarly
* creating the user IDs is the responsibility of the concrete implementation. No methods are defined in
* this interface for these purposes because the number of parameters may vary depending on how users
* authenticate. For example they may supply a username/password pair, just a username string
* in a weaker system, or perhaps other, non-string credentials.permitUserAccess method must be used. To remove a user from this set the
* denyUserAccess method should be used.validateResponse method.createChallenge. This should be called as soon as the response is
* available and only once as there may be timestamping or other protection schemes in place.createChallenge and as passed to createResponse.
* @param r the response from createResponse.
* @return true if the response is valid and the user permitted. False otherwise.
*/
public boolean validateResponse(Challenge c, Response r);
/**
* Create a response for the given challenge coded with the currently logged on user.
*
* @param c the challenge created by createChallenge.
* @return the response to be returned to the originator authority.
*/
public Response createResponse(Challenge c);
/**
* Sets the currently logged on user.
*
* @param u the token identifying an authenticated user.
* @throws AccessDeniedException if the user token is not valid for this authority.
*/
public void logonUser(UserToken u) throws AccessDeniedException;
/**
* Clears the currently logged on user.
*/
public void logoffUser();
/**
* Adds a user ID to the set of users considered by this authority to create valid responses to
* challenges.
*
* @param u the user ID to add.
* @throws AccessDeniedException if the user ID is not valid for this authority.
*/
public void permitUserAccess(UserID u) throws AccessDeniedException;
/**
* Removes a user ID from the set of users considered by this authority to create valid responses to
* challenges.
*
* @param u the user ID to remove.
* @throws AccessDeniedException if the user ID is not valid for this authority.
*/
public void denyUserAccess(UserID u) throws AccessDeniedException;
} jcsp-1.1-rc4.orig/src/org/jcsp/net/ServiceSettings.java 0000644 0000000 0000000 00000013512 11105701167 017715 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.util.*;
/**
* String name,value pairs. Only one setting can exist per name.
* The other type of settings that can be held are address settings. Each
* address settings can hold a list of NodeAddressID objects
* against a String name.
* getServiceName() method.
* String name of the service.
*/
public String getServiceName()
{
return name;
}
/**
* Adds a named address setting.
* @param name the name of the setting to add.
* @param address the address to add to the setting.
*/
public void addAddress(String name, NodeAddressID address)
{
Object o = addresses.get(name);
if(o != null)
{
if(o instanceof Vector)
((Vector) o).add(address);
else
{
Vector v = new Vector();
v.add(o);
v.add(address);
addresses.put(name, v);
}
}
else
addresses.put(name, address);
}
/**
* Gets the addresses held in a setting of a specified name.
* @param name the name of the setting
* @return an array of NodeAddressID objects held in the setting.
*/
public NodeAddressID[] getAddresses(String name)
{
Object o = addresses.get(name);
if(o == null)
return new NodeAddressID[] {};
else if(o instanceof NodeAddressID)
return new NodeAddressID[] {(NodeAddressID) o};
else
{
Vector v = (Vector) o;
return (NodeAddressID[]) v.toArray(new NodeAddressID[v.size()]);
}
}
/**
* Returns an array of String objects containing the names of all
* address settings held in this object.
* @return a String array of all the address setting names.
*/
public String[] getAddressNames()
{
return (String[])addresses.keySet().toArray(new String[addresses.size()]);
}
/**
* Returns an array of String objects containing the names of all
* String name, value settings held in this object.
* @return a String array of all the String name, value setting names.
*/
public String[] getSettingNames()
{
return (String[]) settings.keySet().toArray(new String[settings.size()]);
}
/**
* Adds a String name, value setting to this object.
* @param name the name of the setting to add.
* @param value the value of the setting.
*/
public void addSetting(String name, String value)
{
settings.put(name, value);
}
/**
* Gets the String value held in named
* String name, value pair setting.
* @param name the name of the setting of which to obtain the value.
* @return the value of the setting.
*/
public String getSetting(String name)
{
return (String) settings.get(name);
}
private Hashtable addresses = new Hashtable();
private Hashtable settings = new Hashtable();
private String name;
} jcsp-1.1-rc4.orig/src/org/jcsp/net/Node.java 0000644 0000000 0000000 00000061730 11105701167 015466 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.lang.*;
import java.util.*;
/**
* {@link #getInstance()} method.
* Node Initialization
*
* Before any JCSP.NET constructs can be used, the Node must be initialized.
* There are several init() methods for initializing the Node
* in different ways.
*
* In order for a Node to be initialized, there are various settings that are * required and others which are useful to have. A key facility of a Node is to * be able to communicate with other Nodes. This requires at least one * communications protocol to be installed and also ideally an address on which * to listen for incoming connections. As well as protocols, there are various * services that a user might want to start when ever the Node is initialized. * Technically the Node could be initialized and have its protocols, addresses and * services set up manually by the user. This would, however, be rather cumbersome. *
*
* The JCSP.NET infrastructure is not dependent upon any one network protocol. The
* org.jcsp.net.tcpip package is provided but could easily
* be replaced by an alternate protocol implementation. In the real world, TCP/IP is
* likely to suit many uses and so this class assumes this as a default protocol.
* With this assumption, it is possible to initialize the Node without any further
* information. A Node can be initialized which installs TCP/IP as a protocol and
* listens on all local IP addresses. This is precisely the bahaviour of the
* {@link #init()} method with no parameters.
*
* One of the facilities that most JCSP.NET users are likely to use is the * Channel Name Server. This requires a server process to be running on a * JCSP.NET Node and client services on all Nodes that wish to use the server. * Assuming that a Channel Name Server is running, then at the time of * Node initialization, the knowledge of this server's address is required. *
*
* The {@link org.jcsp.net.tcpip.TCPIPNodeFactory} has
* knowledge of the Channel Name Server and has code for starting the client
* service on a Node. It provides a constructor which takes the address of the
* channel name server. An instance of the class can be created with this
* constructor and passed to the {@link #init(NodeFactory)} method.
* If the parameterless {@link #init()} is used, then an instance
* of the factory is created using its instantiate method which takes no settings.
* This tries to determine the address of the Channel Name Service through other
* means (including system properties and the preferences API etc.). See
* {@link org.jcsp.net.tcpip.TCPIPNodeFactory} for
* more information on this.
*
* Another NodeFactory class provided with JCSP.NET is the
* {@link XMLNodeFactory}. This reads its settings from an
* XML-like config file. This is not a full XML file as JCSP.NET provides
* its own parser. This saves pre Java 1.4 users from obtaining an XML
* parsing package. See {@link XMLNodeFactory} for full
* documentation on how to use this.
*
* As well as initialization methods which take NodeFactory
* objects, there are also methods which take protocol settings
* directly. See the {@link #init(NodeAddressID)}, {@link #init(NodeAddressID[])}
* and {@link #init(NodeAddressID[], Hashtable[])} methods.
*
* All of the Node init methods return a NodeKey object which
* is required for Node management methods.
*
*
Node Management
* *
* Once initialized, JCSP Nodes can have their settings altered. There are two
* manager classes of which each Node has an instance;
* {@link ServiceManager} and {@link ProtocolManager}.
* These instances can be obtained from the local Node object by
* calling their respective accessors ({@link #getServiceManager}
* and {@link #getProtocolManager}). Each of these accessors takes
* a {@link NodeKey} object as a parameter. This is for security
* reasons. Any process can obtain a reference to the local Node object. Without
* this key parameter, any process could therefore perform Node management
* operations. This key allows gives control of access to these methods to the
* process which initialized the Node. This process can decide who it trusts.
*
* See {@link ServiceManager} and
* {@link ProtocolManager} for more information.
*
*
Logging
* *
* The Node class provides two static {@link Logger} objects for
* programs to log information. {@link Node#info} provides
* facilities for logging information messages. {@link Node#err}
* provides facilities for logging error messages. The output from these
* logging objects can be enabled or disabled. See {@link Logger}
* for more information.
*
{@link Logger} for logging information messages..
*/
public static final Logger info = new Logger("info", "stdout");
/**
* A {@link Logger} for logging error messages.
*/
public static final Logger err = new Logger("err", "stderr");
/*-------------------Init Methods--------------------------------------------*/
/**
*
* This method functions the same as calling
* init(NodeAddressID[]) with a single element in the
* array.
*
LinkServer process.
* @throws IllegalStateException if the local Node has already been initialized.
* @throws IllegalArgumentException if no addresses are supplied.
* @throws NodeInitFailedException if the Node is not able to initialize.
* @return the NodeKey required for Node management.
*/
public NodeKey init(NodeAddressID localAddress)
throws IllegalStateException, IllegalArgumentException, NodeInitFailedException
{
if (localAddress == null)
throw new IllegalArgumentException("Null address");
return init(new NodeAddressID[] { localAddress });
}
/**
*
* This method is functionally equivalent to calling
* init(NodeAddressID[], HashTable) with the HashTable
* parameter being supplied as null.
*
LinkServer processes.
* @throws IllegalStateException if the local Node has already been initialized.
* @throws IllegalArgumentException if no addresses are supplied.
* @throws NodeInitFailedException if the Node is not able to initialize.
* @return the NodeKey required for Node management.
*/
public NodeKey init(NodeAddressID[] localAddresses)
throws IllegalStateException, IllegalArgumentException, NodeInitFailedException
{
return init(localAddresses, null);
}
/**
*
* Initializes the local Node and starts LinkServer listening
* on each of the supplied NodeAddressID objects. The
* protocols that match each address are also installed in the local
* protocol manager. If protocol settings are supplied, then these are
* used when the protocols are installed.
*
* A key is returned that needs to be supplied to certain management methods. *
* * @param localAddresses the addresses on which to start *LinkServer processes.
* @param protocolSettings an array of HashTable objects each
* containing settings for the protocols to be
* installed.
* Each HashTable is passed to the
* protocol's ProtocolID object's
* getLinkBuilder(HashTable) method.
* No restriction is placed on protocol
* implementations as to how this
* HashTable object be used. See the
* documentation for whatever protocol
* implementation is being used.
* @throws IllegalStateException if the local Node has already been initialized.
* @throws IllegalArgumentException if no addresses are supplied.
* @throws NodeInitFailedException if the Node is not able to initialize.
* @return the NodeKey required for Node management.
*/
public NodeKey init(NodeAddressID[] localAddresses, Hashtable[] protocolSettings)
throws IllegalStateException, IllegalArgumentException, NodeInitFailedException
{
if (localAddresses == null || localAddresses.length == 0)
throw new IllegalArgumentException("Null argument");
if (protocolSettings != null && protocolSettings.length != localAddresses.length)
throw new IllegalArgumentException("Wrong number of protocol settings");
for (int i = 0; i < localAddresses.length; i++)
{
if (localAddresses[i] == null)
throw new IllegalArgumentException("Null address");
}
// Only call this once or else...
if (initialized)
throw new IllegalStateException("Attempted to initialize org.jcsp.net.Node twice!");
//start Link Manager
LinkManager.getInstance().start();
//Look to see if a System property has been set to set a
//different UIFactory to be used.
String uiFactoryClassName = System.getProperty("JCSP.UIFactoryClass");
if (uiFactoryClassName != null)
{
try
{
Class uiFactoryClass = Class.forName(uiFactoryClassName);
uiFactory = (UIFactory) uiFactoryClass.newInstance();
}
catch (Exception e)
{
Node.err.log(this, "Error trying to load UIFactory: " + uiFactoryClassName);
throw new NodeInitFailedException("Error trying to load UIFactory: " + uiFactoryClassName);
}
}
else
uiFactory = new UIFactory();
nodeID = new NodeID(uiFactory.getUIForThisJVM());
for (int i = 0; i < localAddresses.length; i++)
{
if (!protocolManager.installProtocolServer(localAddresses[i], null))
throw new NodeInitFailedException("Unable to start LinkServer on " + localAddresses[i]);
Hashtable hs = null;
if (protocolSettings != null)
hs = protocolSettings[i];
if (!protocolManager.installProtocolClient(localAddresses[i].getProtocolID(), null, hs))
throw new NodeInitFailedException("Unable to install protocol " + localAddresses[i].getProtocolID());
}
initialized = true;
return nodeKey;
}
/**
*
* Initializes the Node with the current static NodeFactory.
* This can be set by calling the
* {@link #setNodeFactory(NodeFactory)} method.
*
* This default factory is currently the
* {@link org.jcsp.net.tcpip.TCPIPNodeFactory}.
* This is instantiated with its instantiate() method.
*
NodeKey required for Node management.
* @throws NodeInitFailedException if the Node is not able to initialize.
* @see #init(NodeFactory)
*/
public NodeKey init() throws NodeInitFailedException
{
return init(factory);
}
/**
*
* Initializes the Node with the specified
* {@link NodeFactory} object.
*
* This invokes the factory's initNode(Node, Node.Attributes)
* method to actually perform the initialization.
*
* This package provides an {@link XMLNodeFactory} which
* instantiates the Node from settings read from an XML-like config file.
*
NodeKey required for Node management.
* @throws NodeInitFailedException if the Node is not able to initialize.
*/
public NodeKey init(NodeFactory factory) throws NodeInitFailedException
{
if (initialized)
throw new IllegalStateException("Attempted to initialize org.jcsp.net.Node twice!");
NodeKey nk = factory.initNode(this, new AttributesAccess());
if (nk == null)
{
initialized = false;
throw new NodeInitFailedException();
}
return nk;
}
/*-------------------Other Public Methods-------------------------------------*/
/**
*
* This method allows a NodeID to be checked to see whether it
* represents the local Node. It is provided as a more efficient way of
* performing this check than obtaining the local node and checking manually.
* This would result in the local NodeID object being cloned.
*
NodeID to check against the local Node's NodeID.
* @throws IllegalStateException if the local Node has not been initialized.
*/
public boolean isThisNode(NodeID nodeID) throws IllegalStateException
{
checkInitialized();
synchronized (this.nodeID)
{
return this.nodeID.equals(nodeID);
}
}
/**
*
* Checks that the Node has been initialized. If so, returns normally,
* otherwise throws an IllegalStateException.
*
* Returns true if the node has already been initialized,
* false otherwise.
*
true iff Node has been initialized.
*/
public boolean isInitialized()
{
return initialized;
}
/**
*
* Method for obtaining a clone of this Node's NodeID.
*
* This method does not expose the actual underlying object as it is not * immutable. *
* * @return this Node'sNodeID. A clone of the one held by this class.
* @throws IllegalStateException if this Node has not been initialized.
*/
public NodeID getNodeID() throws IllegalStateException
{
checkInitialized();
try
{
synchronized (this.nodeID)
{
return (NodeID) nodeID.clone();
}
}
catch (CloneNotSupportedException e)
{
//should never be called
return null;
}
}
synchronized NodeID getActualNode()
{
return nodeID;
}
public synchronized ApplicationID getNewApplicationID()
{
return new ApplicationID(this.nodeID, this.appIDCounter++);
}
/**
*
* Accessor for obtaining a reference to the local Node's
* ProtocolManager object. The local Node's key must
* be supplied in order to obtain this reference. This prevents
* any unauthorized code from managing the local Node's communication protocols.
*
NodeKey.
* @return the local Node's ProtocolManager or null> if
* an incorrect key is supplied.
*/
public ProtocolManager getProtocolManager(NodeKey nodeKey)
{
if (nodeKey == this.nodeKey)
return protocolManager;
return null;
}
/**
*
* Accessor for obtaining a reference to the local Node's
* ServiceManager object. The local Node's key must
* be supplied in order to obtain this reference. This prevents
* any unauthorized code from managing the local Node's services.
*
NodeKey.
* @return the local Node's ServiceManager or null> if
* an incorrect key is supplied.
*/
public ServiceManager getServiceManager(NodeKey nodeKey)
{
if (nodeKey == this.nodeKey)
return getServiceManager();
return null;
}
ServiceManager getServiceManager()
{
return serviceManager;
}
/**
*
* Obtains a ServiceUserObject from a named Service and
* returns a reference to it. This method calls
* getService(String) on a Service object and
* will therefore obey the rules implemented in the requested Service.
*
* Generally, services are expected to check whether the requesting
* process has permission to access the user object and throw a
* SecurityException if access is denied.
*
ServiceUserObject object.
*
*/
public ServiceUserObject getServiceUserObject(String name)
{
return serviceManager.getService(name).getUserObject();
}
/**
* * Verifies that the supplied key matches the local Node's key. *
* @param nodeKey aNodeKey to check against that of the local Node's.
* @return true iff the supplied key matches the local
* Node's key.
*/
public boolean verifyKey(NodeKey nodeKey)
{
return this.nodeKey == nodeKey;
}
/**
*
* Returns an array of Specification objects to which this
* Node conforms.
*
Specification objects for this Node.
*/
public Specification[] getNodeSpecifications()
{
return (Specification[]) specifications.clone();
}
/**
* * This method tests whether a link currently exists to * a specified remote Node. *
* * @param otherNode TheNodeID of a remote Node to check
* the existance
* @return true iff a link currently exists to
* the specified remote Node.
*/
public boolean linkExists(NodeID otherNode)
{
return LinkManager.getInstance().linkExists(otherNode);
}
/**
* * This method allows users to obtain notification of link failure. *
** The API surrounding these events is new and will possibly change. Users * should be aware of this and only use if stricly necessary. *
*
* This returns an AltingChannelInput which will receive
* events signifying that a link to a particular Node has be been dropped.
* This will receive NodeID objects which signigy the remote
* Nodes at the other end of links which have been dropped.
*
AltingChannelInput event channel.
*/
public AltingChannelInput getLinkLostEventChannel()
{
return LinkManager.getInstance().getLinkLostEventChannel();
}
/*-------------------Package Private Methods----------------------------------*/
/*-------------------Inner Classes--------------------------------------------*/
/**
* An interface for exposing access to the private attributes. This is public.
*/
public interface Attributes
{
public void setSpecifications(Specification[] specs);
public NodeID setUIFactory(UIFactory factory);
public void setInitialized();
public ProtocolManager getProtocolManager();
public ServiceManager getServiceManager();
public NodeKey getNodeKey();
public NodeInitFailedException exception(String msg);
public void startLinkManager();
}
/**
* A class for exposing access to the private attributes. This is private so that only
* this class can create an instance. The interface (Attributes) is public to allow it
* to be used once created.
*/
private class AttributesAccess implements Attributes
{
public void setSpecifications(Specification[] specs)
{
specifications = specs;
}
public NodeID setUIFactory(UIFactory factory)
{
uiFactory = factory;
nodeID = new NodeID(uiFactory.getUIForThisJVM());
return nodeID;
}
public void setInitialized()
{
initialized = true;
}
public ProtocolManager getProtocolManager()
{
return protocolManager;
}
public ServiceManager getServiceManager()
{
return serviceManager;
}
public NodeKey getNodeKey()
{
return nodeKey;
}
public NodeInitFailedException exception(String msg)
{
return new NodeInitFailedException(msg);
}
public void startLinkManager()
{
LinkManager.getInstance().start();
}
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/LinkServer.java 0000644 0000000 0000000 00000010726 11105701167 016664 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
/**
* An abstract class that must be implemented by communication
* protocol implementations. LinkServer objects are
* processes which listen on a certain address for connection
* requests. When a request is received, a Link should be spawned in
* server mode.
*
* @author Quickstone Technologies Limited
*/
public abstract class LinkServer
{
/**
* Constructor. A LinkServer must have an associated protocolID.
* @param protocolID The ProtocolID for the protocol that the concrete implementation of LinkServer supports.
* @param linkServerAddressID the NodeAddressID for this LinkServer to listen on.
*/
protected LinkServer(ProtocolID protocolID, NodeAddressID linkServerAddressID)
{
if (protocolID == null || linkServerAddressID == null)
throw new IllegalArgumentException("ProtocolID cannot be null");
this.protocolID = protocolID;
this.linkServerAddressID = linkServerAddressID;
}
/**
* Create a server on a specifiedNodeAddressID, and start it. The server
* is spawned off in parallel, so this call returns immediately. This needs
* to be implemented by the concrete implementation of this class. This is
* not enforced by the compiler due to this being a static method.
*
* This NEEDS to be overridden.
*
* @param addressID The NodeAddressID to accept from
* @return the instance of LinkServer.
*/
protected static LinkServer create(NodeAddressID addressID)
{
throw new UnsupportedOperationException();
}
/**
* Stops the LinkServer.
*
* This NEEDS to be overridden.
* @return true iff the LinkServer has stopped.
*/
protected boolean stop()
{
throw new UnsupportedOperationException();
}
/**
* Gets the protocol that this LinkServer supports.
*
* @return the ProtocolID representing this LinkServers protocol.
*/
protected final ProtocolID getProtocolID()
{
return protocolID;
}
/**
* Protected accessor for obtaining the NodeAddressID on which
* this server is listening.
* @return the NodeAddressID on which this server is listening.
*/
protected final NodeAddressID getLinkServerAddressID()
{
return linkServerAddressID;
}
private final ProtocolID protocolID;
private final NodeAddressID linkServerAddressID;
} jcsp-1.1-rc4.orig/src/org/jcsp/net/ProtocolManager.java 0000644 0000000 0000000 00000022216 11105701167 017671 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.util.*;
/**
*
* The ProtocolManager class is a singleton class.
* See the documentation for the Node class
* for information on how to obtain a reference to its instance.
*
* A reference to a Node's ProtocolManager allows the Nodes installed
* protocols to be managed. Installing a protocol server creates a
* LinkServer that listens on a specified NodeAddressID.
* In order to connect to a Node's LinkServer, a Node must have
* a matching protocol client installed in its local ProtocolManager.
*
* When protocol clients and servers are installed, an array of
* Specification objects can be supplied. These are
* specifications that the client or server meets. The specifications for
* a given protocol can be obtained and then used to test whether a set of
* specifications match a given Profile.
*
Specification objects that are held for
* a specified protocol.
* @param protocolID the ProtocolID of a protocol
* @return the specifications of the supplied protocol.
*/
public Specification[] getProtocolSpecifications(ProtocolID protocolID)
{
return (Specification[]) protocolSpecifications.get(protocolID);
}
/** Returns an array of Specification objects that are held for
* a specified local address.
* @param addressID a NodeAddressID that should match an address on which a local
* LinkServer is listening.
* @return the set of specifications that are held against
* the specified address.
*/
public Specification[] getAddressSpecifications(NodeAddressID addressID)
{
return (Specification[]) addressSpecifications.get(addressID);
}
/** Installs a LinkServer listening on a specified
* NodeAddressID and holds the specified set of
* Specification objects against the address.
* @param addressID the address on which the LinkServer should be started.
* @param specifications the specifications to hold against the address.
* @return true iff the server is successfully installed.
*/
public boolean installProtocolServer(NodeAddressID addressID, Specification[] specifications)
{
if(addressID == null)
return false;
synchronized(linkServers)
{
if(!linkServers.contains(addressID))
{
ProtocolID pID = addressID.getProtocolID();
LinkServer ls = pID.startLinkServer(addressID);
if(ls != null)
{
linkServers.put(addressID, ls);
if(specifications != null)
addressSpecifications.put(addressID, specifications);
//update Node with new address
NodeID thisNode = Node.getInstance().getActualNode();
synchronized(thisNode)
{
//add the address taken from LinkServer in case it
//has been modified
thisNode.addAddress(ls.getLinkServerAddressID());
}
return true;
}
}
}
return false;
}
/** Stops the LinkServer that is listening on the specified address.
* @param addressID the NodeAddressID on which the LinkServer to
* stop is listening.
* @return true if, after returning, no LinkServer is listening
* on the specified adddress.
*/
public boolean stopProtocolServer(NodeAddressID addressID)
{
if(addressID == null)
return false;
if(linkServers.contains(addressID))
{
LinkServer ls = (LinkServer)linkServers.get(addressID);
if(ls != null)
{
if(ls.stop())
{
linkServers.remove(addressID);
addressSpecifications.remove(addressID);
return true;
}
}
}
else
return true;
return false;
}
/** Installs a protocol client so that links can be established to Nodes with
* LinkServer processes listening on the specified protocol.
* @param protocolID The ProtocolID of the protocol to install.
* @param specifications The specification of the protocol being installed.
* @param settings a HashTable that can contain settings that are passed
* to the protocol's Builder.
* @return true iff the protocol client is successfully installed or
* has already been installed.
*/
public boolean installProtocolClient(ProtocolID protocolID, Specification[] specifications, Hashtable settings)
{
if(protocolID == null)
return false;
if(protocolClients.get(protocolID) != null)
return true;
LinkFactory.Builder builder = protocolID.getLinkBuilder(settings);
if(LinkFactory.getInstance().installBuilder(builder))
{
protocolClients.put(protocolID, builder);
if(specifications != null)
protocolSpecifications.put(protocolID, specifications);
return true;
}
return false;
}
/** Removes the installed protocol client for a specified protocol.
* @param protocolID the ProtocolID of the protocol client to remove.
* @return true iff a matching protocol client has been successfully removed.
*/
public boolean removeProtocolClient(ProtocolID protocolID)
{
if(protocolID == null)
return false;
LinkFactory.Builder builder = (LinkFactory.Builder)protocolClients.get(protocolID);
if(builder == null)
return false;
if(LinkFactory.getInstance().removeBuilder(protocolID, builder))
{
protocolClients.remove(protocolID);
protocolSpecifications.remove(protocolID);
return true;
}
return false;
}
/*----------------------Attributes--------------------------------------------*/
private Hashtable linkServers = new Hashtable();
/**
* This Hashtable contains protocolID's as the keys which map to
* builders that build the links for that protocol.
*/
private Hashtable protocolClients = new Hashtable();
private Hashtable addressSpecifications = new Hashtable();
private Hashtable protocolSpecifications = new Hashtable();
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NetLabelledChannelEndFactory.java 0000644 0000000 0000000 00000007450 11105701167 022223 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
/**
*
* This factory constructs NetChannelInput objects
* which have labelled VCN's.
*
* JCSP.NET network channel addresses (signified by
* {@link NetChannelLocation} objects) have a
* Virtual Channel Number (VCN). This number is not exposed
* to JCSP users but is an integral part of channel addressing.
*
* If two Nodes have no means of communication, there is no
* way that one can pass a {@link NetChannelLocation}
* object to the other. This means that a channel cannot be
* established using convential means. JCSP.NET solves this
* problem by allowing VCN's to be labelled by the user.
* If the address of a Node hosting a ChannelInput
* with a known labelled VCN is known by a process in another Node,
* then a ChannelOutput can be established by
* constructing with a NetChannelLocation object constrcuted
* using the {@link
* NetChannelLocation#NetChannelLocation(NodeAddressID, String)
* } constructor.
*
NetAltingChannelInput which
* has a VCN assigned with the specified label.
*
* @param label the label to apply to the channel's VCN.
*
* @return the constructed NetAltingChannelInput
* object.
*/
public NetAltingChannelInput createNet2One(String label);
/**
* Constructs a NetSharedChannelInput which
* has a VCN assigned with the specified label.
*
* @param label the label to apply to the channel's VCN.
*
* @return the constructed NetSharedChannelInput
* object.
*/
public NetSharedChannelInput createNet2Any(String label);
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NetSharedChannelOutput.java 0000644 0000000 0000000 00000004437 11105701167 021171 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.lang.SharedChannelOutput;
/**
* This interface should be implemented by classes that
* wish to act as NetChannelOutput objects
* which can be used by muliple concurrent processes.
*
* @author Quickstone Technologies Limited
*/
public interface NetSharedChannelOutput extends NetChannelOutput, SharedChannelOutput
{
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NetConnectionClient.java 0000644 0000000 0000000 00000004642 11105701167 020505 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.lang.ConnectionClient;
/**
* This interface should be implemented by classes that wish to act
* as Networked ConnectionClient objects.
*
* @author Quickstone Technologies Limited
*/
public interface NetConnectionClient extends Networked, ConnectionClient
{
/**
* Destroys the NetConnectionClient object and frees
* any resources created within the JCSP.NET infrastructure.
*
*/
public void destroyClient();
} jcsp-1.1-rc4.orig/src/org/jcsp/net/GlobalID.java 0000644 0000000 0000000 00000010227 11105701167 016211 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.io.*;
/**
* * A Class whose instances represent the global domain. * There is only ever a need to have one instance of this class * per JVM so a static instance is supplied. *
*
* The GlobalID object is the parent
* AbstractID to all top level DomainID objects.
*
* See {@link AbstractID} for a fully explanation of
* this class.
*
* Returns null as there is no parent
* AbstractID of instances of this class.
*
null.
*/
public AbstractID getParentID()
{
return null;
}
/**
*
* Compares another object with this GlobalID object.
*
true iff the other object is a GlobalID.
*/
public boolean equals(Object o)
{
if (o == null || !(o instanceof GlobalID))
return false;
//o is an instance of GlobalID, therefore equal
return true;
}
/**
*
* Returns an int hash code for this object.
*
int hash code.
*/
public int hashCode()
{
return ("GlobalID").hashCode();
}
/**
*
* Returns a human readable string representation of a
* GlobalID.
*
String - currently "Global".
*/
public String toString()
{
return "Global";
}
boolean onSameBranch(AbstractID abstractID)
{
if (abstractID != null && abstractID instanceof GlobalID)
return true;
return false;
}
/**
*
* A static instance of GlobalID.
* Instead of creating GlobalID objects, it
* is better to use this instance as only once instance is
* ever required.
*
Description
* AcknowledgementsBuffer is an implementation of ChannelDataStore that yields * a FIFO buffered semantics for a channel. When empty, the channel blocks readers. * However, its capacity is infinite (expanding to whatever is needed so far as * the underlying memory system will permit). So, it never gets full and blocks * a writer. * See the static * {@link org.jcsp.lang.One2OneChannel#create(org.jcsp.util.ChannelDataStore) create} * methods of {@link org.jcsp.lang.One2OneChannel} etc. ** The getState method returns EMPTY or NONEMPTYFULL, but * never FULL. *
* An initial size for the buffer can be specified during construction. *
* This buffer will save memory by changing multiple ChannelMessage.Ack messages into * AcknowledgementsBuffer.Acks. * * @see org.jcsp.util.InfiniteBuffer * @author Quickstone Technologies Limited */ //package-private class AcknowledgementsBuffer implements ChannelDataStore, Serializable { /** * The default size of the buffer */ private static final int DEFAULT_SIZE = 8; /** * The initial size of the buffer */ private int initialSize; /** * The storage for the buffered Objects */ private Object[] buffer; /** * The number of Objects stored in the InfiniteBuffer */ private int counter = 0; /** * The index of the first element */ private int firstIndex = 0; /** * The index of the last element */ private int lastIndex = 0; /** * The Acks which is currently in the buffer. */ private Acks acks = null; /** * Compressed form of one or more acknowledgements. */ //package-private static class Acks { /** * Count of acknowledgements */ //package-private int count = 1; long vcn = -1; NodeID sourceNodeID = null; /** * Default Constructor. */ //package-private Acks() { } } /** * Construct a new InfiniteBuffer with the default size (of 8). */ //package-private AcknowledgementsBuffer() { this(DEFAULT_SIZE); } /** * Construct a new AcknowledgementsBuffer with the specified initial size. * * @param initialSize the number of Objects * the AcknowledgementsBuffer can initially store */ //package-private AcknowledgementsBuffer(int initialSize) { this.initialSize = initialSize; buffer = new Object[initialSize + 1]; } /** * Returns the oldest Object from the InfiniteBuffer and removes it. *
* Pre-condition: getState must not currently return EMPTY. * * @return the oldest Object from the InfiniteBuffer */ public Object get() { Object value = buffer[firstIndex]; buffer[firstIndex] = null; firstIndex = (++firstIndex) % buffer.length; counter--; if (value == acks) acks = null; return value; } public Object startGet() { Object value = buffer[firstIndex]; if (value == acks) acks = null; return value; } public void endGet() { buffer[firstIndex] = null; firstIndex = (++firstIndex) % buffer.length; counter--; } /** * Puts a new Object into the InfiniteBuffer. *
* Implementation note: if InfiniteBuffer is full, a new internal * buffer with double the capacity is constructed and the old data copied across. * * @param value the Object to put into the InfiniteBuffer */ public void put(Object value) { if (value instanceof ChannelMessage.Ack) { if (acks == null) { // Add new Acks entry to array. acks = new Acks(); /* This was put in so that a channel which used a label instead of a vcn could obtain the destination's actual vcn. This only really needs to be done once so perhaps this should be changed. */ acks.vcn = ((ChannelMessage.Ack)value).sourceIndex; acks.sourceNodeID = ((ChannelMessage.Ack)value).sourceID; value = acks; } else { // Just increment Acks counter. // Don't add anything to array. acks.count++; return; } } // Add value to array if (counter == buffer.length) { Object[] temp = buffer; buffer = new Object[buffer.length * 2]; System.arraycopy(temp, firstIndex, buffer, 0, temp.length - firstIndex); System.arraycopy(temp, 0, buffer, temp.length - firstIndex, firstIndex); firstIndex = 0; lastIndex = temp.length; } buffer[lastIndex] = value; lastIndex = (++lastIndex) % buffer.length; counter++; } /** * Returns the current state of the AcknowledgementsBuffer. * * @return the current state of the AcknowledgementsBuffer (EMPTY or * NONEMPTYFULL) */ public int getState() { if (counter == 0) return EMPTY; else return NONEMPTYFULL; } /** * Returns a new (and EMPTY) AcknowledgementsBuffer with the same * creation parameters as this one. *
* Note: Only the initial size and structure of the AcknowledgementsBuffer
* is cloned, not any stored data.
*
* @return the cloned instance of this AcknowledgementsBuffer.
*/
public Object clone()
{
return new AcknowledgementsBuffer(initialSize);
}
public void removeAll()
{
counter = 0;
firstIndex = 0;
lastIndex = 0;
acks = null;
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/One2NetChannel.java 0000644 0000000 0000000 00000047770 11105701167 017354 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.lang.*;
import org.jcsp.util.InfiniteBuffer;
import java.io.*;
/**
* A channel for network output (TX). This is a "One2Net" channel,
* which can only be safely used by one writer.
*
* @author Quickstone Technologies Limited
*/
class One2NetChannel implements NetChannelOutput, Serializable
{
/***********Constructors******************************************************/
/**
* Constructor which takes the location of a
* For a normal channel (numUnacknowledged == 0), the contract of this
* method is as follows: When the method returns, the data has been sent
* to the remote computer, and the process (or user-supplied buffer) at
* the other end has accepted it. It is safe to modify data
* after the call. Transmission is guaranteed unless a
* LinkLostException is thrown, in which case it is impossible to
* determine whether or not the remote computer recieved the data
* before the link dropped.
*
* For a streaming channel (numUnacknowledged > 0), the contract of
* this method is slightly different. When the method returns, the data
* has started it's trip to the remote computer, but the link may go down
* so there is no guarantee that it will get there. Also, since it may
* not have left this computer yet (the actual transmission is done in
* parallel with the return from this method), it is *NOT* safe to modify
* the passed data object. After the next call to this
* method, then you may assume that the data object has been
* transmitted, and re-use it or let the Java garbage collector deal with
* it as appropriate. You must wait a total of numUnacknowledged
* calls to this method before you can assume that the data was recieved
* - and if any of those calls throw a LinkLostException, then you
* cannot find out how much of the stream of data was recieved by the
* remote computer before the link broke.
*
* A LinkLostException is thrown if the TCP/IP link is dropped.
* This could be due to a network problem, but more often it is caused
* when the remote Java VM crashes or is shut down. It can also be
* caused if there is a serialization problem with the TCP/IP link - e.g.
* an attempt to send a non-serializable object, or an attempt to send a
* class which doesn't exist or isn't the same version at the recieving
* end. Note that LinkLostException is a permanent error - if it
* is thrown, then any further call to this method will cause it to be
* thrown again.
*
* @param data an object to send over the channel. This should be
* Factory for node instantiation based on an XML-like file.
*
* The factory uses its own XML parser that supports a sub-set of
* XML. The current implementation will parse a file compatible
* with jcsp-config.dtd. The parser does not current test conformance
* to this DTD. It does not currently support XML comments.
*
* An example of using this class can be seen in
*
* JCSP.NET communication protocol implementations must provide a concrete
* implementation of this class. The instances of the class implementations
* should hold address information for JCSP Node
* There is no defined way in this class as to how
* Implementations of the
* Compares the instance of the class implementing this interface
* with another object. This should return
* Returns a hash code for this object. Two
* Returns a clone of the instance of the class implementing this interface.
*
* Returns
* A Node may have several addresses. If a Node is on an internal network that
* is connected to the Internet, it may have one local address and one address
* that is accessible from the Internet. The Internet address may be globally
* unique whereas the local address may be duplicated in other internal networks.
* The
* Returns a
* This is is a static method that should be overriden by concrete implementations
* of this class. Ideally this method would be abstract but the language does
* not allow abstract static methods.
*
* The method constructs a
* Defines a class whose instances should be
*
* Individual instances may not be used by multiple processes but
* duplicate clients can be obtained by invoking
*
* Constructor for NetSharedAltingConnectionClient.
*
* Produces a duplicate
*
* Destroys this networked client object.
*
* This frees any resources used within the JCSP.NET
* infrastructure.
* Used internally by the JCSP network infrastructure to load a configuration from an XML file. This is not a full XML reader, and is capable of reading only a subset of XML. This package is used internally by the JCSP network infrastructure to load XML configuration files and
represent their structure. It is not intended for use and so minimal documentation is supplied.
* Produces a duplicate
*
* A Class whose instances represent a unique identifier for a JCSP.NET Node.
*
* For an explanation of this class, see
* Returns a clone of the instance of
* Compares this
* Returns a hash code for this
* Compares this
* This comparison is based upon the implementation of
* This method is equivalent to calling the
* Returns a clone of the set of
* If any held
* An interface that should be implemented by
*
* As well as usefully combining the
* Requests that the instance of the implementing class should
* reinitialize itself.
*
* Requests that the instance of the implementing class should
* reinitialize itself with a new location.
*
* Destroys the channel writer end and frees all the
* underlying JCSP.NET resources.
*
* Returns the factory class used for constructing this channel
* end object.
* This is a package-private implementation class.
* @author Quickstone Technologies Limited
*/
// package-private
abstract class ChannelMessage extends Message
{
/**
* Data from channel output to channel input.
*
* This is a package-private implementation class.
*
*/
// package-private
static final class Data extends ChannelMessage
{
/**
* The actual data being transmitted.
* This needs to be Serializable.
*
* @see java.io.Serializable
*
* @serial
*/
Object data;
boolean acknowledged = true;
//debug code
public String toString()
{
return "MessageData: " + data;
}
}
/**
* An acknowledgement.
*
* This is a package-private implementation class.
*
*/
// package-private
static final class Ack extends ChannelMessage
{
}
static final class WriteRejected extends ChannelMessage
{
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/AbstractID.java 0000644 0000000 0000000 00000011230 11105701167 016547 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.io.Serializable;
/**
* This is an abstract class that is sub-classed by classes whose
* instances should represent some kind of identifier and be part of a
* hierarchy of This class has no public or protected constructor so it may
* not be sub-classed by JCSP users. JCSP.NET defines four implementations
* of this class;
* An Networked
* ChannelInput to which to send data.
* The channel constructed will block after any data is sent
* until an acknowledgement is returned.
*
* A Link to the ChannelInput object's Node will
* be established if necessary. This Link may be established over any
* available protocol implementation.
*
* This constructor is equivalent to using the
* (NetChannelLocation, boolean, Profile) constructor with
* the boolean set to true and
* the Profile set to null.
*
*/
public One2NetChannel(NetChannelLocation channelLocation)
{
this(channelLocation, true, null);
}
/**
* Constructor which takes the location of a Networked
* ChannelInput to which to send data and a
* Profile that any Link used should match.
*
* The channel constructed will block after any data is sent
* until an acknowledgement is returned.
*
* A Link to the ChannelInput object's Node will
* be established if necessary. This Link will match the specified
* Profile. A RuntimeException will be thrown if a
* a matching Link cannot be established.
*
* This constructor is equivalent to using the
* (NetChannelLocation, boolean, Profile) constructor with
* the boolean set to true.
*
*/
public One2NetChannel(NetChannelLocation channelLocation, Profile linkProfile)
{
this(channelLocation, true, linkProfile);
}
/**
* Constructor which takes the location of a Networked
* ChannelInput to which to send data and a
* boolean indicating whether or not to obtain
* acknowledgements.
*
* If the acknowledged parameter is true, then the channel
* constructed will block after any data is sent
* until an acknowledgement is returned. Otherwise, the channel should not
* block, however, some flow control may be implemented which may result
* in blocking.
*
* A Link to the ChannelInput object's Node will
* be established if necessary. This Link may be established over any
* available protocol implementation.
*
* This constructor is equivalent to using the
* (NetChannelLocation, boolean, Profile) constructor with
* the Profile set to null.
*
*/
public One2NetChannel(NetChannelLocation channelLocation, boolean acknowledged)
{
this(channelLocation, acknowledged, null);
}
/**
* Constructor which takes the location of a Networked
* ChannelInput to which to send data and a
* boolean indicating whether or not to obtain
* acknowledgements.
*
* If the acknowledged parameter is true, then the channel
* constructed will block after any data is sent
* until an acknowledgement is returned. Otherwise, the channel should not
* block, however, some flow control may be implemented which may result
* in blocking.
*
* A Link to the ChannelInput object's Node will
* be established if necessary. This Link will match the specified
* Profile. A objects are RuntimeException will be thrown if a
* a matching Link cannot be established.
*
*/
public One2NetChannel(NetChannelLocation channelLocation, boolean acknowledged, Profile linkProfile)
{
this.acknowledged = acknowledged;
this.channelLocation = channelLocation;
this.channelID = new ChannelID(channelLocation.getChannelNodeID(), channelLocation.getVCN());
this.linkProfile = linkProfile;
this.maxUnacknowledged = 0;
if (acknowledged)
{
IndexManager.ChannelAndIndex chanAndIndex = IndexManager.getInstance().getNewReplyChannel(this);
fromNetIn = chanAndIndex.channel.in();
fromNetOut = chanAndIndex.channel.out();
channelIndex = chanAndIndex.index;
}
else
channelIndex = -1;
}
/***********Private fields****************************************************/
/**
* The channel ID of the remote computer.
* Not valid unless we are connected.
*/
private transient ChannelID channelID;
/**
* Our channel index. (On the local computer, for acknowlegements).
*/
private transient long channelIndex;
/**
* The channel we use for recieving from the demuxes.
*/
private transient AltingChannelInput fromNetIn;
private transient SharedChannelOutput fromNetOut;
/**
* The channel we use for sending to the network TX.
* Not valid unless we are connected.
*/
private transient ChannelOutput toNet;
/**
* True iff the link's been dropped.
*/
private transient boolean broken;
/**
* True iff we're connected to the remote computer.
*/
private transient boolean connected;
private transient ChannelMessage.Data messageA = new ChannelMessage.Data();
private transient ChannelMessage.Data messageB = new ChannelMessage.Data();
private transient boolean sendMessageA = true;
/**
* The channel name.
*
* @serial
*/
private NetChannelLocation channelLocation;
/**
* The Profile that the link used by this channel should match.
*/
private final Profile linkProfile;
/**
* The maximum number of data items "in flight" when a call to write()
* returns. The default setting of zero gives standard unbuffered
* channel semantics.
*
* 5/Jun/2002
* This is not currently used nor exposed to the user.
* Streaming has been changed so that acknowledgements are
* either on or off. Flow control really needs to be
* controlled from the receiving end but this functionality
* has not yet been implemented.
*
* @serial
*/
private final int maxUnacknowledged;
/**
* The number of data items currently unacknowledged ("in flight").
* Always <= maxUnacknowledged + 1. If it is > maxUnacknowledged,
* then we must be blocked in write().
*/
private transient int numUnacknowledged;
/**
* Indicates whether this channel requires acknowledgements to be
* returned from the receiver.
*
*/
private boolean acknowledged = true;
/***********Public Methods****************************************************/
/**
* Output data to this channel. The data must be Serializable.
* Serializable.
*/
public synchronized void write(Object data)
{
if (broken)
// Oops.
throw new LinkLostException(this, /*name*/"FILL IN");
if (!connected)
{
if (channelID == null)
channelID = new ChannelID(channelLocation.getChannelNodeID(), channelLocation.getVCN());
if (channelLocation.getChannelNodeID() == null)
toNet = LinkManager.getInstance().getTxChannel(channelLocation.getChannelAddress());
else
toNet = LinkManager.getInstance().getTxChannel(channelID.getNodeID(), linkProfile);
connected = true;
}
// Now we're set up, do the output.
// Create a Message object to hold the message
ChannelMessage.Data message = null;
if (acknowledged)
{
if(sendMessageA)
message = messageA;
else
message = messageB;
sendMessageA = !sendMessageA;
}
else
//if not acknowledge too dangerous to use message pool
message = new ChannelMessage.Data();
message.destIndex = channelID.getIndex();
message.sourceIndex = channelIndex;
message.data = data;
message.acknowledged = acknowledged;
if (message.destIndex == IndexManager.getInvalidVCN())
message.destVCNLabel = channelLocation.getChannelLabel();
else
message.destVCNLabel = null;
// Transmit the message
toNet.write(message);
// One more acknowldgement we should get back.
if (acknowledged)
{
numUnacknowledged++;
// Loop around recieving messages. We can't continue if the number
// of acks pending is over the limit. Otherwise, we just loop
// until we've read the Acks _or_ we've run out of things to read.
//
// (Claim: This is a _fair_ system - i.e. similar to fair ALTing
// between acks and data to send. This is because there are
// never two sends in a row without an attempt to read acks, and
// this thread never reads two acks in a row without a send.
// What's more, since the special buffer is merging acks, all
// pending acks are processed in a single read each time we send).
boolean gotAcks = false;
while ((numUnacknowledged > maxUnacknowledged) || ((!gotAcks) && fromNetIn.pending()))
{
Object obj = fromNetIn.read();
if (obj instanceof AcknowledgementsBuffer.Acks)
{
numUnacknowledged -= ((AcknowledgementsBuffer.Acks)obj).count;
// Could (should?) check that numUnacknowledged >= 0 here,
// but I'm going to assume that the other side isn't that
// broken. Besides, even if numUnacknowledged < 0, what can
// we do about it?
gotAcks = true;
if (message.destVCNLabel != null)
{
channelID = new ChannelID(((AcknowledgementsBuffer.Acks)obj).sourceNodeID,
((AcknowledgementsBuffer.Acks)obj).vcn);
channelLocation.setLocationDetails(channelID.getNodeID(), channelID.getIndex());
}
}
else if (obj instanceof LinkLost)
{
LinkLost cl = (LinkLost)obj;
cl.txChannel.write(cl); // acknowlegement.
if (cl.txChannel == toNet)
{
broken = true;
toNet = null;
throw new LinkLostException(this, "Lost Link to " + ((LinkLost) obj).address);
}
}
else if(obj instanceof Message.BounceMessage)
throw new ReaderIndexException();
else if(obj instanceof ChannelMessage.WriteRejected)
throw new ChannelDataRejectedException();
else
{
Node.err.log(this, "One2NetChannel, write: Received unexpected message type: " +
((obj == null) ? null : obj.getClass()));
throw new NetChannelError("One2NetChannel received invalid " +
"message over acknowledgement channel. This could be " +
"caused by using a Non-shared NetChannelOutput object " +
"between multiple processes!");
}
}
}
// Done!
}
/**
* Returns a clone of the NetChannelLocation object
* held by the instance of this class which contains information
* about the location of the networked ChannelInput
* object to which this ChannelOutput is connected.
*
* @return the NetChannelLocation of the destination
* ChannelInput.
*
*/
public NetChannelLocation getChannelLocation()
{
try
{
return (NetChannelLocation) channelLocation.clone();
}
catch (CloneNotSupportedException e)
{
return null;
}
}
static Any2OneChannel failedLinks = Channel.any2one(new InfiniteBuffer());
static
{
new ProcessManager(new CSProcess()
{
public void run()
{
while (true)
{
One2NetChannel c = (One2NetChannel)failedLinks.in().read();
c.destroyWriter();
}
}
}).start();
}
void linkFailed(NodeID remoteID)
{
if (channelLocation.getChannelNodeID().equals(remoteID))
failedLinks.out().write(this); // asynchronously destroy to avoid deadlock
}
/**
* This destroys this write end of the channel and frees any resources
* in the JCSP.NET infrastructure.
*
*/
public synchronized void destroyWriter()
{
if (channelIndex != IndexManager.getInvalidVCN())
IndexManager.getInstance().removeChannel(channelIndex, fromNetOut);
broken = true;
}
/**
* Requests that the channel recreates itself and reconnects to the
* other end of the channel.
*
* This method will call refresh() on the
* NetChannelLocation it holds for its destination.
* If the instance held is an instance of a sub-class of
* NetChannelLocation then this provides an oportunity
* for the instance to refresh its information. This could, for example,
* be from a naming service.
*
*/
public void recreate()
{
connected = false;
channelID = null;
numUnacknowledged = 0;
broken = false;
this.channelLocation.refresh();
}
/**
* Requests that the channel recreates itself and reconnects to the
* other end of the channel. A new location of the read end can be
* supplied.
*
* @param newLoc the new location of the read end of the channel.
*/
public void recreate(NetChannelLocation newLoc)
{
connected = false;
channelID = null;
numUnacknowledged = 0;
broken = false;
this.channelLocation = newLoc;
}
public Class getFactoryClass()
{
return StandardNetChannelEndFactory.class;
}
/**
* Currently, network channels are unpoisonable so this method has no effect.
*/
public void poison(int strength) {
}
/***********Private Methods***************************************************/
/**
* Handles deserialization. This is responsible for starting up the
* process which handles output, and for creating the internal channel.
*/
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException
{
// read non-transient fields.
stream.defaultReadObject();
connected = false;
broken = false;
// Sanity check.
if (maxUnacknowledged < 0)
throw new InvalidObjectException("One2NetChannel: maxUnacknowledged < 0");
if (acknowledged)
{
IndexManager.ChannelAndIndex chanAndIndex = IndexManager.getInstance().getNewReplyChannel(this);
fromNetIn = chanAndIndex.channel.in();
fromNetOut = chanAndIndex.channel.out();
channelIndex = chanAndIndex.index;
messageA = new ChannelMessage.Data();
messageB = new ChannelMessage.Data();
}
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/PingRequirement.java 0000644 0000000 0000000 00000006166 11105701167 017721 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.net.settings.*;
/**
*
* @author Quickstone Technologies Limited.
*/
class PingRequirement extends Requirement
{
PingRequirement(int intValue, int acceptableDifference)
{
super(XMLConfigConstants.REQ_NAME_MAXPING,
XMLConfigConstants.SPEC_NAME_PING,
XMLConfigConstants.REQ_COMPARATOR_LESS,
intValue);
if(intValue < 0 || acceptableDifference < 0)
throw new IllegalArgumentException("Illegal arguments - a value is less than zero.");
this.acceptableDifference = acceptableDifference;
}
public boolean matches(Specification spec)
{
if(this.specName.equals(spec.name) && this.type.equals(spec.type))
{
if(intValue > spec.intValue)
//This object is greater than the other object - i.e. the other
//object is less than this object
return true;
else if(spec.intValue - intValue <= acceptableDifference)
//This object is less than the other object - i.e. the other
//object is greater than this object
return true;
}
return false;
}
final int acceptableDifference;
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NetSharedConnectionClient.java 0000644 0000000 0000000 00000004536 11105701167 021636 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.lang.SharedConnectionClient;
/**
* This interface should be implemented by classes that
* wish to act as SharedConnectionClient
* objects which accept connections from
* ConnectionClient objects from over a JCSP.NET
* network.
*
* @author Quickstone Technologies Limited
*/
public interface NetSharedConnectionClient extends Networked, SharedConnectionClient
{
} jcsp-1.1-rc4.orig/src/org/jcsp/net/DuplicateChannelLabelException.java 0000644 0000000 0000000 00000005000 11105701167 022607 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
/**
* This Exception is thrown if there is an attempt to label
* a channel's VCN with a label that already exists at the
* same Node.
*
* @author Quickstone Technologies Limited
*/
public class DuplicateChannelLabelException extends RuntimeException
{
/**
* Constructor for DuplicateChannelLabelException.
*/
DuplicateChannelLabelException()
{
super();
}
/**
* Constructor for DuplicateChannelLabelException.
* @param message
*/
DuplicateChannelLabelException(String message)
{
super(message);
}
}jcsp-1.1-rc4.orig/src/org/jcsp/net/XMLNodeFactory.java 0000644 0000000 0000000 00000060752 11105701167 017402 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.net.*;
import java.io.*;
import java.util.*;
import java.lang.reflect.*;
import org.jcsp.net.settings.*;
/**
* {@link org.jcsp.net.cns.CNS}.
* XMLNodeFactory that uses the
* specified file.
*
* @param filename the file name of the config file to use.
*/
public XMLNodeFactory(String filename) throws IOException
{
this(new File(filename));
}
/**
* Constructs an XMLNodeFactory that uses the
* specified file.
*
* @param xmlFile a File object pointing to the
* XML file to use.
*
*/
public XMLNodeFactory(File xmlFile) throws IOException
{
config = new ConfigReader(new FileInputStream(xmlFile)).getConfig();
}
/**
* Constructs an XMLNodeFactory that uses the
* specified file.
*
* @param xmlFile a URL object pointing to the
* XML file to use.
*/
public XMLNodeFactory(URL xmlFile) throws IOException
{
config = new ConfigReader(xmlFile.openStream()).getConfig();
}
/**
* This is called by the Node class.
*
* @param node the Node object calling the method.
* @param attribs the attributes that need to be set by the method.
* @throws NodeInitFailedException if initialization failed.
*/
public NodeKey initNode(Node node, Node.Attributes attribs) throws NodeInitFailedException
{
//setup the plugins - only UIFactory at the moment
Plugins plugins = config.getPlugins();
Plugin uiFactPlugin = plugins.getPlugin("UIFactory");
if (uiFactPlugin != null)
{
try
{
Class uiFactoryClass = uiFactPlugin.getPluginClass();
attribs.setUIFactory((UIFactory) uiFactoryClass.newInstance());
}
catch (Exception e)
{
Node.err.log(this, "Error trying to load UIFactory: " + uiFactPlugin.getName());
throw attribs.exception("Error trying to load UIFactory: " + uiFactPlugin.getName());
}
}
else
attribs.setUIFactory(new UIFactory());
//Setup protocols
Hashtable protocolIDMap = new Hashtable();
Protocol[] protocols = config.getProtocols().getProtocols();
for (int i = 0; i < protocols.length; i++)
{
if (protocols[i] != null)
{
Protocol p = protocols[i];
try
{
//Get the protocol id
Class idClass = p.getIDClass();
ProtocolID pID = (ProtocolID) idClass.newInstance();
//set the order of preference of this protocol
pID.setPosition(p.getPosition());
//get any settings that are needed
Setting[] settingsFromConfig = p.getSettings();
Hashtable settings = new Hashtable();
for (int j = 0; j < settingsFromConfig.length; j++)
settings.put(settingsFromConfig[j].getName(), settingsFromConfig[j].getValue());
//Setup specs
Spec[] specs = p.getSpecs();
Specification[] specifications = new Specification[specs.length + 2];
//Have an extra specification for protocolID
specifications[specifications.length - 1] =
new Specification(XMLConfigConstants.SPEC_NAME_PROTOCOL,idClass.toString());
specifications[specifications.length - 2] = new Specification(XMLConfigConstants.SPEC_NAME_PING, 0);
for (int j = 0; j < specs.length; j++)
{
int intVal = -1;
double dblValue = -1;
boolean booValue = false;
String strValue = "";
Class type = null;
if (specs[j] instanceof OtherSpec)
{
OtherSpec otherSpec = (OtherSpec) specs[j];
type = otherSpec.getType();
if (type.equals(String.class))
strValue = otherSpec.getStringValue();
else if (type.equals(Integer.TYPE))
intVal = otherSpec.getIntValue();
else if (type.equals(Double.TYPE))
dblValue = otherSpec.getDoubleValue();
else if (type.equals(Boolean.TYPE))
booValue = otherSpec.getBooleanValue();
}
else
{
Class specClass = specs[j].getClass();
try
{
Method valueMethod = specClass.getMethod("getValue", null);
type = valueMethod.getReturnType();
Object returned = valueMethod.invoke(specs[j], new Object[0]);
if (type.equals(String.class))
strValue = (String) returned;
else if (type.equals(Integer.TYPE))
intVal = ((Integer) returned).intValue();
else if (type.equals(Double.TYPE))
dblValue = ((Double) returned).doubleValue();
else if (type.equals(Boolean.TYPE))
booValue = ((Boolean) returned).booleanValue();
else
throw attribs.exception("Specification's value is of an unsupported type: " + type);
}
catch (NoSuchMethodException e)
{
Node.err.log(this, "Spec does not have a getValue() method.");
throw attribs.exception("Cannot load protcol specification: " + specs[j].getName());
}
catch (IllegalAccessException e)
{
throw attribs.exception("Unable to access specification's value: " + specs[j].getName());
}
catch (InvocationTargetException e)
{
throw attribs.exception("An exception was thrown while trying to access specification's value: " +
e.getTargetException());
}
}
if (type.equals(String.class))
specifications[j] = new Specification(specs[j].getName(), strValue);
else if (type.equals(Integer.TYPE))
specifications[j] = new Specification(specs[j].getName(), intVal);
else if (type.equals(Double.TYPE))
specifications[j] = new Specification(specs[j].getName(), dblValue);
else if (type.equals(Boolean.TYPE))
specifications[j] = new Specification(specs[j].getName(), booValue);
}
//install the protocol
attribs.getProtocolManager().installProtocolClient(pID, specifications, settings);
protocolIDMap.put(p.getProtocolID(), pID);
}
catch (Exception e)
{
throw attribs.exception("Unable to instantiate protocol: " + p.getName() + "\n" + e.getMessage());
}
}
else
{
Node.err.log(this, "Null protocol specified.");
throw attribs.exception("Null protocol specified.");
}
}
//Setup local addresses
Address[] addresses = config.getAddresses().getAddresses();
for (int i = 0; i < addresses.length; i++)
{
if (addresses[i] != null)
{
Address a = addresses[i];
String xmlProtocolID = a.getProtocolID();
ProtocolID pID = (ProtocolID) protocolIDMap.get(xmlProtocolID);
if (pID != null)
{
NodeAddressID add;
try
{
add = pID.createAddressID(a.getValue(), a.isUnique());
}
catch (IllegalArgumentException e)
{
throw attribs.exception("Address specified in invalid format: " + a.getValue());
}
//Setup specs
Spec[] specs = a.getSpecs();
Specification[] specifications = new Specification[specs.length];
for (int j = 0; j < specs.length; j++)
{
int intVal = -1;
double dblValue = -1;
boolean booValue = false;
String strValue = "";
Class type = null;
if (specs[j] instanceof OtherSpec)
{
OtherSpec otherSpec = (OtherSpec) specs[j];
type = otherSpec.getType();
if (type.equals(String.class))
strValue = otherSpec.getStringValue();
else if (type.equals(Integer.TYPE))
intVal = otherSpec.getIntValue();
else if (type.equals(Double.TYPE))
dblValue = otherSpec.getDoubleValue();
else if (type.equals(Boolean.TYPE))
booValue = otherSpec.getBooleanValue();
}
else
{
Class specClass = specs[j].getClass();
try
{
Method valueMethod = specClass.getMethod("getValue", null);
type = valueMethod.getReturnType();
Object returned = valueMethod.invoke(specs[j], new Object[0]);
if (type.equals(String.class))
strValue = (String) returned;
else if (type.equals(Integer.TYPE))
intVal = ((Integer) returned).intValue();
else if (type.equals(Double.TYPE))
dblValue = ((Double) returned).doubleValue();
else if (type.equals(Boolean.TYPE))
booValue = ((Boolean) returned).booleanValue();
else
throw attribs.exception("Specification's value is of an unsupported type: " + type);
}
catch (NoSuchMethodException e)
{
Node.err.log(this, "Spec does not have a getValue() method.");
throw attribs.exception("Cannot load protcol specification: " + specs[j].getName());
}
catch (IllegalAccessException e)
{
throw attribs.exception("Unable to access specification's value: " + specs[j].getName());
}
catch (InvocationTargetException e)
{
throw attribs.exception("An exception was thrown while trying to access specification's value: " +
e.getTargetException());
}
}
if (type.equals(String.class))
specifications[j] = new Specification(specs[j].getName(), strValue);
else if (type.equals(Integer.TYPE))
specifications[j] = new Specification(specs[j].getName(), intVal);
else if (type.equals(Double.TYPE))
specifications[j] = new Specification(specs[j].getName(), dblValue);
else if (type.equals(Boolean.TYPE))
specifications[j] = new Specification(specs[j].getName(), booValue);
}
attribs.getProtocolManager().installProtocolServer(add, specifications);
}
else
throw attribs.exception("Unable to set address " + a.getValue() + ", " + "unknown protocol specified.");
}
else
{
Node.err.log(this, "Null address specified.");
throw attribs.exception("Null address specified.");
}
}
//Setup Node specifications
Spec[] nodeSpecs = config.getNodeSpecs().getSpecs();
Specification[] specifications = new Specification[nodeSpecs.length];
for (int j = 0; j < nodeSpecs.length; j++)
{
int intVal = -1;
double dblValue = -1;
boolean booValue = false;
String strValue = "";
Class type = null;
if (nodeSpecs[j] instanceof OtherSpec)
{
OtherSpec otherSpec = (OtherSpec) nodeSpecs[j];
type = otherSpec.getType();
if (type.equals(String.class))
strValue = otherSpec.getStringValue();
else if (type.equals(Integer.TYPE))
intVal = otherSpec.getIntValue();
else if (type.equals(Double.TYPE))
dblValue = otherSpec.getDoubleValue();
else if (type.equals(Boolean.TYPE))
booValue = otherSpec.getBooleanValue();
}
else
{
Class specClass = nodeSpecs[j].getClass();
try
{
Method valueMethod = specClass.getMethod("getValue", null);
type = valueMethod.getReturnType();
Object returned = valueMethod.invoke(nodeSpecs[j], new Object[0]);
if (type.equals(String.class))
strValue = (String) returned;
else if (type.equals(Integer.TYPE))
intVal = ((Integer) returned).intValue();
else if (type.equals(Double.TYPE))
dblValue = ((Double) returned).doubleValue();
else if (type.equals(Boolean.TYPE))
booValue = ((Boolean) returned).booleanValue();
else
throw attribs.exception("Specification's value is of an unsupported type: " + type);
}
catch (NoSuchMethodException e)
{
Node.err.log(this, "Spec does not have a getValue() method.");
throw attribs.exception("Cannot load protcol specification: " + nodeSpecs[j].getName());
}
catch (IllegalAccessException e)
{
throw attribs.exception("Unable to access specification's value: " + nodeSpecs[j].getName());
}
catch (InvocationTargetException e)
{
throw attribs.exception("An exception was thrown while trying to access specification's value: " +
e.getTargetException());
}
}
if (type.equals(String.class))
specifications[j] = new Specification(nodeSpecs[j].getName(), strValue);
else if (type.equals(Integer.TYPE))
specifications[j] = new Specification(nodeSpecs[j].getName(), intVal);
else if (type.equals(Double.TYPE))
specifications[j] = new Specification(nodeSpecs[j].getName(), dblValue);
else if (type.equals(Boolean.TYPE))
specifications[j] = new Specification(nodeSpecs[j].getName(), booValue);
}
attribs.setSpecifications(specifications);
//Setup profiles
LinkProfile[] linkProfiles = config.getLinkProfiles().getProfiles();
for (int i = 0; i < linkProfiles.length; i++)
{
//Setup reqs
Req[] reqs = linkProfiles[i].getReqs();
Requirement[] requirements = new Requirement[reqs.length];
for (int j = 0; j < reqs.length; j++)
{
String matchingSpecName = reqs[j].getName();
String value = null;
if (matchingSpecName.equals(XMLConfigConstants.REQ_NAME_MINSPEED))
matchingSpecName = XMLConfigConstants.SPEC_NAME_MAXSPEED;
else if (matchingSpecName.equals(XMLConfigConstants.REQ_NAME_PROTOCOL))
{
matchingSpecName = XMLConfigConstants.SPEC_NAME_PROTOCOL;
value = protocolIDMap.get(reqs[j].getStringValue()).getClass().toString();
}
else if (matchingSpecName.equals(XMLConfigConstants.REQ_NAME_MAXPING))
matchingSpecName = XMLConfigConstants.SPEC_NAME_PING;
if (reqs[j] instanceof MaxPing)
requirements[j] = new PingRequirement(reqs[j].getIntValue(), 50);
else if (reqs[j].getType().equals(String.class))
{
if (value == null)
value = reqs[j].getStringValue();
requirements[j] = new Requirement(reqs[j].getName(), matchingSpecName, reqs[j].getComparator(), value);
}
else if (reqs[j].getType().equals(Integer.TYPE))
requirements[j] =
new Requirement(reqs[j].getName(), matchingSpecName, reqs[j].getComparator(), reqs[j].getIntValue());
else if (reqs[j].getType().equals(Double.TYPE))
requirements[j] =
new Requirement(reqs[j].getName(), matchingSpecName, reqs[j].getComparator(), reqs[j].getDoubleValue());
else if (reqs[j].getType().equals(Boolean.TYPE))
requirements[j] =
new Requirement(reqs[j].getName(), matchingSpecName, reqs[j].getComparator(), reqs[j].getBooleanValue());
}
Profile.createNewLinkProfile(linkProfiles[i].getName(), requirements, linkProfiles[i].getExactMatchRequired());
}
//Node Profiles
NodeProfile[] nodeProfiles = config.getNodeProfiles().getProfiles();
for (int i = 0; i < nodeProfiles.length; i++)
{
//Setup reqs
Req[] reqs = nodeProfiles[i].getReqs();
Requirement[] requirements = new Requirement[reqs.length];
for (int j = 0; j < reqs.length; j++)
{
String matchingSpecName = reqs[j].getName();
if (matchingSpecName.equals(XMLConfigConstants.REQ_NAME_MINSPEED))
matchingSpecName = XMLConfigConstants.SPEC_NAME_MAXSPEED;
else if (matchingSpecName.equals(XMLConfigConstants.REQ_NAME_MINMEMORY))
matchingSpecName = XMLConfigConstants.SPEC_NAME_MEMORY;
else if (matchingSpecName.equals(XMLConfigConstants.REQ_NAME_MAXPING))
matchingSpecName = XMLConfigConstants.SPEC_NAME_PING;
if (reqs[j].getType().equals(String.class))
requirements[j] =
new Requirement(reqs[j].getName(), matchingSpecName, reqs[j].getComparator(), reqs[j].getStringValue());
else if (reqs[j].getType().equals(Integer.TYPE))
requirements[j] =
new Requirement(reqs[j].getName(), matchingSpecName, reqs[j].getComparator(), reqs[j].getIntValue());
else if (reqs[j].getType().equals(Double.TYPE))
requirements[j] =
new Requirement(reqs[j].getName(), matchingSpecName, reqs[j].getComparator(), reqs[j].getDoubleValue());
else if (reqs[j].getType().equals(Boolean.TYPE))
requirements[j] =
new Requirement(reqs[j].getName(), matchingSpecName, reqs[j].getComparator(), reqs[j].getBooleanValue());
}
Profile.createNewNodeProfile(nodeProfiles[i].getName(), requirements, nodeProfiles[i].getExactMatchRequired());
}
//start Link Manager
LinkManager.getInstance().start();
attribs.setInitialized();
//Setup CNS
ServiceManager sm = attribs.getServiceManager();
org.jcsp.net.settings.Service[] services = config.getServices().getServices();
//shouldn't be that many services so just loop through array each time
int servicePos = 0;
for (int i = 0; i < services.length; i++)
{
int actualPos = -1;
for (int j = 0; j < services.length && actualPos < 0; j++)
if (services[j].getPosition() == servicePos)
actualPos = j;
ServiceSettings serviceSettings = new ServiceSettings(services[actualPos].getName());
//get the array of addresses for each setting name
AddressSetting[] addressSettings = services[actualPos].getAddressSettings();
for (int j = 0; j < addressSettings.length; j++)
{
//loop through the alternate addresses for the setting name
AddressSetting addrSetting = addressSettings[j];
while (addrSetting != null)
{
ProtocolID pID = (ProtocolID) protocolIDMap.get(addrSetting.getProtocolID());
NodeAddressID addID = pID.createAddressID(addrSetting.getValue(), false);
//add the address to the ServiceSettings object
serviceSettings.addAddress(addrSetting.getName(), addID);
//get the next alternate address for the current name
addrSetting = addrSetting.getAlternate();
}
}
Setting[] otherSettings = services[actualPos].getSettings();
for (int j = 0; j < otherSettings.length; j++)
serviceSettings.addSetting(otherSettings[j].getName(), otherSettings[j].getValue());
if (sm.installService(serviceSettings, services[actualPos].getServiceClass()))
//service has installed
if (services[actualPos].getRun())
if (!sm.startService(services[actualPos].getName()))
Node.info.log(this, "Service " + services[actualPos].getName() + " failed to start.");
servicePos++;
}
return attribs.getNodeKey();
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/ServiceInstallationException.java 0000644 0000000 0000000 00000004675 11105701167 022447 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
/**
* An excpetion that is thrown if a service installation fails.
*
* @author Quickstone Technologies Limited
*/
public class ServiceInstallationException extends RuntimeException
{
/**
* Constructor for ServiceInstallationException.
*/
public ServiceInstallationException()
{
super();
}
/**
* Constructor for ServiceInstallationException.
* @param message
*/
public ServiceInstallationException(String message)
{
super(message);
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/SerializedMessage.java 0000644 0000000 0000000 00000006773 11105701167 020207 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.io.*;
/**
*
* @author Quickstone Technologies Limited.
*/
class SerializedMessage extends Message implements Serializable
{
public SerializedMessage(Message msg) throws NotSerializableException, IOException
{
serializedObject = new SerializedObject(msg, false);
destIndex = msg.destIndex;
sourceIndex = msg.sourceIndex;
}
SerializedMessage(SerializedObject serializedObject, long destIndex, long sourceIndex)
{
this.serializedObject = serializedObject;
this.destIndex = destIndex;
this.sourceIndex = sourceIndex;
}
public byte[] getSerializedData()
{
return serializedObject.getSerializedData();
}
/*--------------------------*/
public Object get() throws ClassNotFoundException, IOException
{
return get(null);
}
public Object get(SerializedObject.InputStreamFactory factory) throws ClassNotFoundException, IOException
{
Object o = null;
if(factory == null)
o = serializedObject.get();
else
o = serializedObject.get(factory);
if(o instanceof Message)
{
Message msg = (Message) o;
msg.sourceID = sourceID;
msg.txReplyChannel = txReplyChannel;
}
return o;
}
private SerializedObject serializedObject;
private boolean isInternalClass;
private static class AccesibleByteArrayOutputStream extends ByteArrayOutputStream
{
public byte[] getByteArray()
{
return buf;
}
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NodeAddressID.java 0000644 0000000 0000000 00000016505 11105701167 017211 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.io.*;
/**
* LinkServer
* processes. For example, a TCP/IP implementation would most likely hold
* an IP address and port number.
* NodeAddressID
* objects should be created. The JCSP infrastructure never looks at the
* underlying address information, it simply needs to be able compare one address
* with another. The equals(Object) should be implemented in such a
* way that this can be achieved.
* ProtocolID class should implement the
* createAddressID(String, boolean) method so that
* NodeAddressID objects for that protocol can be created from a
* String. The boolean parameter indicates whether or
* not the address is globally unique.
* true if the other
* object represents the same address.
* NodeAddressID.
* @return true if the other object is another NodeAddressID representing
* the same address.
*/
public abstract boolean equals(Object obj);
/**
* NodeAddressID objects
* should return the same hash code if they equal as governed by the rules
* for the equals(Object) method.
* int hash code.
*/
public abstract int hashCode();
/**
* ProtocolID for the protocol that is
* associated with this NodeAddressID.
* @return this NodeAddressID object's ProtocolID.
*/
public abstract ProtocolID getProtocolID();
/**
* true if this NodeAddressID is known to be
* unique within the global org.jcsp.net domain.
* NodeAddressID object representing the Internet address should
* return true when this method is called whereas the
* NodeAddressID representing the local address should return
* false.
* true iff this NodeAddressID is globally unique.
*/
public abstract boolean isGloballyUnique();
/**
* String that contains all information necessary for
* reconstucting this object from a String. The object is
* reconstructed by calling the static getAddressIDFromString(String)
* method.
* String that can be passed to the static getAddressIDFromString(String)
* method in order to reconstuct the object.
* @deprecated This is going to be removed from the API.
* The purpose of this mechanism was so that channel
* information could be encoded into anonymous channels'
* channel names.
*/
protected abstract String getStringForm();
/**
* NodeAddressID object from a
* String that is in the form of that returned by the
* getStringForm() method. The object returned by this method
* should equal the object that returned the String when its
* getStringForm() methdo was called.
* String used to construct the NodeAddressID.
* @throws IllegalArgumentException if the String supplied is invalid.
* @return a newly constructed NodeAddressID object.
*/
protected static NodeAddressID getAddressIDFromString(String stringForm)
throws IllegalArgumentException
{
//have made this protected 17/04/2002 - not sure why it wasn't.
return null;
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NetConnectionServer.java 0000644 0000000 0000000 00000004576 11105701167 020543 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.lang.ConnectionServer;
/**
* This interface should be implemented by classes that wish to act
* as Networked ConnectionServer objects.
*
* @author Quickstone Technologies Limited
*/
public interface NetConnectionServer extends ConnectionServer, Networked
{
/**
* Destroys the server and frees any resources used
* within the JCSP.NET infrastructure.
*
*/
public void destroyServer();
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NetSharedChannelInput.java 0000644 0000000 0000000 00000004432 11105701167 020763 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.lang.SharedChannelInput;
/**
* This interface should be implemented by classes that
* wish to act as NetChannelInput objects
* which can be used by muliple concurrent processes.
*
* @author Quickstone Technologies Limited
*/
public interface NetSharedChannelInput extends SharedChannelInput, NetChannelInput
{
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NetSharedAltingConnectionClient.java 0000644 0000000 0000000 00000013201 11105701167 022762 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.lang.*;
import org.jcsp.util.Buffer;
/**
* {@link org.jcsp.lang.SharedAltingConnectionClient}
* that connect to a ConnectionServer over a JCSP.NET
* network.
* {@link #duplicate()}. These duplicates work over the
* same connection and each one may be used by a different process.
* NetChannelLocation object.
*
* @see org.jcsp.net.Networked#getChannelLocation()
*/
public NetChannelLocation getChannelLocation()
{
return this.serverLocation;
}
/**
* NetSharedAltingConnectionClient object which
* may be used by another process.
* SharedConnectionClient
* object.
*/
public SharedConnectionClient duplicate()
{
return new NetSharedAltingConnectionClient(synchChan,
fromServer,
openToServer,
reqToServer,
backToClient);
}
/**
* NetChannelLocation object.
*
* @see org.jcsp.net.Networked#getChannelLocation()
*/
public NetChannelLocation getChannelLocation()
{
return in.getChannelLocation();
}
/**
* SharedConnectionServer object which
* may be used by another process.
* SharedConnectionServer
* object.
*/
public SharedConnectionServer duplicate()
{
return new NetSharedConnectionServerImpl(synchChan, in);
}
/**
* Destroys the server and frees any resources used within
* the JCSP.NET infrastructure.
*
*/
public void destroyServer()
{
synchChan.out().write(null);
in.destroyReader();
synchChan.in().read();
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NodeID.java 0000644 0000000 0000000 00000043124 11105701167 015700 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.io.*;
import java.lang.reflect.*;
import java.util.*;
/**
* {@link AbstractID}.
* NodeID on which
* this method is being called.
* NodeID cannot be cloned.
* @return a clone of the current instance of NodeID.
*/
public Object clone() throws CloneNotSupportedException
{
NodeID clone = (NodeID)super.clone();
clone.unrecognisedAddressIDs = (HashSet) unrecognisedAddressIDs.clone();
return clone;
}
/**
* NodeID with another object. This will only return
* true if the other object is a NodeID representing the same Node as
* this NodeID. The comparison is performed by using a Node's unique
* identifier. This was introduced for efficiency reasons as comparing two
* NodeID objects' sets of addresses could be quite slow.
* NodeID.
* @return true iff the other object is a NodeID representing the same
* Node as this NodeID.
*/
public boolean equals(Object o)
{
if (o == null || !(o instanceof NodeID))
return false;
NodeID other = (NodeID) o;
if (!(domainID.equals(other.getDomainID())))
return false;
return nodeUI.equals(other.nodeUI);
}
/**
* NodeID object.
* int hash code.
*/
public int hashCode()
{
return nodeUI.hashCode();
}
/**
* NodeID object with another
* NodeID object. Returns 0 if this NodeID is equal
* to the other NodeID, a negative int if this
* NodeID is less than the supplied NodeID or a positive
* int if this NodeID is greater than the supplied
* NodeID.
* NodeUI used.
* NodeID.
* @throws ClassCastException if the parameter supplied is not a NodeID.
* @return 0 if this NodeID is equal
* to the other NodeID, a negative int if this
* NodeID is less than the supplied NodeID or a positive
* int if this NodeID is greater than the supplied
* NodeID.
*/
public int compareTo(Object o) throws ClassCastException
{
NodeID other = (NodeID) o;
if (equals(o))
return 0;
int domCompare = domainID.compareTo(other.domainID);
if (domCompare != 0)
return domCompare;
return nodeUI.compareTo(other.nodeUI);
}
/**
* compareTo(Object)
* and supplying the local Node's NodeID as a parameter.
* int following the rules of the
* compareTo(Object) method.
*/
public int compareToLocalNode()
{
return compareTo(Node.getInstance().getActualNode());
}
boolean onSameBranch(AbstractID abstractID)
{
if (abstractID == null)
return false;
if (abstractID instanceof NodeID)
return this.equals(abstractID);
if (abstractID instanceof ApplicationID)
return abstractID.onSameBranch(this);
return domainID.onSameBranch(abstractID);
}
/**
* NodeAddressID objects that
* this NodeID holds.
* NodeAddressID objects do not support
* cloning, then the actual object is returned but this should
* never be the case.
* NodeAddressID objects.
*/
public synchronized NodeAddressID[] getAddresses()
{
NodeAddressID[] addressIDs = new NodeAddressID[this.addressIDs.length];
for (int i = 0; i < addressIDs.length; i++)
{
try
{
addressIDs[i] = (NodeAddressID) this.addressIDs[i].clone();
}
catch (CloneNotSupportedException e)
{
//will make do without cloning
addressIDs[i] = this.addressIDs[i];
}
}
return addressIDs;
}
synchronized void addAddress(NodeAddressID addressID)
{
final NodeAddressID[] newArray = new NodeAddressID[this.addressIDs.length + 1];
System.arraycopy(this.addressIDs, 0, newArray, 0, this.addressIDs.length);
newArray[newArray.length - 1] = addressID;
this.addressIDs = newArray;
}
synchronized void removeAddress(NodeAddressID addressID)
{
int position = -1;
for (int i = 0; i < this.addressIDs.length; i++)
{
if (this.addressIDs[i].equals(addressID))
position = i;
}
if (position < 0)
// The address was not in our list. Maybe raise an exception as this indicates a logical error elsewhere.
return;
final NodeAddressID[] newArray = new NodeAddressID[this.addressIDs.length - 1];
System.arraycopy(this.addressIDs, 0, newArray, 0, position);
int remainingLength = this.addressIDs.length - position - 1;
if (remainingLength > 0)
System.arraycopy(this.addressIDs, position + 1, newArray, position, remainingLength);
this.addressIDs = newArray;
}
/**
*
* @deprecated Not needed now channel names have been abstracted
*/
static NodeID createFromStringForm(String stringForm) throws IllegalArgumentException
{
return new NodeID(stringForm);
}
/**
* This gets a String form of this NodeID. This is only intended to be
* called for NodeID's representing the current JVM as any
* NodeAddressIDs in serialized form in the unrecognisedAddressIDs
* HashSet will not be saved. This HashSet should be empty for NodeID's
* representing the current JVM.
*
* @deprecated Not needed now channel names have been abstracted
*
* @return the String form that can be used to reconstruct this NodeID.
*/
synchronized String getStringForm()
{
String[] strings = new String[addressIDs.length + 2];
strings[0] = domainID.getStringForm();
strings[1] = nodeUI.getStringForm();
for (int i = 0; i < addressIDs.length; i++)
{
NodeAddressID naddID = addressIDs[i];
strings[2 + i] = naddID.getClass().getName() + ":" + naddID.getStringForm();
}
return Utils.arrayToString(strings);
}
synchronized void setDomainID(DomainID domainID)
{
this.domainID = domainID;
}
public AbstractID getParentID()
{
return domainID;
}
/** Get the DomainID of the domain to which the Node represented by
* this NodeID object belongs.
* If the Node is not a member of a domain then a DomainID object
* will be returned that will return true when its
* isNullDomain() method is called.
* @return this NodeID object's DomainID object.
*/
public DomainID getDomainID()
{
return domainID;
}
/** Returns a name that has been assigned to the Node
* represented by this NodeID object.
* If no name has been assigned, then an empty String
* is returned.
*
* The Node naming feature is not currently implemented.
* @return the name assigned to this NodeID object's Node.
*/
public String getName()
{
return name;
}
/** Returns a human readable String that
* represents this NodeID object.
* This will either include the name of the Node, if assigned, or else
* a list of the Node's addresses.
*
* The String returned by this method is only really intended as a
* way of supply debugging information to users. The contents is not guaranteed
* and should not relied upon by a program.
* @return a human readable String.
*/
public String toString()
{
if (!name.equals(""))
return getDomainID() + "\\Node: " + name;
StringBuffer stringToReturn = new StringBuffer(getDomainID() + "\\Node(");
for (int i = 0; i < addressIDs.length; i++)
stringToReturn.append(addressIDs[i] + ")");
return stringToReturn.toString();
}
void setName(String name)
{
if (name != null)
this.name = name;
else
name = "";
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
{
try
{
domainID = (DomainID) in.readObject();
nodeUI = (NodeUI) in.readObject();
name = (String) in.readObject();
int numAddresses = in.readInt();
addressIDs = new NodeAddressID[numAddresses];
int unrecCount = 0;
for (int i = 0; i < numAddresses; i++)
{
SerializedObject s = (SerializedObject) in.readObject();
try
{
NodeAddressID naddID = (NodeAddressID) s.get();
addressIDs[i - unrecCount] = naddID;
}
catch (ClassNotFoundException e)
{
unrecCount++;
unrecognisedAddressIDs.add(s);
//put s into HashSet of addresses which this JVM
//does not recognise - means they won't be lost
}
catch (Exception e)
{
e.printStackTrace();
}
}
unrecognisedAddressIDs = new HashSet();
if (unrecCount > 0)
{
NodeAddressID[] addressIDs = new NodeAddressID[numAddresses - unrecCount];
System.arraycopy(this.addressIDs, 0, addressIDs, 0, addressIDs.length);
this.addressIDs = addressIDs;
}
}
catch (Exception e)
{
e.printStackTrace();
throw new IOException("An error occured during deserialization");
}
}
private void writeObject(ObjectOutputStream out) throws IOException
{
synchronized (this)
{
out.writeObject(domainID);
out.writeObject(nodeUI);
out.writeObject(name);
out.writeInt(addressIDs.length + unrecognisedAddressIDs.size());
for (int i = 0; i < addressIDs.length; i++)
{
try
{
out.writeObject(new SerializedObject(addressIDs[i], true));
}
catch (Exception e)
{
//ignored - could print out a message
e.printStackTrace();
}
}
for (Iterator it = unrecognisedAddressIDs.iterator(); it.hasNext(); )
{
try
{
out.writeObject(it.next());
}
catch (Exception ex)
{
//ignored - could print out a message
ex.printStackTrace();
}
}
}
}
/*----------------------Attributes--------------------------------------------*/
/**
* This is a set of addresses of LinkServers that the Node, represented by
* this NodeID, is running.
*/
private NodeAddressID[] addressIDs = new NodeAddressID[0];
/**
* This is the set of addresses of LinkServers that the Node, represented by
* this NodeID, is running but this JVM does not recognise. The serialized
* forms of the addresses are stored here so that
*/
private HashSet unrecognisedAddressIDs = new HashSet();
/**
* The Domain of which the Node represented by this NodeID is a member.
*/
private DomainID domainID;
/**
* A unique identifier for this node.
*/
private NodeUI nodeUI;
/**
* A name assigned to this Node.
*/
private String name = "";
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NetChannelOutput.java 0000644 0000000 0000000 00000006422 11105701167 020036 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.lang.*;
/**
* ChannelOutput objects which are used for transmitting
* over the network.
* Networked and
* ChannelOutput interfaces, this interface adds a
* recreate() that requests the implementing class should
* reinitialize itself.
* Class of the
*/
public Class getFactoryClass();
} jcsp-1.1-rc4.orig/src/org/jcsp/net/ChannelMessage.java 0000644 0000000 0000000 00000005762 11105701167 017461 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
/**
* Messages used by channels.
*
* AbstractID objects.{@link ApplicationID},
* {@link NodeID}, {@link DomainID}
* and {@link GlobalID}.ApplicationID object identifies a JCSP application.
* A JCSP Application is formed of a process network initiated at a
* particular Node, but processes launched on a remote Node may
* also be part of the same application. The parent AbstractIDApplicationIDNodeID
* objects.
*
* A NodeID object identifies a particular JCSP Node. A
* JCSP Node is a Java Virtual Machine that has been initialized
* to form part of a JCSP.NET network. The parent AbstractIDNodeID objects are DomainID
* objects.
*
* A DomainID object represents a domain of JCSP Nodes.
* Node Domains are not presently implemented but this class is
* included for completeness. In the future, it is envisaged that
* domain controllers will be introduced. At present, all
* NodeID objects have a parent DomainID
* equal to the Null Domain (this has a zero length string name).
*
* A GlobalID object represents the global Node domain.
* This includes all domains, their sub-domains, and all Nodes within
* sub-domains. There only ever needs to be a single instance of this
* class. The parent of the Null Domain is a
* GlobalID object.
*
AbstractID object.
*
* @return the parent AbstractID of this object.
*/
public abstract AbstractID getParentID();
/**
* This tests whether another ID is on the same branch of a
* hierachy. Returns true if either the supplied object
* is a child (or a child of child etc.) of this object or
* if the supplied object is a parent (or a parent of a parent
* etc.) of this object.
*
* @return a boolean indicating whether or not
* the supplied object is on the same branch.
*/
abstract boolean onSameBranch(AbstractID abstractID);
} jcsp-1.1-rc4.orig/src/org/jcsp/net/Requirement.java 0000644 0000000 0000000 00000016200 11105701167 017071 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
/**
*
* @author Quickstone Technologies Limited.
*/
class Requirement
{
Requirement(String name, String specName, String comparator, int intValue)
{
if(name == null
|| specName == null
|| comparator == null
|| !(comparator.equals(COMPARATOR_EQUALS)
|| comparator.equals(COMPARATOR_LESS_THAN)
|| comparator.equals(COMPARATOR_GREATER_THAN)))
throw new IllegalArgumentException("Illegal arguments - either null parameter or invalid comparator value");
this.name = name;
this.specName = specName;
this.comparator = comparator;
this.intValue = intValue;
this.strValue = "";
this.dblValue = -1;
this.booValue = false;
type = Integer.TYPE;
}
Requirement(String name, String specName, String comparator, String strValue)
{
if(name == null
|| specName == null
|| comparator == null
|| !(comparator.equals(COMPARATOR_EQUALS)
|| comparator.equals(COMPARATOR_LESS_THAN)
|| comparator.equals(COMPARATOR_GREATER_THAN)))
throw new IllegalArgumentException("Illegal arguments - either null parameter or invalid comparator value");
this.name = name;
this.specName = specName;
this.comparator = comparator;
this.strValue = strValue;
this.intValue = -1;
this.dblValue = -1;
this.booValue = false;
type = String.class;
}
Requirement(String name, String specName, String comparator, double dblValue)
{
if(name == null
|| specName == null
|| comparator == null
|| !(comparator.equals(COMPARATOR_EQUALS)
|| comparator.equals(COMPARATOR_LESS_THAN)
|| comparator.equals(COMPARATOR_GREATER_THAN)))
throw new IllegalArgumentException("Illegal arguments - either null parameter or invalid comparator value");
this.name = name;
this.specName = specName;
this.comparator = comparator;
this.dblValue = dblValue;
this.intValue = -1;
this.strValue = "";
this.booValue = false;
type = Double.TYPE;
}
Requirement(String name, String specName, String comparator, boolean booValue)
{
if(name == null
|| specName == null
|| comparator == null
|| !(comparator.equals(COMPARATOR_EQUALS)
|| comparator.equals(COMPARATOR_LESS_THAN)
|| comparator.equals(COMPARATOR_GREATER_THAN)))
throw new IllegalArgumentException("Illegal arguments - either null parameter or invalid comparator value");
this.name = name;
this.specName = specName;
this.comparator = comparator;
this.booValue = booValue;
this.intValue = -1;
this.strValue = "";
this.dblValue = -1;
type = Boolean.TYPE;
}
public boolean matches(Specification spec)
{
if(specName.equals(spec.name) && type.equals(spec.type))
{
Comparable cThis = null;
Comparable cOther = null;
if(type.equals(String.class))
{
cThis = strValue;
cOther = spec.strValue;
}
else if(type.equals(Integer.TYPE))
{
cThis = new Integer(intValue);
cOther = new Integer(spec.intValue);
}
else if(type.equals(Double.TYPE))
{
cThis = new Double(dblValue);
cOther = new Double(spec.dblValue);
}
else if(type.equals(Boolean.TYPE))
{
cThis = new BooleanComparable(booValue);
cOther = new BooleanComparable(spec.booValue);
}
int comparison = cThis.compareTo(cOther);
if(comparator.equals(COMPARATOR_EQUALS) && comparison == 0)
return true;
else if(comparator.equals(COMPARATOR_LESS_THAN) && comparison > 0)
//This object is greater than the other object - i.e. the other
//object is less than this object
return true;
else if(comparator.equals(COMPARATOR_GREATER_THAN) && comparison < 0)
//This object is less than the other object - i.e. the other
//object is greater than this object
return true;
}
return false;
}
final Class type;
final String name;
final String specName;
final String comparator;
final int intValue;
final String strValue;
final double dblValue;
final boolean booValue;
private static final String COMPARATOR_EQUALS = "EQU";
private static final String COMPARATOR_LESS_THAN = "LTH";
private static final String COMPARATOR_GREATER_THAN = "GRT";
private class BooleanComparable implements Comparable
{
BooleanComparable(boolean val)
{
this.val = val;
}
public int compareTo(Object o)
{
BooleanComparable other = (BooleanComparable) o;
if(val == other.val)
return 0;
else if(other.val == true)
return -1;
return 1;
}
private boolean val;
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/LinkFactory.java 0000644 0000000 0000000 00000031372 11105701167 017025 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.util.*;
//based upon AbstractFactory
/**
* * This class does not need to be used by normal JCSP users. *
*
* The Builder inner class needs to be sub-classed
* by JCSP.NET protocol implementations.
*
LinkFactory instance.
* Returns an array of ProtocolID objects which identify the protocols.
* @return an array of ProtocolID objects which identify the currently installed protocols.
*/
synchronized ProtocolID[] getTxProtocols()
{
Set tmp = builders.keySet();
return (ProtocolID[]) tmp.toArray(new ProtocolID[tmp.size()]).clone();
}
/** An abstract inner class which should be implemented by
* comunication protocol implementations.
*
* The Builder class provides an abstract method which
* should be implemented to take a NodeAddressID object
* which should be used to construct a Link which is then
* returned by the method to the factory.
*/
public static abstract class Builder
{
/** A constructor which takes the ProtocolID identifying the
* protocol that this Builder supports. This must be called
* by sub-classes.
* @param protocolID the ProtocolID for the protocol that the implementation supports.
*/
public Builder(ProtocolID protocolID)
{
this.protocolID = protocolID;
}
/** Takes a NodeAddressID and constructs and returns
* a Link object.
* @param addressID the AddressID for the remote Node.
* @throws IllegalArgumentException if the AddressID object is invalid.
* @return the constructed Link.
*/
public abstract Link testAndBuild(NodeAddressID addressID)
throws IllegalArgumentException;
/** Gets the ProtocolID that this Builder supports.
* @return the ProtocolID that this Builder supports.
*/
public final ProtocolID getProtocolID()
{
return protocolID;
}
private final ProtocolID protocolID;
}
/*----------------------Attributes--------------------------------------------*/
/**
* This Hashtable stores ProtocolID's as it keys and map these to
* Builders for those Protocols.
*/
private Hashtable builders = new Hashtable();
/*----------------------Inner Classes-----------------------------------------*/
private static class ProtocolComparator implements Comparator
{
/**
* @param o1
* @param o2
* @return */
public int compare(Object o1, Object o2)
{
if (o1 instanceof NodeAddressID)
{
if (o2 instanceof NodeAddressID)
return compare((NodeAddressID) o1, (NodeAddressID) o2);
else if (o2 instanceof ProtocolID)
return compare((NodeAddressID) o1, (ProtocolID) o2);
}
else if (o1 instanceof ProtocolID)
{
if (o2 instanceof NodeAddressID)
return compare((ProtocolID) o1, (NodeAddressID) o2);
else if (o2 instanceof ProtocolID)
return compare((ProtocolID) o1, (ProtocolID) o2);
}
throw new ClassCastException();
}
/**
* @param naID
* @param pID
* @return */
public int compare(NodeAddressID naID, ProtocolID pID)
{
ProtocolID pID1 = naID.getProtocolID();
return compare(pID1, pID);
}
/**
* @param pID
* @param naID
* @return */
public int compare(ProtocolID pID, NodeAddressID naID)
{
ProtocolID pID2 = naID.getProtocolID();
return compare(pID, pID2);
}
/**
* @param naID1
* @param naID2
* @return */
public int compare(NodeAddressID naID1, NodeAddressID naID2)
{
ProtocolID pID1 = naID1.getProtocolID();
ProtocolID pID2 = naID2.getProtocolID();
return compare(pID1, pID2);
}
/**
* @param pID1
* @param pID2
* @return */
public int compare(ProtocolID pID1, ProtocolID pID2)
{
return pID1.getClass().getName().compareTo(pID2.getClass().getName());
}
}
private static class ProtocolPerformanceComparator implements Comparator
{
/**
* @param o1
* @param o2
* @return */
public int compare(Object o1, Object o2)
{
if (o1 instanceof ProtocolID)
{
if (o2 instanceof ProtocolID)
return compare((ProtocolID) o1, (ProtocolID) o2);
}
throw new ClassCastException();
}
/**
* @param pID1
* @param pID2
* @return */
public int compare(ProtocolID pID1, ProtocolID pID2)
{
if (pID1.getPosition() == pID2.getPosition())
return 0;
else if (pID1.getPosition() < pID2.getPosition())
return -1;
else
return 1;
}
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/remote/ 0000755 0000000 0000000 00000000000 11410045050 015211 5 ustar jcsp-1.1-rc4.orig/src/org/jcsp/net/remote/SpawnerServiceNT.java 0000644 0000000 0000000 00000005742 11105701167 021277 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.remote;
import org.jcsp.win32.*;
/**
* Wraps up the SpawnerService as an NT service. To install the service, register the
* path java org.jcsp.net.remote.SpawnerServiceNT with the service name
* JCSP.NET:SpawnerService.
SpawnerService.main.
*/
protected void startService()
{
svc = SpawnerService.construct(new String[0]);
svc.run();
// will block
}
/**
* Terminates the spawner.
*/
protected void stopService()
{
svc.stop();
}
/**
* Creates the service instance.
*/
private SpawnerServiceNT()
{
super("JCSP.NET:SpawnerService");
}
/**
* Creates a service instance and sets it running.
*/
public static void main(String[] args)
{
new SpawnerServiceNT().run();
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/remote/package.html 0000644 0000000 0000000 00000001501 10520670125 017477 0 ustar
Supports the remote spawning of processes at other nodes. A local proxy process strategy is used which
attempts to create similar effects to running the process locally. For example the run method
of the proxy will not complete until the run of the remote process completes so that a
conventional Parallel can be used to synchronize on process termination. Also, any exceptions
raised by the remote process will be similarly raised at the local machine.
Refer to the description of RemoteProcess for examples of use. Refer to
SpawnerService for details of starting the server process to support the spawning of
additional JVMs at a node.
This package is currently in a beta state and the API may be subject to changes.
jcsp-1.1-rc4.orig/src/org/jcsp/net/remote/SpawnerService.java 0000644 0000000 0000000 00000013025 11105701167 021026 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.net.remote; import java.io.*; import org.jcsp.lang.*; import org.jcsp.net.*; import org.jcsp.net.dynamic.*; import org.jcsp.util.filter.*; /** *Services requests from RemoteProcess proxies to start up child JVMs running the
* actual processes.
If started from the command line, it will use the XML config file specified by the first
* command parameter. If no file is given it will try and use JCSPNetSpawnerService.xml to
* initialize the local node. Alternatively it can be started programmatically and the caller must
* take responsibility for initializing the node.
For use by the infrastructure only.
* *Process launcher for starting a child JVM. This class should not be used directly. On loading the
* process to be started will be retrieved from the main SpawnerService JVM and run. The
* .NET node will be initialized using the factory supplied by the spawner. This may be either the
* platform's default factory or one supplied to the proxy ChildProcess processes.
The process started should not call System.exit to terminate. If it does a
* RemoteProcessFailedException will be raised as an abrupt exit cannot be distinguished
* from a .NET infrastructure failure.
If the process raises an exception, this will be forwarded to the caller if possible.
* * @author Quickstone Technologies Limited */ public class ChildProcess { /** * Program entry point. An argument will give the name of a temporary file that contains serialized * representations of the process and other information required to locate the originating host. * * @param args program command line arguments */ public static void main(String[] args) { Throwable eToThrow = null; NetChannelLocation ncl = null; try { NodeFactory nf = null; CSProcess p = null; File f = new File(args[0]); try { ObjectInputStream os = new ObjectInputStream(new FileInputStream(f)); nf = (NodeFactory)os.readObject(); p = (CSProcess)os.readObject(); RemoteProcess.applicationID = (ApplicationID)os.readObject(); ncl = (NetChannelLocation)os.readObject(); os.close(); } finally { f.delete(); } if (nf != null) Node.setNodeFactory(nf); Node.getInstance().init(); p.run(); } catch (Throwable e) { eToThrow = e; } // Try and route the exception back (or send the null for an OK signal) try { NetChannelOutput out = NetChannelEnd.createOne2Net(ncl); out.write(eToThrow); System.exit(0); } catch (Throwable e) { System.err.println("\n"); System.err.println("Unable to route exception back to calling application"); System.err.println("Reason for not being able to route:"); e.printStackTrace(); System.err.println("Exception:"); eToThrow.printStackTrace(); } finally { System.exit(1); } } } jcsp-1.1-rc4.orig/src/org/jcsp/net/remote/ProcessSpawner.java 0000644 0000000 0000000 00000041644 11111260160 021042 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.net.remote; import java.io.*; import org.jcsp.lang.*; import org.jcsp.util.ints.*; import org.jcsp.net.*; /** * Launches a new JVM to run a process received by this spawner. This process will communicate with the * new JVM, routing any exceptions to the requesting host and also any information printed to the *System.err or System.out streams.
*
* @author Quickstone Technologies Limited
*/
class ProcessSpawner implements CSProcess
{
/** A String follows with a line of text that was for System.out. */
final static int MSG_STDOUT = 0; // string follows
/** A String follows with a line of text that was for System.err. */
final static int MSG_STDERR = 1; // string follows
/** An Exception follows that was raised by the spawned process. */
final static int MSG_EXCEPTION = 2; // exception follows
/** An Exception follows that was raised by the spawned process on failure. */
final static int MSG_FAIL = 4; // exception follows
/** The process terminated without error. */
final static int MSG_OK = 5; // nothing follows
/** A String follows with a line of text that was for System.out. */
private final static Integer msgSTDOUT = new Integer(MSG_STDOUT);
/** A String follows with a line of text that was for System.err. */
private final static Integer msgSTDERR = new Integer(MSG_STDERR);
/** An Exception follows that was raised by the spawned process. */
private final static Integer msgEXCEPTION = new Integer(MSG_EXCEPTION);
/** An Exception follows that was raised by the spawned process on failure. */
private final static Integer msgFAIL = new Integer(MSG_FAIL);
/** The process terminated without error. */
private final static Integer msgOK = new Integer(MSG_OK);
/** The parent service that started this one. */
private final SpawnerService service;
/** The process that needs to be started. */
private final CSProcess process;
/** For sending data back to the calling JVM who is running the RemoteProcess proxy. */
private final NetChannelOutput caller;
/**
* The factory the child should use to initialize its node or null if the default initialization
* should take place.
*/
private final NodeFactory factory;
/** The application identifier of the caller that the child should adopt. */
private final ApplicationID applicationID;
/** A unique name generated by the service fo use in creating a temporary file. */
private final String uniqueName;
/**
* The classpath the spawned JVM should use to get the caller's classes from a networked
* filesystem or null if the default classpath should be used.
*/
private final String classPath;
/**
* Constructs a new spawner.
*
* @param service the parent service that is creating this object.
* @param process the process that should be run.
* @param caller for sending data back to the caller.
* @param factory optional factory for initializing the child process' node.
* @param applicationID caller's application ID that the child should adopt.
* @param unique a unique number allocated by the parent service.
* @param classPath classpath specified by the caller process for any classes available from a
* networked filesystem.
*/
public ProcessSpawner(SpawnerService service, CSProcess process, NetChannelOutput caller,
NodeFactory factory, ApplicationID applicationID, int unique, String classPath)
{
this.service = service;
this.process = process;
this.caller = caller;
this.factory = factory;
this.applicationID = applicationID;
String str = Node.getInstance().getNodeID().toString();
str = str.replace(' ', '_').replace('\\', '_').replace('.', '_').replace(':', '_');
this.uniqueName = str + unique;
this.classPath = classPath;
}
/**
* Main process loop.
*/
public void run()
{
final Throwable eToThrow[] = new Throwable[] { null };
try
{
final NetAltingChannelInput _in = NetChannelEnd.createNet2One();
File f = File.createTempFile(uniqueName, "bin");
ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(f));
os.writeObject(factory);
os.flush();
os.writeObject(process);
os.flush();
os.writeObject(applicationID);
os.flush();
os.writeObject(_in.getChannelLocation());
os.close();
// Start the child process
Node.info.log(this, "Starting child process " + f.getAbsolutePath());
final Process child;
if (classPath == null)
child = Runtime.getRuntime().exec(new String[] {"java", ChildProcess.class.getName(), f.getAbsolutePath()});
else
child = Runtime.getRuntime().exec(new String[]
{"java", "-cp", classPath, ChildProcess.class.getName(), f.getAbsolutePath()});
Node.info.log(this, "Child process " + f.getAbsolutePath() + " started");
// A semaphore for synchronising access to the caller
final Any2OneChannelInt semaphore = Channel.any2oneInt(new BufferInt(1));
// Trap the STDOUT and STDERR
Parallel par = new Parallel(new CSProcess[]
{
new CSProcess()
{
public void run()
{
try
{
boolean claimed = false;
try
{
InputStream in = child.getErrorStream();
Reader reader = new InputStreamReader(in);
BufferedReader buffReader = new BufferedReader(reader);
String line = buffReader.readLine();
while (line != null)
{
semaphore.out().write(0);
claimed = true;
caller.write(msgSTDERR);
caller.write(line);
semaphore.in().read();
claimed = false;
line = buffReader.readLine();
}
buffReader.close();
}
catch (LinkLostException e)
{
child.destroy();
semaphore.in().read();
}
catch (Exception e)
{
if (!claimed)
semaphore.out().write(0);
caller.write(msgEXCEPTION);
caller.write(e);
semaphore.in().read();
}
}
catch (Exception e)
{
eToThrow[0] = e;
}
}
},
new CSProcess()
{
public void run()
{
// Wait for an exception to be sent from the child, a null to be sent or
// the process to terminate without sending either (an error)
CSTimer tim = new CSTimer();
Alternative alt = new Alternative(new Guard[] { _in, tim });
while (true)
{
tim.setAlarm(tim.read() + 2000);
if (alt.priSelect() == 0)
{
eToThrow[0] = (Throwable) _in.read();
try
{
semaphore.out().write(0);
caller.write(null);
}
catch (Exception e)
{
child.destroy();
}
finally
{
semaphore.in().read();
}
break;
}
else
{
try
{
int ec = child.exitValue();
eToThrow[0] = new RemoteProcessFailedException(ec, process);
break;
}
catch (IllegalThreadStateException e)
{
}
}
}
}
},
new CSProcess()
{
public void run()
{
try
{
boolean claimed = false;
try
{
InputStream in = child.getInputStream();
Reader reader = new InputStreamReader(in);
BufferedReader buffReader = new BufferedReader(reader);
String line = buffReader.readLine();
while (line != null)
{
semaphore.out().write(0);
claimed = true;
caller.write(msgSTDOUT);
caller.write(line);
semaphore.in().read();
claimed = false;
line = buffReader.readLine();
}
buffReader.close();
}
catch (LinkLostException e)
{
child.destroy();
semaphore.in().read();
}
catch (Exception e)
{
if (!claimed)
semaphore.out().write(0);
caller.write(msgEXCEPTION);
caller.write(e);
semaphore.in().read();
}
}
catch (Exception e)
{
eToThrow[0] = e;
}
}
}
});
par.run();
par.releaseAllThreads();
// wait for process to terminate
Node.info.log(this, "Child process " + f.getAbsolutePath() + " waiting to terminate");
int ec = child.waitFor();
Node.info.log(this, "Child process " + f.getAbsolutePath() + " terminated");
if (ec != 0)
if (eToThrow[0] == null)
eToThrow[0] = new RemoteProcessFailedException(ec, process);
}
catch (Exception e)
{
eToThrow[0] = e;
}
try
{
if (eToThrow[0] != null)
{
caller.write(msgFAIL);
caller.write(eToThrow[0]);
}
else
caller.write(msgOK);
}
finally
{
caller.destroyWriter();
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/net/remote/SpawnerMessage.java 0000644 0000000 0000000 00000006367 11105701167 021025 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.remote;
import java.io.*;
import org.jcsp.lang.*;
import org.jcsp.net.*;
/**
* Message sent from RemoteProcess to SpawnerService listing the details of
* the process that should be started and a network channel address for replying on.
*
* @author Quickstone Technologies Limited
*/
class SpawnerMessage implements Serializable
{
public final CSProcess process;
public final NetChannelLocation caller;
public final NodeFactory factory;
public final ApplicationID applicationID;
public final String classPath;
/**
* Constructs a new message.
*
* @param process the process to be spawned.
* @param caller the location of the RemoteProcess's channel for replies.
* @param factory the optional factory for initializing the remote node.
* @param applicationID the application ID that the remote node should adopt.
* @param classPath the class path the remote JVM should use.
*/
public SpawnerMessage(CSProcess process, NetChannelLocation caller, NodeFactory factory,
ApplicationID applicationID, String classPath)
{
this.process = process;
this.caller = caller;
this.factory = factory;
this.applicationID = applicationID;
this.classPath = classPath;
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/remote/RemoteProcess.java 0000644 0000000 0000000 00000030521 11105701167 020660 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.remote;
import org.jcsp.lang.*;
import org.jcsp.net.*;
/**
* A proxy process that runs locally while another process executes on a different node. An instance
* is created with a CSProcess and an address of a remote node to execute the process on.
* This proxy is itself a CSProcess so can be used in a PAR construct. When
* run it will trigger the remote process. The local run will not return until
* the remote process has terminated.
A factory can be specified to control how the remote process initializes its Node.
* The factory used to initialize the local node should be passed to the remote node so that it will
* use the same CNS and configure other services in the same manner. For example, to initialize from
* the same XML file:
* NodeFactory nf = new XMLNodeFactory ("config.xml");
* try {
* Node.getInstance ().init (nf);
* } catch (NodeNotInitializedException e) {
* System.exit (1);
* }
* NodeAddressID slaveNode1 = new TCPIPAddressID ("123.45.6.78", 6000);
* NodeAddressID slaveNode2 = new TCPIPAddressID ("123.45.6.79", 6000);
* CSProcess proc1 = ...;
* CSProcess proc2 = ...;
* new Parallel (new CSProcess[] {
* new RemoteProcess (proc1, slaveNode1, nf),
* new RemoteProcess (proc2, slaveNode2, nf)
* }).run ();
*
*
* If the local node has class files that won't be available at the remote node it can specify a * network location for a classpath that the remote node should use to get classes from. Dynamic class * loading is not currently implemented for remote spawning in this release.
* *
* NodeAddressID slaveNode1 = new TCPIPAddressID ("123.45.6.78", 6000);
* NodeAddressID slaveNode2 = new TCPIPAddressID ("123.45.6.79", 6000);
* CSProcess proc1 = ...;
* CSProcess proc2 = ...;
* new Parallel (new CSProcess[] {
* new RemoteProcess (proc1, slaveNode1, "\\\\FileServer\\Packages"),
* new RemoteProcess (proc2, slaveNode2, "\\\\FileServer\\Packages")
* }).run ();
*
*
* The remote process will be started in its own JVM and so this approach is not recommended for many * small processes at the same node. If a number of remote processes are required it is suggested that * a process responsible for creating the others be started remotely. For example:
* *
* class WorkerGroup implements CSProcess, Serializable {
*
* private final int numWorkers;
* private final NetChannelLocation farmer, harvester;
*
* public WorkerGroup (int numWorkers, NetChannelLocation farmer,
* NetChannelLocation harvester) {
* this.numWorkers = numWorkers;
* }
*
* public void run () {
* CSProcess workers[] = new CSProcess[numWorkers];
* for (int i = 0; i < numWorkers; i++) {
* workers[i] = new Worker (farmer, harvester);
* }
* new Parallel (workers).run ();
* }
* }
*
* NodeAddressID slaveNode1 = new TCPIPAddressID ("123.45.6.78", 6000);
* NodeAddressID slaveNode2 = new TCPIPAddressID ("123.45.6.79", 6000);
* NetChannelInput workers2farmer = NetChannelEnd.createNet2One ();
* NetChannelInput workers2harvester = NetChannelEnd.createNet2One ();
* One2OneChannel farmer2harvester = Channel.one2one ();
* new Parallel (new CSProcess[] {
* new Farmer (farmer2harvester.out (), workers2farmer),
* new Harvester (farmer2harvester.in (), workers2harvester),
* new RemoteProcess (new WorkerGroup (10, workers2farmer.getChannelLocation (),
* workers2harvester.getChannelLocation ()),
* slaveNode1),
* new RemoteProcess (new WorkerGroup (10, workers2farmer.getChannelLocation (),
* workers2harvester.getChannelLocation ()),
* slaveNode2),
* }).run ();
*
*
* Using a single RemoteProcess for each remote node is more efficient than using
* a RemoteProcess for each of the 10 worker processes at each node.
If a process needs an application ID it should call the static getApplicationID. If
* this is the only node running, it will allocate a new ID. If the process running was started
* remotely then the application ID of the parent node will be returned.
getApplicationID. */
static ApplicationID applicationID = null;
/**
* Returns the application ID. If the caller of this was started as a remote process then the
* parent's application ID will be returned. If this is the first node started then a new
* application ID is allocated.
*
* @return the application ID.
*/
public static synchronized ApplicationID getApplicationID()
{
if (applicationID == null)
applicationID = Node.getInstance().getNewApplicationID();
return applicationID;
}
/**
* Constructs a new proxy.
*
* @param process the process to launch remotely.
* @param remoteNode the node to launch the process on.
*/
public RemoteProcess(CSProcess process, NodeAddressID remoteNode)
{
this.process = process;
this.remoteNode = new NetChannelLocation(remoteNode, "controlSignals");
this.factory = null;
this.classPath = null;
}
/**
* Constructs a new proxy.
*
* @param process the process to launch remotely.
* @param remoteNode the node to launch the process on.
* @param nodeFactory the factory to use for initializing the remote node.
*/
public RemoteProcess(CSProcess process, NodeAddressID remoteNode, NodeFactory factory)
{
this.process = process;
this.remoteNode = new NetChannelLocation(remoteNode, "controlSignals");
this.factory = factory;
this.classPath = null;
}
/**
* Constructs a new proxy.
*
* @param process the process to launch remotely.
* @param remoteNode the node to launch the process on.
* @param classPath the classpath the remote JVM should use.
*/
public RemoteProcess(CSProcess process, NodeAddressID remoteNode, String classPath)
{
this.process = process;
this.remoteNode = new NetChannelLocation(remoteNode, "controlSignals");
this.factory = null;
this.classPath = classPath;
}
/**
* Constructs a new proxy.
*
* @param process the process to launch remotely.
* @param remoteNode the node to launch the process on.
* @param factory the factory to use for initializing the remote node.
* @param classPath the classpath the remote JVM should use.
*/
public RemoteProcess(CSProcess process, NodeAddressID remoteNode, NodeFactory factory, String classPath)
{
this.process = process;
this.remoteNode = new NetChannelLocation(remoteNode, "controlSignals");
this.factory = factory;
this.classPath = classPath;
}
/**
* The main process body. This will communicate with the remote node and send it the information * needed to spawn the remote process. And output from the remote process will be put onto the * system output streams. If the remote process throws an exception this will rethrow the * same exception to the caller.
* *If there is a problem with the remote process, such as it throwing a checked exception or
* error, a RemoteSpawnException will be rethrown which contains the actual exception
* from the process.
Exception that is thrown if Node initialization
* fails.
*
* @author Quickstone Technologies Limited
*/
public class NodeInitFailedException extends Exception
{
NodeInitFailedException()
{
super();
}
NodeInitFailedException(String msg)
{
super(msg);
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NetChannelError.java 0000644 0000000 0000000 00000005175 11105701167 017633 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
/**
* * This is an error that is thrown by a Networked * channel if something happens that should never * happen. This can occur if users disobey rules * to do with the number of concurrent processes * that are allowed to access a channel object at * any instant. *
* * @author Quickstone Technologies Limited */ public class NetChannelError extends Error { /** ** Constructor for NetChannelError. *
*/ public NetChannelError() { super(); } /** ** Constructor for NetChannelError. *
* @param message */ public NetChannelError(String message) { super(message); } } jcsp-1.1-rc4.orig/src/org/jcsp/net/ServiceManager.java 0000644 0000000 0000000 00000013611 11105701167 017467 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.net; import java.util.*; /** *
* An instance of the ServiceManager is created by the Node when
* it is initialized. This reference can be obtained from the Node
* class.
*
* The class allows the local Node's services to be installed and started. The * class does not currently allow services to removed. Services can be stopped * by obtaining their reference and stopping them directly. *
* @author Quickstone Technologies Limited */ public class ServiceManager { private Hashtable services = new Hashtable(); /** * Installs a service as specified by its class and a set * of settings. * @param settings the settings for the service. * @param serviceClass theClass object of the class of the service to install.
* @return true iff the service has successfully been installed.
*/
public synchronized boolean installService(ServiceSettings settings, Class serviceClass)
{
try
{
Service service = (Service) serviceClass.newInstance();
if (!service.init(settings))
return false;
return installService(service, settings.getServiceName());
}
catch (Exception e)
{
Node.err.log(this, e);
return false;
}
}
/**
* Installs a Service object as a service in this
* ServiceManager. The name of the service must be supplied.
* @param service the Service object to install.
* @param name the name of the service.
* @return true iff the service has been successfully installed.
*/
public boolean installService(Service service, String name)
{
synchronized (services)
{
services.put(name, service);
}
return true;
}
/**
* Starts the service with the specified name.
* @param name the name of the service to start.
* @return true iff the service has been successfully started.
*/
public synchronized boolean startService(String name)
{
Service service = getService(name);
if (service != null)
return service.start();
return false;
}
/**
* * This method allows a service that is not running to be * uninstalled. *
*
* A running service can be uninstalled by obtaining the service
* reference, calling its stop() method and then
* calling this method with the service's name.
*
true iff the service has been uninstalled.
*/
public synchronized boolean uninstallService(String name)
{
Service service = getService(name);
if (!service.isRunning())
{
services.remove(name);
return true;
}
return false;
}
/**
*
* Returns the Service object of the service with the specified name.
*
Service object of the service with the specified name.
*/
public Service getService(String name)
{
synchronized (services)
{
return (Service) services.get(name);
}
}
/**
* Returns an array containing an array of String objects
* which represent the names of the currently installed
* services.
*
* @return an array of String service names.
*/
public String[] getServiceNames()
{
synchronized (services)
{
String[] serviceNames = new String[this.services.size()];
Enumeration en = services.keys();
int i = 0;
while (en.hasMoreElements())
{
serviceNames[i] = (String) en.nextElement();
i++;
}
return serviceNames;
}
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/Networked.java 0000644 0000000 0000000 00000004622 11105701167 016540 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
/**
* An interface that should be implemented by any
* class that has a Networked channel location or wishes
* to expose the location of an underlying channel.
*
* @author Quickstone Technologies Limited
*/
public interface Networked
{
/**
* Returns the location of the Networked
* ChannelInput.
*
* @return the NetChannelLocation object.
*/
public NetChannelLocation getChannelLocation();
} jcsp-1.1-rc4.orig/src/org/jcsp/net/config.xml 0000644 0000000 0000000 00000002366 10520670125 015724 0 ustar
* Classes implementing this interface act as factories for constructing
* NetChannelInput and NetChannelOutput objects.
*
* NetChannelInput objects are constructed and have their
* location registered with a channel naming service.
*
* NetChannelOutput objects are constructed and connected
* to NetChannelInput objects whose location is resolved from
* a channel naming service.
*
NetAltingChannelInput object and
* registers its location with the supplied name in the global namespace
* of a channel naming service.
*
* @param name the name against which to register the channel.
*
* @return the constructed NetAltingChannelInput object.
*/
public NetAltingChannelInput createNet2One(String name);
/**
* Constructs a NetAltingChannelInput object and
* registers its location with the supplied name in specified
* namespace of a channel naming service.
*
* @param name the name against which to register the channel.
* @param nameAccessLevel the namespace in which to register the name.
*
* @return the constructed NetAltingChannelInput object.
*/
public NetAltingChannelInput createNet2One(String name, NameAccessLevel nameAccessLevel);
/**
* Constructs a NetSharedChannelInput object and
* registers its location with the supplied name in the global namespace
* of a channel naming service.
*
* @param name the name against which to register the channel.
*
* @return the constructed NetSharedChannelInput object.
*/
public NetSharedChannelInput createNet2Any(String name);
/**
* Constructs a NetSharedChannelInput object and
* registers its location with the supplied name in specified
* namespace of a channel naming service.
*
* @param name the name against which to register the channel.
* @param nameAccessLevel the namespace in which to register the name.
*
* @return the constructed NetSharedChannelInput object.
*/
public NetSharedChannelInput createNet2Any(String name, NameAccessLevel nameAccessLevel);
/**
* Constructs a NetChannelOutput object connected
* to a NetChannelInput located at a location
* resolved from the specified channel name.
*
* @param name the name of the channel from which to resolve the location.
*
* @return the constructed NetChannelOutput object.
*/
public NetChannelOutput createOne2Net(String name);
/**
* Constructs a NetChannelOutput object connected
* to a NetChannelInput located at a location
* resolved from the specified channel name that exists in the supplied
* namespace.
*
* @param name the name of the channel from which to resolve the location.
* @param accessLevel the namespace in which the channel name exists.
*
* @return the constructed NetChannelOutput object.
*/
public NetChannelOutput createOne2Net(String name, NameAccessLevel accessLevel);
/**
* Constructs a NetSharedChannelOutput object connected
* to a NetChannelInput located at a location
* resolved from the specified channel name.
*
* @param name the name of the channel from which to resolve the location.
*
* @return the constructed NetChannelOutput object.
*/
public NetSharedChannelOutput createAny2Net(String name);
/**
* Constructs a NetSharedChannelOutput object connected
* to a NetChannelInput located at a location
* resolved from the specified channel name that exists in the supplied
* namespace.
*
* @param name the name of the channel from which to resolve the location.
* @param accessLevel the namespace in which the channel name exists.
*
* @return the constructed NetChannelOutput object.
*/
public NetSharedChannelOutput createAny2Net(String name, NameAccessLevel accessLevel);
} jcsp-1.1-rc4.orig/src/org/jcsp/net/cns/CNSChannelEndManager.java 0000644 0000000 0000000 00000032356 11105701167 021224 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.cns;
import org.jcsp.net.*;
import java.util.*;
/**
* This class implements the NamedChannelEndManager interface;
* providing methods for both constructing and destroying channels.
*
* This implementation uses the standard Channel Name Server. Instances
* interact with a local CNSService through the use of a
* CNSUser object. The default constructor assumes the use
* of the default CNS service and obtains the reference itself. The
* constructor which takes a CNSUser object allows the use of
* an alternative CNS service. A CNSUser object can be
* obtained by calling a CNSService object's
* getUserObject() method
* ({@link org.jcsp.net.cns.CNSService#getUserObject()}).
*
* For further information see
* {@link org.jcsp.net.cns.NamedChannelEndFactory}.
*
* @see org.jcsp.net.cns.NamedChannelEndFactory
* @see org.jcsp.net.cns.NamedChannelEndManager
* @see org.jcsp.net.cns.CNSService
*
*
* @author Quickstone Technologies Limited
*/
public class CNSChannelEndManager implements NamedChannelEndManager
{
private Hashtable channelInputRegistrations = new Hashtable();
private Hashtable channelOutputsCreated = new Hashtable();
private CNSUser cnsUser;
private NetChannelEndFactory factoryToUse;
/**
* Constructor for CNSChannelEndManager.
*/
public CNSChannelEndManager()
{
super();
factoryToUse = StandardNetChannelEndFactory.getDefaultInstance();
if (CNSService.staticServiceRef != null)
this.cnsUser = (CNSUser)CNSService.staticServiceRef.getUserObject();
}
public CNSChannelEndManager(CNSUser cnsUser)
{
super();
factoryToUse = StandardNetChannelEndFactory.getDefaultInstance();
this.cnsUser = cnsUser;
}
private void checkCnsService()
{
if (this.cnsUser == null)
{
if (CNSService.staticServiceRef != null)
this.cnsUser = (CNSUser)CNSService.staticServiceRef.getUserObject();
if (this.cnsUser == null)
throw new NullPointerException("CNS service to use is null.");
}
}
/**
* Constructs a NetAltingChannelInput object and
* registers its location with the supplied name in the global namespace
* of a channel naming service.
*
* @param name the name against which to register the channel.
*
* @return the constructed NetAltingChannelInput object.
*
* @see org.jcsp.net.cns.NamedChannelEndFactory#createNet2One(String)
*/
public NetAltingChannelInput createNet2One(String name)
{
return createNet2One(name, null);
}
/**
* Constructs a NetAltingChannelInput object and
* registers its location with the supplied name in specified
* namespace of a channel naming service.
*
* @param name the name against which to register the channel.
* @param nameAccessLevel the namespace in which to register the name.
*
* @return the constructed NetAltingChannelInput object.
*
* @see org.jcsp.net.cns.NamedChannelEndFactory#createNet2One(String, NameAccessLevel)
*/
public NetAltingChannelInput createNet2One(String name, NameAccessLevel nameAccessLevel)
{
NetAltingChannelInput chanIn = factoryToUse.createNet2One();
checkCnsService();
ChannelNameKey key = (nameAccessLevel != null)
? cnsUser.register(chanIn, name, nameAccessLevel)
: cnsUser.register(chanIn, name);
ChannelRegistration cr = new ChannelRegistration(name, nameAccessLevel, key);
channelInputRegistrations.put(chanIn, cr);
return chanIn;
}
/**
* Constructs a NetSharedChannelInput object and
* registers its location with the supplied name in the global namespace
* of a channel naming service.
*
* @param name the name against which to register the channel.
*
* @return the constructed NetSharedChannelInput object.
*
* @see org.jcsp.net.cns.NamedChannelEndFactory#createNet2Any(String)
*/
public NetSharedChannelInput createNet2Any(String name)
{
return createNet2Any(name, null);
}
/**
* Constructs a NetSharedChannelInput object and
* registers its location with the supplied name in specified
* namespace of a channel naming service.
*
* @param name the name against which to register the channel.
* @param nameAccessLevel the namespace in which to register the name.
*
* @return the constructed NetSharedChannelInput object.
*
* @see org.jcsp.net.cns.NamedChannelEndFactory#createNet2Any(String, NameAccessLevel)
*/
public NetSharedChannelInput createNet2Any(String name, NameAccessLevel nameAccessLevel)
{
NetSharedChannelInput chanIn = factoryToUse.createNet2Any();
checkCnsService();
ChannelNameKey key = (nameAccessLevel != null)
? cnsUser.register(chanIn, name, nameAccessLevel)
: cnsUser.register(chanIn, name);
ChannelRegistration cr = new ChannelRegistration(name, nameAccessLevel, key);
channelInputRegistrations.put(chanIn, cr);
return chanIn;
}
/**
* Constructs a NetChannelOutput object connected
* to a NetChannelInput located at a location
* resolved from the specified channel name.
*
* @param name the name of the channel from which to resolve the location.
*
* @return the constructed NetChannelOutput object.
*
* @see org.jcsp.net.cns.NamedChannelEndFactory#createOne2Net(String)
*/
public NetChannelOutput createOne2Net(String name)
{
return createOne2Net(name, null);
}
/**
* Constructs a NetChannelOutput object connected
* to a NetChannelInput located at a location
* resolved from the specified channel name that exists in the supplied
* namespace.
*
* @param name the name of the channel from which to resolve the location.
* @param accessLevel the namespace in which the channel name exists.
*
* @return the constructed NetChannelOutput object.
*
* @see org.jcsp.net.cns.NamedChannelEndFactory#createOne2Net(String, NameAccessLevel)
*/
public NetChannelOutput createOne2Net(String name, NameAccessLevel accessLevel)
{
checkCnsService();
NetChannelOutput chanOut = factoryToUse.createOne2Net(cnsUser.resolve(name, accessLevel));
//never use the value for 2Net channels but it must not be null
channelOutputsCreated.put(chanOut, this);
return chanOut;
}
/**
* Constructs a NetSharedChannelOutput object connected
* to a NetChannelInput located at a location
* resolved from the specified channel name.
*
* @param name the name of the channel from which to resolve the location.
*
* @return the constructed NetChannelOutput object.
*
* @see org.jcsp.net.cns.NamedChannelEndFactory#createAny2Net(String)
*
*/
public NetSharedChannelOutput createAny2Net(String name)
{
return createAny2Net(name, null);
}
/**
* Constructs a NetSharedChannelOutput object connected
* to a NetChannelInput located at a location
* resolved from the specified channel name that exists in the supplied
* namespace.
*
* @param name the name of the channel from which to resolve the location.
* @param accessLevel the namespace in which the channel name exists.
*
* @return the constructed NetChannelOutput object.
*
* @see org.jcsp.net.cns.NamedChannelEndFactory#createAny2Net(String, NameAccessLevel)
*/
public NetSharedChannelOutput createAny2Net(String name, NameAccessLevel accessLevel)
{
checkCnsService();
NetSharedChannelOutput chanOut = factoryToUse.createAny2Net(cnsUser.resolve(name, accessLevel));
channelOutputsCreated.put(chanOut, this);
return chanOut;
}
/**
* Destroys an individual NetChannelInput object
* that was constructed with this instance. This will deregister
* the channel name and destroy the channel end.
*
* @param chanInEnd the channel end to destroy.
* @see org.jcsp.net.cns.NamedChannelEndManager#destroyChannelEnd(NetChannelInput)
*/
public void destroyChannelEnd(NetChannelInput chanInEnd)
{
ChannelRegistration registration = (ChannelRegistration) channelInputRegistrations.remove(chanInEnd);
if (registration != null)
{
//channel must have been in the collection so ok
//to deregister it from the CNS
chanInEnd.destroyReader();
checkCnsService();
cnsUser.deregisterChannelName(registration.name, registration.accessLevel, registration.key);
}
else
{
//channel was not created by this factory
throw new WrongFactoryException("Channel End was not created by this factory");
}
}
/**
* Destroys an individual NetChannelOutput object
* that was constructed with this instance. This will simply
* destroy the channel end.
*
* @param chanInEnd the channel end to destroy.
* @see org.jcsp.net.cns.NamedChannelEndManager#destroyChannelEnd(NetChannelOutput)
*/
public void destroyChannelEnd(NetChannelOutput chanOutEnd)
{
if (channelOutputsCreated.remove(chanOutEnd) != null)
//channel was in the HashTable
chanOutEnd.destroyWriter();
else
//channel was not created by this factory
throw new WrongFactoryException("Channel End was not created by this factory");
}
/**
* Destroys all channel ends constructed with this instance
* of the factory.
* @see o.jcsp.net.cns.NamedChannelEndManager#destroyAllChannelEnds()
*/
public void destroyAllChannelEnds()
{
NetChannelInput[] inputChans = new NetChannelInput[channelInputRegistrations.size()];
NetChannelOutput[] outputChans = new NetChannelOutput[channelOutputsCreated.size()];
Enumeration keys = channelInputRegistrations.keys();
int i=0;
while (keys.hasMoreElements())
{
inputChans[i] = (NetChannelInput) keys.nextElement();
i++;
}
keys = channelOutputsCreated.keys();
i=0;
while (keys.hasMoreElements())
{
outputChans[i] = (NetChannelOutput)keys.nextElement();
i++;
}
//code for destroying channels
for (i=0; iAbstractID object can have a single parent
* AbstractID object. This allows a tree-like hierarchy
* to be formed which in turn allows a name space hierarchy.
*
*
* For example, two ApplicationID objects, A and B, may each
* have a parent NodeID Z. The namespaces created around
* A and B will each be a superset of the namespace of Z. Channels registered
* in Z's namespace can be resolved in either A's or B's namespace. A channel
* registered in A's namespace may neither be resolved in Z's namespace nor
* B's.
*
NameAccessLevel for the global namespace.
*/
public static final NameAccessLevel GLOBAL_ACCESS_LEVEL = new NameAccessLevel(GlobalID.instance);
/*------------Constructor----------------------------------------------------*/
/**
*
* Constructor which takes an AbstractID to use
* for identifying the namespace.
*
*/
public NameAccessLevel(AbstractID abstractID)
{
this.abstractID = abstractID;
}
/*------------Methods overriden from Object----------------------------------*/
/**
* Compares an object with this object.
*
* @return ture iff the other object is a
* NameAccessLevel object which has an
* equal underlying AbstractID.
*
* @see org.jcsp.net.AbstractID
*/
public boolean equals(Object o)
{
if(o == null || !(o instanceof NameAccessLevel))
return false;
NameAccessLevel other = (NameAccessLevel) o;
return abstractID.equals(other.abstractID);
}
/**
* Returns a hash code for this object obeying the standard rules
* for a hash code.
*
* @see java.lang.Object#hashCode()
*/
public int hashCode()
{
return abstractID.hashCode();
}
/**
* Returns a string representation of this object.
*
* @return a human readable string.
*/
public String toString()
{
return abstractID.toString();
}
/*------------Package level methods------------------------------------------*/
/**
* Accessor for the underlying AbstractID object.
*
* @return the underlying AbstractID.
*/
AbstractID getLevelAbstractID()
{
return abstractID;
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/cns/CNSUser.java 0000644 0000000 0000000 00000026705 11105701167 016651 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.cns;
import org.jcsp.net.*;
/**
* Interface that a class can implement to indicate that instances allow
* channel names within a naming service to be managed.
*
* @see CNSService
* @see CNSService#getUserObject()
*
* @author Quickstone Technologies Limited
*/
public interface CNSUser
{
/**
*
* This method resolves a channel name into a
* NetChannelLocation object. The name should be
* assumed to be in the global name space (see
* {@link NameAccessLevel#GLOBAL_ACCESS_LEVEL}).
*
* This method resolves a channel name into a
* NetChannelLocation object. The name must
* exist in the specified name space.
*
* The name space is specified by passing in a
* {@link NameAccessLevel} object. A name space
* includes itself and any name space higher up in the
* hierarchy. The global name space is the highest level of
* name space.
*
* This method allows a channel (or any instance of a class implementing
* {@link Networked}) to be registered with a Naming
* Service Implementation. The name will be registered in the
* global name space.
*
Networked object whose location
* should be registered.
* @param name the name against which to register the channel.
* @return the ChannelNameKey needed for managing
* the name registration or null if registration
* failed.
*/
public ChannelNameKey register(Networked owner, String name);
/**
*
* This method allows a channel (or any instance of a class implementing
* {@link Networked}) to be registered with a Naming Service
* Implementation.
*
* The name will be registered in the specified name space. This is
* specified by passing in a {@link NameAccessLevel} object.
*
Networked object whose location
* should be registered.
* @param name the name against which to register the channel.
* @param accessLevel the name space in which to register the channel name.
* @return the ChannelNameKey needed for managing
* the name registration or null if registration
* failed.
*
* @see NameAccessLevel
*/
public ChannelNameKey register(Networked owner, String name, NameAccessLevel accessLevel);
/**
*
* This method allows a channel (or any instance of a class implementing
* {@link Networked}) that has previously been registered
* with the to be reregistered with a Naming Service implementation.
* The name should have been leased (see
* {@link #leaseChannelName(String, NameAccessLevel, ChannelNameKey)}
* ). It is necessaray to supply the key that was obtained when
* the name was leased. If the channel name has not previously been
* registered, then the key can be specified as null.
*
* The name will be registered in the in the global name space. *
* @param owner theNetworked object whose location
* should be registered.
* @param name the name against which to register the channel.
* @param accessLevel the name space in which to register the channel name.
* @return the ChannelNameKey needed for managing
* the name registration or null if registration
* failed.
*/
public ChannelNameKey register(Networked owner, String name, ChannelNameKey key);
/**
*
* This method allows a channel (or any instance of a class implementing
* {@link Networked}) that has previously been registered
* to be reregistered with the Naming Service implementation. The name
* should have been leased (see
* {@link #leaseChannelName(String, NameAccessLevel, ChannelNameKey)}
* ). It is necessaray to supply the key that was obtained when
* the name was leased. If the channel name has not previously been
* registered, then the key can be specified as null.
*
* The name will be registered in the specified name space. This is
* specified by passing in a {@link NameAccessLevel} object.
*
Networked object whose location
* should be registered.
* @param name the name against which to register the channel.
* @param accessLevel the name space in which to register the channel name.
* @param key the ChannelNameKey returned when the
* name was leased.
* @return the ChannelNameKey needed for managing
* the name registration or null if registration
* failed.
* @see NameAccessLevel
*/
public ChannelNameKey register(Networked owner, String name, NameAccessLevel accessLevel, ChannelNameKey key);
/**
*
* This method allows a channel's location to be registered against a
* name in the Naming Service implementation. It differs from the other
* register methods in that it takes a NetChannelLocation
* object instead of a Networked object. This can be obtained
* from a Networked object by invoking its
* getChannelLocation() method (see
* {@link Networked#getChannelLocation()}).
*
* The name will be registered in the specified name space. This is
* specified by passing in a {@link NameAccessLevel} object.
*
* {@link #register(Networked, String, NameAccessLevel, ChannelNameKey)}
* ).
*
*
* @param ownerLocation the location of a channel to be registered
* against the name.
* @param name the name against which to register the channel.
* @param accessLevel the name space in which to register the channel name.
* @param key the ChannelNameKey returned when the
* name was leased.
* @return the ChannelNameKey needed for managing
* the name registration or null if registration
* failed.
*
* @see #register(Networked, String, NameAccessLevel, ChannelNameKey)
* @see NameAccessLevel
*/
public ChannelNameKey register(NetChannelLocation ownerLocation, String name, NameAccessLevel accessLevel,ChannelNameKey key);
/**
* * Leases the channel name within the specified name space * from the Naming Service Implemenation. Once a name has been leased, * a channel cannot be registered with that name without supplying * the key returned by the call to this method. *
*
* Depending on the implementation, leases may expire, however, they
* may be renew by recalling this mehtod. Leases
* can be given up by deregistering the name. Leases should remain even
* after the obtaining Node has shut down. This allows a channel to move
* its registered location to another channel on a different Node. There
* should be no danger of another party managing to obtain the name as
* transfering a registered name into a lease should be an atomic action.
*
* @param name the name to lease.
* @param accessLevel the name space in which to lease the name.
* @param channelKey the key to use if the name is currently
* registered or leased.
*
* @return a new ChannelNameKey needed for managing the
* lease or null if leasing failed.
*
* @throws ChannelNameException if the channel name is invalid.
* @throws NameAccessLevelException if the specifed name space is
* invalid.
*
*/
public ChannelNameKey leaseChannelName(String name, NameAccessLevel accessLevel, ChannelNameKey channelKey)
throws ChannelNameException, NameAccessLevelException;
/**
*
* This deregisters a registered or leased Channel name from the * Naming Service implementation. * A boolean is returned to indicate whether deregistration was successful. *
* * @param name the name of the channel as a String. * @param nameAccessLevel the nameAccessLevel of the channel. * @param channelKey the ChannelNameKey to use to deregister the * Channel name. * * @return a boolean indicating success. */ public boolean deregisterChannelName(String name, NameAccessLevel accessLevel, ChannelNameKey channelKey); } jcsp-1.1-rc4.orig/src/org/jcsp/net/cns/package.html 0000644 0000000 0000000 00000001475 11077376055 017016 0 ustarThis package contains the files specifically for the JCSP.NET Channel Name Service (CNS). A CNS provides a broker service, enabling distributed JCSP processes to set up communications with each other. Networked channels have names. Currently, networked channels are automatically Any-One. The reading process is responsible for creating the channel and (optionally) registering it with a CNS with some unique (to the CNS) name. Writing processes need to know (or be told) the name of a networked channel to connect to it by the CNS. Communications between networked writers and reader then proceed directly (independent from the CNS).
See {@link org.jcsp.net.cns.CNS}
and {@link org.jcsp.net.cns.CNSService}
for information on the service.
* Classes implementing this interface act as factories for constructing
* NetChannelInput and NetChannelOutput objects
* (see {@link NamedChannelEndFactory}).
*
* They also supply methods for destroying the channel ends created, either
* an individual end or all constructed so far. The later provides a convenient
* way for a releasing all org.jcsp.net resources used by a process network. An
* instance of an implementing class could be passed as parameter around a
* process network and used to construct all channels. Once the network has
* terminated the rousources can be released by calling
* {@link #destroyAllChannelEnds()}.
*
* If an attempt is made to destroy a channel end that was not constructed
* by the instance of this class that was invoked, then a
* WrongFactoryException should be thrown.
*
NetChannelInput object
* that was constructed with this instance. This will deregister
* the channel name and destroy the channel end.
*
* @param chanInEnd the channel end to destroy.
*/
public void destroyChannelEnd(NetChannelInput chanInEnd);
/**
* Destroys an individual NetChannelOutput object
* that was constructed with this instance. This will simply
* destroy the channel end.
*
* @param chanOutEnd the channel end to destroy.
*/
public void destroyChannelEnd(NetChannelOutput chanOutEnd);
/**
* Destroys all channel ends constructed with this instance
* of the factory.
*/
public void destroyAllChannelEnds();
}
jcsp-1.1-rc4.orig/src/org/jcsp/net/cns/CNSService.java 0000644 0000000 0000000 00000137337 11105701167 017337 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.cns;
import java.util.*;
import org.jcsp.lang.*;
import org.jcsp.net.*;
import org.jcsp.util.Buffer;
/**
* * This class is the Channel Name Server's main client process class. *
** One instance of this class needs to be instantiated at each Node wishing * to interact with a Channel Name Server. *
** At present only one instance of this service class should be installed at * each Node, however, it is envisaged that it may be desirable to be able to * use multiple Channel Name servers. This functionality has been partially * implemented and eventually multiple instances of this service will be able * to be installed. Each instance would be given a separate name. *
** A default instance of this class can be held. Interaction with this * default instance is facilitated through the static methods of * the {@link CNS} class. *
*
* Once constructed, an instance of the object can be installed into the
* Node's service manager in the same way as any other Service
* (see {@link org.jcsp.net.ServiceManager}).
* Alternatively, the one of the static install methods may be used
* (see {@link CNSService#install(NodeKey, NodeAddressID)},
* {@link CNSService#install(NodeKey, NodeAddressID, String)}).
*
* Default constructor that does not supply any of the necessary settings
* for initializing the CNS. The init(ServiceSettings) method
* must be called if this constructor is used.
*
* Constructor which takes an address of the Node hosting * the Channel Name Server. *
*
* In order to connect to the Channel Name Server, this service
* must know the label of the server's admin channel. By default this
* is given the value of the CNS.CNS_CHANNEL_LABEL constant.
* This constructor assumes that this label has been used. It is equivalent
* to calling the constructor which takes
* (NodeAddressID, String) parameters.
*
* Constructor which takes an address of the Node hosting
* the Channel Name Server as well as a boolean
* indicating whether or not the service should be started.
*
* In order to connect to the Channel Name Server, this service
* must know the label of the server's admin channel. By default this
* is given the value of the CNS.CNS_CHANNEL_LABEL constant.
* This constructor assumes that this label has been used. It is
* equivalent to calling the constructor which takes
* (NodeAddressID, String,boolean) parameters.
*
true to start service.
*
* @see #CNSService(NodeAddressID,String,boolean)
*/
public CNSService(NodeAddressID cnsAddress, boolean start)
{
this(cnsAddress, CNS.CNS_CHANNEL_LABEL, start);
}
/**
* * Constructor which takes an address of the Node hosting * the Channel Name Server as well as the label of the Channel * Name Server's admin channel. *
*
* This is equivalent to using the construtor with
* (NodeAddressID, String, boolean) parameters with the
* boolean equal to false.
*
* Constructor which takes an address of the Node hosting
* the Channel Name Server, the label of the Channel
* Name Server's admin channel and a boolean indicating
* whether the service should be started.
*
* If the service is started, there is no need to initialize and start * the service separately. *
* * @param cnsAddress the address of channel name server to use. * @param adminChannelLabel the label of server's admin channel. * @param start indicates whether the service should be started. * Should betrue to start service.
*
* @see org.jcsp.net.NodeAddressID
*/
public CNSService(NodeAddressID cnsAddress, String adminChannelLabel, boolean start)
{
cnsChannelLocation = new NetChannelLocation(cnsAddress, adminChannelLabel);
holdStaticRef = true;
//Request channels
resolveRequestChanIn = resolveRequestChan.in();
resolveRequestChanOut = resolveRequestChan.out();
registerRequestChanIn = registerRequestChan.in();
registerRequestChanOut = registerRequestChan.out();
deregisterRequestChanIn = deregisterRequestChan.in();
deregisterRequestChanOut = deregisterRequestChan.out();
leaseRequestChanIn = leaseRequestChan.in();
leaseRequestChanOut = leaseRequestChan.out();
//leaseRequestChanIn
registerReplyChanIn = registerReplyChan.in();
registerReplyChanOut = registerReplyChan.out();
deregisterReplyChanIn = deregisterReplyChan.in();
deregisterReplyChanOut = deregisterReplyChan.out();
leaseReplyChanIn = leaseReplyChan.in();
leaseReplyChanOut = leaseReplyChan.out();
//if want to initialize, then initialize
if (start)
{
if (init(null))
{
if (!start())
{
cnsChannelLocation = null;
throw new RuntimeException("Failed to start CNS.");
}
}
else
{
cnsChannelLocation = null;
throw new RuntimeException("Failed to init CNS.");
}
}
}
/*-----------Concrete Implementations of Methods Service---------------------*/
/**
*
* Initializes the this instance of the CNSService.
*
* If the default constructor was used to construct the instance of this
* class, then a name of the instance must be supplied along with at
* least one address of a channel name server. The admin channel label of
* the server may also be supplied. The keys to use in the
* ServiceSettings are held as constants in this class
* ({@link #CNS_SETTING_NAME_ADDRESS},
* {@link #CNS_SETTING_NAME_SERVICE_NAME},
* {@link #CNS_SETTING_NAME_ADMIN_CHANNEL_LABEL}).
*
* This need only be called if the no-arg constructor is used. *
* * @param settings A
* {@link org.jcsp.net.ServiceSettings}
* object that holds the
* settings for this service.
*
* @return true if this request to initialize the service
* succeeds.
*
*/
public boolean init(ServiceSettings settings)
{
synchronized (processStatusChanging)
{
fromCNS = NetChannelEnd.createNet2One(new Buffer(RX_BUFFER_SIZE));
CNSMessage.LogonMessage logonMsg = new CNSMessage.LogonMessage();
logonMsg.replyLocation = fromCNS.getChannelLocation();
String serviceName = (settings != null) ? settings.getSetting(CNS_SETTING_NAME_SERVICE_NAME) : null;
if (serviceName != null)
this.cnsServiceName = serviceName;
if (cnsChannelLocation == null)
{
//construct from the settings object
//get the channel label of CNS Server's admin channel
String adminChannelLabel = settings.getSetting(CNS_SETTING_NAME_ADMIN_CHANNEL_LABEL);
//if no label supplied, use default
if (adminChannelLabel == null)
adminChannelLabel = CNS.CNS_CHANNEL_LABEL;
//Get the list of addresses to try and use to connect to the CNS
NodeAddressID[] possibleAddresses = settings.getAddresses(CNS_SETTING_NAME_ADDRESS);
for (int i = 0; i < possibleAddresses.length; i++)
{
cnsChannelLocation = new NetChannelLocation(possibleAddresses[i], adminChannelLabel);
try
{
//Attempt to send message to CNS
toCNS = NetChannelEnd.createOne2Net(cnsChannelLocation);
toCNS.write(logonMsg);
}
catch (Exception e)
{
if (i == possibleAddresses.length - 1)
{
//no more addresses to try so return false
clearFields();
return false;
}
}
}
if (toCNS == null)
{
clearFields();
return false;
}
}
else
{
//Constructor supplied cns channel location information
try
{
toCNS = NetChannelEnd.createOne2Net(cnsChannelLocation);
toCNS.write(logonMsg);
}
catch (Exception e)
{
e.printStackTrace();
clearFields();
return false;
}
}
try
{
//Wait for logon reply message from CNS
CNSMessage.LogonReplyMessage reply = (CNSMessage.LogonReplyMessage)fromCNS.read();
if (reply.success)
{
synchronized (staticSync)
{
if (holdStaticRef && staticServiceRef == null)
staticServiceRef = this;
}
initialized = true;
return true;
}
else
{
Node.err.log(this, "CNS Logon failure");
clearFields();
return false;
}
}
catch (Exception e)
{
e.printStackTrace();
clearFields();
return false;
}
}
}
private void clearFields()
{
if (fromCNS != null)
{
fromCNS.destroyReader();
fromCNS = null;
}
cnsChannelLocation = null;
if (toCNS != null)
{
toCNS.destroyWriter();
toCNS = null;
}
}
/**
* This checks to see if the service is already running, if it is not then
* it starts it.
*
* @return true iff the service is running once this method has returned.
*/
public boolean start()
{
synchronized (processStatusChanging)
{
if (!initialized)
return false;
if (running)
return true;
One2OneChannel startedChan = Channel.one2one();
new ProcessManager(new ServiceProcess(startedChan.out())).start();
return ((Boolean) startedChan.in().read()).booleanValue();
}
}
/**
* This checks to see if the service is running, if it is then it stops it.
*
* @return true if the service is NOT running.
*/
public boolean stop()
{
stopChan.out().write(null);
return true;
}
/**
* This returns whether the service is running.
* If the service is currently starting or stopping, this method will block
* until the state change is complete.
*
* @return true iff the service is running.
*/
public boolean isRunning()
{
synchronized (processStatusChanging)
{
return running;
}
}
/**
* This returns a ServiceUserObject which implements the
* Resolver interface. This allows processes to obtain a
* reference to an installed CNS Service without having admin
* privileges. A SecurityException may be thrown if the
* calling process does not have permission to obtain the
* ServiceUserObject.
*
* @return a Resolver which can be used to resolve names
* using this CNSService.
* @throws SecurityException if the calling process does not have
* permission to obtain the ServiceUserObject.
*
* @see CNSUser
*
*/
public ServiceUserObject getUserObject() throws SecurityException
{
return userProxy;
}
/*---------------Public Methods-----------------------------------------------*/
/**
*
* Installs and starts a Channel Name Server client service on the
* local Node. The service is installed with the default service name
* as specified by CNSService.CNS_DEFAULT_SERVICE_NAME.
* This method needs to be supplied with the local Node's
* NodeKey. This is required in order to obtain access
* to the Node's service manager.
*
NodeKey.
* @param cnsAddress the address of the Channel Name Server to use.
*
* @throws ServiceInstallationException if installation fails.
*
* @return the CNS object installed.
*/
public static CNSService install(NodeKey key, NodeAddressID cnsAddress)
{
return install(key, cnsAddress, CNS_DEFAULT_SERVICE_NAME);
}
/**
*
* Installs and starts a Channel Name Server client service on the
* local Node. The service is installed with the specified service name.
* This method needs to be supplied with the local Node's
* NodeKey. This is required in order to obtain access to
* the Node's service manager.
*
NodeKey.
* @param cnsAddress the address of the Channel Name Server to use.
* @param name the name to give the service.
*
* @throws ServiceInstallationException if installation fails.
*
* @return the CNS object installed.
*
* @see org.jcsp.net.NodeAddressID
*/
public static CNSService install(NodeKey key, NodeAddressID cnsAddress, String serviceName)
{
ServiceManager sm = Node.getInstance().getServiceManager(key);
//Initialize the CNS Server Process
CNSService cnsService = new CNSService(cnsAddress, false);
if (sm.installService(cnsService, serviceName))
{
if (cnsService.init(null))
{
if (sm.startService(serviceName))
{
Node.info.log("org.jcsp.net.cns.CNSService", "CNSService Started");
return cnsService;
}
}
sm.uninstallService(serviceName);
throw new ServiceInstallationException("Failed to start service.");
}
else
{
Node.info.log("org.jcsp.net.cns.CNSService", "CNSService failed to start");
throw new ServiceInstallationException("Failed to install service.");
}
}
/*-----------Resolving-------------------------*/
/**
*
* This method resolves a channel name into a
* NetChannelLocation object. The name is assumed
* to be in the global name space (see
* {@link NameAccessLevel#GLOBAL_ACCESS_LEVEL}).
*
* This method is safe to be called by concurrent processes. *
* @param name the name of channel to resolve. * @return the location to which the name resolved. */ public NetChannelLocation resolve(String name) { return resolve(name, NameAccessLevel.GLOBAL_ACCESS_LEVEL); } /** *
* This method resolves a channel name into a
* NetChannelLocation object. The name must
* exist in the specified name space.
*
* The name space is specified by passing in a
* {@link NameAccessLevel} object. A name space
* includes itself and any name space higher up in the
* hierarchy. The global name space is the highest level of
* name space.
*
* This method is safe to be called by concurrent processes. *
* @param name the name of channel to resolve. * @param accessLevel the name space in which to resolve * the channel name. * @return the location to which the name resolved. */ public NetChannelLocation resolve(String name, NameAccessLevel accessLevel) { if (accessLevel == null) return resolve(name); if (name == null) throw new IllegalArgumentException("name cannot be null."); PendingResolve req = new PendingResolve(name, accessLevel); resolveRequestChanOut.write(req); NetChannelLocation resolved = (NetChannelLocation) req.sync.in().read(); CNSNetChannelLocation toReturn = new CNSNetChannelLocation(resolved, name, accessLevel, this, cnsServiceName); return (toReturn); } /*-----------Registration----------------------*/ /** *
* This method allows a channel (or any instance of a class implementing
* {@link Networked}) to be registered with the Channel
* Name Server. The name will be registered in the global name space.
*
* A name will stay registered with the Channel Name Server until it * has been leased, deregistered or the Node that registered the name * has shut down. *
** This method is safe to be called by concurrent processes. *
* @param owner theNetworked object whose location
* should be registered.
* @param name the name against which to register the channel.
* @return the ChannelNameKey needed for managing
* the name registration or null if registration
* failed.
*/
public ChannelNameKey register(Networked owner, String name)
{
return register(owner, name, NameAccessLevel.GLOBAL_ACCESS_LEVEL);
}
/**
*
* This method allows a channel (or any instance of a class implementing
* {@link Networked}) to be registered with the Channel
* Name Server.
*
* The name will be registered in the specified name space. This is
* specified by passing in a {@link NameAccessLevel} object.
*
* A name will stay registered with the Channel Name Server until it * has been leased, deregistered or the Node that registered the name * has shut down. *
** This method is safe to be called by concurrent processes. *
* @param owner theNetworked object whose location
* should be registered.
* @param name the name against which to register the channel.
* @param accessLevel the name space in which to register the channel name.
* @return the ChannelNameKey needed for managing
* the name registration or null if registration
* failed.
*
* @see NameAccessLevel
*/
public ChannelNameKey register(Networked owner, String name, NameAccessLevel accessLevel)
{
return register(owner, name, accessLevel, null);
}
/**
*
* This method allows a channel (or any instance of a class implementing
* {@link Networked}) that has previously been registered
* with the to be reregistered with the Channel Name Server. The name
* should have been leased (see
* {@link #leaseChannelName(String, NameAccessLevel, ChannelNameKey)}
* ). It is necessaray to supply the key that was obtained when
* the name was leased. If the channel name has not previously been
* registered, then the key can be specified as null.
*
* The name will be registered in the in the global name space. *
** A name will stay registered with the Channel Name Server until it * has been leased, deregistered or the Node that registered the name * has shut down. *
** This method is safe to be called by concurrent processes. *
* * @param owner theNetworked object whose location
* should be registered.
* @param name the name against which to register the channel.
* @param accessLevel the name space in which to register the channel name.
* @return the ChannelNameKey needed for managing
* the name registration or null if registration
* failed.
*/
public ChannelNameKey register(Networked owner, String name, ChannelNameKey key)
{
return register(owner.getChannelLocation(), name, NameAccessLevel.GLOBAL_ACCESS_LEVEL, key);
}
/**
*
* This method allows a channel (or any instance of a class implementing
* {@link Networked}) that has previously been registered
* to be reregistered with the Channel Name Server. The name
* should have been leased (see
* {@link #leaseChannelName(String, NameAccessLevel, ChannelNameKey)}
* ). It is necessaray to supply the key that was obtained when
* the name was leased. If the channel name has not previously been
* registered, then the key can be specified as null.
*
* The name will be registered in the specified name space. This is
* specified by passing in a {@link NameAccessLevel} object.
*
* A name will stay registered with the Channel Name Server until it * has been leased, deregistered or the Node that registered the name * has shut down. *
** This method is safe to be called by concurrent processes. *
* * @param owner theNetworked object whose location
* should be registered.
* @param name the name against which to register the channel.
* @param accessLevel the name space in which to register the channel name.
* @param key the ChannelNameKey returned when the
* name was leased.
* @return the ChannelNameKey needed for managing
* the name registration or null if registration
* failed.
* @see NameAccessLevel
*/
public ChannelNameKey register(Networked owner, String name, NameAccessLevel accessLevel, ChannelNameKey key)
{
return register(owner.getChannelLocation(), name, accessLevel, key);
}
/**
*
* This method allows a channel's location to be registered against a
* name in the Channel Name Server. It differs from the other register
* methods in that it takes a NetChannelLocation object
* instead of a Networked object. This can be obtained
* from a Networked object by invoking its
* #getChannelLocation() method (see
* {@link Networked#getChannelLocation()}).
*
* The name will be registered in the specified name space. This is
* specified by passing in a {@link NameAccessLevel} object.
*
* {@link #register(Networked, String, NameAccessLevel, ChannelNameKey)}
* ).
*
* * A name will stay registered with the Channel Name Server until it * has been leased, deregistered or the Node that registered the name * has shut down. *
** This method is safe to be called by concurrent processes. *
* * @param ownerLocation the location of a channel to be registered * against the name. * @param name the name against which to register the channel. * @param accessLevel the name space in which to register the channel name. * @param key theChannelNameKey returned when the
* name was leased.
* @return the ChannelNameKey needed for managing
* the name registration or null if registration
* failed.
*
* @see #register(Networked, String, NameAccessLevel, ChannelNameKey)
* @see NameAccessLevel
*/
public ChannelNameKey register(NetChannelLocation ownerLocation, String name,
NameAccessLevel accessLevel, ChannelNameKey key)
{
if (accessLevel == null)
accessLevel = NameAccessLevel.GLOBAL_ACCESS_LEVEL;
if (ownerLocation instanceof LocationNotCNSRegisterable)
throw new IllegalArgumentException("The NetChannelLocation object supplied cannot be registered with the CNS.");
if (name == null || accessLevel == null || ownerLocation == null)
throw new IllegalArgumentException("One or more parameters is null " + (name == null) + " " +
(accessLevel == null) + " " + (ownerLocation == null));
CNSMessage.RegisterRequest request = new CNSMessage.RegisterRequest();
request.name = name;
request.accessLevel = accessLevel;
request.key = key;
request.channelLocation = ownerLocation;
registerRequestChanOut.write(request);
CNSMessage.RegisterReply reply = (CNSMessage.RegisterReply)registerReplyChanIn.read();
if (reply != null)
return reply.key;
else
//link to CNS lost
return null;
}
/*-----------Leasing---------------------------*/
/**
* * Leases the channel name within the specified name space * from the Channel Name Server. Once a name has been leased, * a channel cannot be registered with that name without supplying * the key returned by the call to this method. *
** Currently, leases are infinite; they never expire. This is likely * to change in the future so that leases have to be renewed. Leases * can be given up by deregistering the name. Leases will remain even * after the obtaining Node has shut down. This allows a channel to move * its registered location to another channel on a different Node. There * is no danger of another party managing to obtain the name as transfering * a registered name into a lease is an atomic action. Although leases * are currently infinite, there is no reason why a program cannot renew * the lease by recalling this method. *
** A name may be leased without first registering a channel against it. *
** This method is safe to be called by concurrent processes. *
* * @param name the name to lease. * @param accessLevel the name space in which to lease the name. * @param channelKey the key to use if the name is currently * registered or leased. * * @return a newChannelNameKey needed for managing the
* lease or null if leasing failed.
*
* @throws ChannelNameException if the channel name is invalid.
* @throws NameAccessLevelException if the specifed name space is
* invalid.
*
*/
public ChannelNameKey leaseChannelName(String name, NameAccessLevel accessLevel, ChannelNameKey channelKey)
throws ChannelNameException, NameAccessLevelException
{
if (name == null)
throw new IllegalArgumentException("Null parameter");
if (accessLevel == null)
accessLevel = NameAccessLevel.GLOBAL_ACCESS_LEVEL;
CNSMessage.LeaseRequest request = new CNSMessage.LeaseRequest();
request.name = name;
request.accessLevel = accessLevel;
request.key = channelKey;
leaseRequestChanOut.write(request);
CNSMessage.LeaseReply reply = (CNSMessage.LeaseReply) leaseReplyChanIn.read();
if (reply != null)
return reply.key;
else
return null;
}
/*-----------Deregistration--------------------*/
/**
* * This deregisters a Channel name from the Channel Name Server. * If the CNS Service is not running, this method will block until it * is running. * A boolean is returned to indicate whether deregistration was successful. * This is also returned if the link to the CNS is lost. *
** This method is safe to be called by concurrent processes. *
* * @param name the name of the channel as a String. * @param nameAccessLevel the nameAccessLevel of the channel. * @param channelKey the ChannelNameKey to use to deregister the * Channel name. * * @return a boolean indicating success. */ public boolean deregisterChannelName(String name, NameAccessLevel accessLevel, ChannelNameKey channelKey) { if (name == null || channelKey == null) throw new IllegalArgumentException("Null parameter"); if (accessLevel == null) accessLevel = NameAccessLevel.GLOBAL_ACCESS_LEVEL; CNSMessage.DeregisterRequest request = new CNSMessage.DeregisterRequest(); request.name = name; request.accessLevel = accessLevel; request.key = channelKey; deregisterRequestChanOut.write(request); CNSMessage.DeregisterReply reply = (CNSMessage.DeregisterReply) deregisterReplyChanIn.read(); if (reply != null) return reply.success; else //link to CNS lost return false; } /*---------------Inner Classes------------------------------------------------*/ /** * Data structure for pending resolve requests. * */ private static class PendingResolve { PendingResolve(String name, NameAccessLevel nameAccessLevel) { channelName = name; next = null; sync = Channel.one2one(); this.nameAccessLevel = nameAccessLevel; } final String channelName; final One2OneChannel sync; final NameAccessLevel nameAccessLevel; PendingResolve next; } /** * The main process of the service. * * This handles a single request at a time. * * Register, lease and deregister requests are sent to the server * and then the process waits for a response. * * Resolve requests are sent to the server after which the process * resumes serving requests. The server will send a response back to * this process once a name matching the request has been registered. * */ private class ServiceProcess implements CSProcess { ServiceProcess(ChannelOutput startedChan) { this.startedChan = startedChan; } ChannelOutput startedChan; public void run() { try { final int STOP_INDEX = 0; final int FROM_CNS_INDEX = 1; final int RESOLVE_INDEX = 2; final int REGISTER_INDEX = 3; final int LEASE_INDEX = 4; final int DEREGISTER_INDEX = 5; running = true; Alternative alt = new Alternative(new Guard[] { stopChan.in(), fromCNS, resolveRequestChanIn, registerRequestChanIn, leaseRequestChanIn, deregisterRequestChanIn }); startedChan.write(new Boolean(true)); while (running) { switch (alt.priSelect()) { case STOP_INDEX : stopChan.in().read(); running = false; break; case FROM_CNS_INDEX : Object obj = fromCNS.read(); if (obj instanceof CNSMessage.ResolveReply) { CNSMessage.ResolveReply rr = (CNSMessage.ResolveReply) obj; PendingResolve pr = (PendingResolve)pendingResolves.remove(new CNS.NameAndLevel(rr.name, rr.accessLevel)); while (pr != null) { pr.sync.out().write(rr.channelLocation); pr = pr.next; } } else Node.err.log(this, "Unexpected message type received: " + obj.getClass()); break; case RESOLVE_INDEX : { PendingResolve req = (PendingResolve)resolveRequestChanIn.read(); req.next = (PendingResolve)pendingResolves.put(new CNS.NameAndLevel(req.channelName, req.nameAccessLevel), req); if (req.next == null) { // The request to establish this link had not already // been sent so send request CNSMessage.ResolveRequest request = new CNSMessage.ResolveRequest(); request.name = req.channelName; request.accessLevel = req.nameAccessLevel; request.replyLocation = fromCNS.getChannelLocation(); request.RequestIndex = 0; toCNS.write(request); } break; } case REGISTER_INDEX : { CNSMessage.RegisterRequest req = (CNSMessage.RegisterRequest)registerRequestChanIn.read(); req.RequestIndex = 0; req.replyLocation = fromCNS.getChannelLocation(); // Send request to CNS toCNS.write(req); CNSMessage reply = getRegistrationReply(); if (reply == null) { Node.err.log(this, "Link to CNS lost"); stopCNSService(); } else { while (!(reply instanceof CNSMessage.RegisterReply)) { Node.err.log(this, "Wrong message type received"); reply = getRegistrationReply(); } } registerReplyChanOut.write(reply); break; } case LEASE_INDEX : { CNSMessage.LeaseRequest req = (CNSMessage.LeaseRequest)leaseRequestChanIn.read(); req.RequestIndex = 0; req.replyLocation = fromCNS.getChannelLocation(); // Send request to CNS toCNS.write(req); CNSMessage reply = getRegistrationReply(); if (reply == null) { Node.err.log(this, "Link to CNS lost"); stopCNSService(); } else while (!(reply instanceof CNSMessage.LeaseReply)) Node.err.log(this, "Wrong message type received"); reply = getRegistrationReply(); leaseReplyChanOut.write(reply); break; } case DEREGISTER_INDEX : { CNSMessage.DeregisterRequest req = (CNSMessage.DeregisterRequest)deregisterRequestChanIn.read(); req.RequestIndex = 0; req.replyLocation = fromCNS.getChannelLocation(); // Send request to CNS toCNS.write(req); CNSMessage reply = getRegistrationReply(); if (reply == null) { Node.err.log(this, "Link to CNS lost"); stopCNSService(); } else { while (!(reply instanceof CNSMessage.DeregisterReply)) { Node.err.log(this, "Wrong message type received"); reply = getRegistrationReply(); } } deregisterReplyChanOut.write(reply); break; } } } } catch (Exception e) { e.printStackTrace(); } finally { running = false; } } private CNSMessage getRegistrationReply() { // Get reply from CNS and handle others in the mean time. CNSMessage reply = null; while (reply == null) { Object obj = fromCNS.read(); if (obj instanceof CNSMessage.RegisterReply) reply = (CNSMessage.RegisterReply) obj; else if (obj instanceof CNSMessage.DeregisterReply) reply = (CNSMessage.DeregisterReply) obj; else if (obj instanceof CNSMessage.LeaseReply) reply = (CNSMessage.LeaseReply) obj; else if (obj instanceof CNSMessage.ResolveReply) { CNSMessage.ResolveReply rr = (CNSMessage.ResolveReply) obj; PendingResolve pr = (PendingResolve)pendingResolves.remove(new CNS.NameAndLevel(rr.name, rr.accessLevel)); while (pr != null) { pr.sync.out().write(rr.channelLocation); pr = pr.next; } } else { Thread.dumpStack(); Node.err.log(this, "Unexpected message type received."); } } return reply; } /** * This stops the CNS Service and removes its Channel from * IndexManager. It sets the running indicator to false. * */ private void stopCNSService() { } } /** * This class acts as a proxy for the name management * methods in its outer class. * */ private class UserObject implements ServiceUserObject, CNSUser { public NetChannelLocation resolve(String name) { return outerObject.resolve(name); } public NetChannelLocation resolve(String name, NameAccessLevel accessLevel) { return outerObject.resolve(name, accessLevel); } public ChannelNameKey register(Networked owner, String name) { return outerObject.register(owner, name); } public ChannelNameKey register(Networked owner, String name, NameAccessLevel accessLevel) { return outerObject.register(owner, name, accessLevel); } public ChannelNameKey register(Networked owner, String name, ChannelNameKey key) { return outerObject.register(owner, name, key); } public ChannelNameKey register(Networked owner, String name, NameAccessLevel accessLevel, ChannelNameKey key) { return outerObject.register(owner, name, accessLevel, key); } public ChannelNameKey register(NetChannelLocation ownerLocation, String name, NameAccessLevel accessLevel, ChannelNameKey key) { return outerObject.register(ownerLocation, name, accessLevel, key); } public ChannelNameKey leaseChannelName(String name, NameAccessLevel accessLevel, ChannelNameKey channelKey) throws ChannelNameException, NameAccessLevelException { return outerObject.leaseChannelName(name, accessLevel, channelKey); } public boolean deregisterChannelName(String name, NameAccessLevel accessLevel, ChannelNameKey channelKey) { return outerObject.deregisterChannelName(name, accessLevel, channelKey); } } } jcsp-1.1-rc4.orig/src/org/jcsp/net/cns/CNSMessage.java 0000644 0000000 0000000 00000007227 11105701167 017315 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.net.cns; import java.io.*; import org.jcsp.net.*; /** * This class is only visible to this package and does not need to be * used by JCSP users. * * The class is used for sending messages between the CNS server * process and CNSService client processes. * * @author Quickstone Technologies Limited */ abstract class CNSMessage implements Serializable { static class LogonMessage extends CNSMessage { NetChannelLocation replyLocation; } static class LogonReplyMessage extends CNSMessage { boolean success; } static abstract class CNSRequestMessage extends CNSMessage { NetChannelLocation replyLocation; int RequestIndex; String name; NameAccessLevel accessLevel; } static abstract class CNSReplyMessage extends CNSMessage { int RequestIndex; } static class RegisterRequest extends CNSRequestMessage { NetChannelLocation channelLocation; ChannelNameKey key; } static class ResolveRequest extends CNSRequestMessage { } static class LeaseRequest extends CNSRequestMessage { ChannelNameKey key; } static class DeregisterRequest extends CNSRequestMessage { ChannelNameKey key; } static class RegisterReply extends CNSReplyMessage { ChannelNameKey key; } static class ResolveReply extends CNSReplyMessage { NetChannelLocation channelLocation; String name; NameAccessLevel accessLevel; } static class LeaseReply extends CNSReplyMessage { ChannelNameKey key; } static class DeregisterReply extends CNSReplyMessage { boolean success; } } jcsp-1.1-rc4.orig/src/org/jcsp/net/cns/WrongFactoryException.java 0000644 0000000 0000000 00000004734 11105701167 021670 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.net.cns; /** * Thrown if an attempt is made to get aNamedChannelEndManager
* to destroy a channel that it did not create.
*
* @author Quickstone Technologies Limited
*/
public class WrongFactoryException extends RuntimeException
{
/**
* Constructor for WrongFactoryException.
*/
public WrongFactoryException()
{
super();
}
/**
* Constructor for WrongFactoryException.
* @param message
*/
public WrongFactoryException(String message)
{
super(message);
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/cns/CNS.java 0000644 0000000 0000000 00000121716 11105701167 016010 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.cns;
import java.util.*;
import org.jcsp.lang.*;
import org.jcsp.util.*;
import org.jcsp.net.*;
/**
* * This class is the Channel Name Server's main server process class. *
*
* This class should only be instantiated at Nodes wishing to run
* a server process. Although this class does not need to be used
* by clients wishing to interact with a server, it does
* provide some convenient static methods for client code to use. There
* are static versions of the methods provided in CNSService
* and there are also static factory methods for constructing CNS
* registered channel objects.
*
*
Server Installation
* *
* Channel Name Servers may be run either on a dedicated Node or else on
* the same Node as one of the user Nodes. The former approach is recommended
* for most sitations but for smaller scale use, the latter approach may
* suffice. The service implements the
* org.jcsp.net.Service interface and can be installed
* in the same way as any other other service by using the service manager
* ({@link org.jcsp.net.ServiceManager}). Alternatively, the
* service provides install methods which handle the service manager
* interaction directly.
*
* The following example initializes a Node and installs a Channel Name Server. * It then proceeds to install a CNS client service and creates and resolves * a channel. The example does not proceed to do anything else but could be * used as the framework for an application wishing to host its own * Channel Name Server. *
*
* import org.jcsp.lang.*;
* import org.jcsp.net.*;
* import org.jcsp.net.cns.*;
* import org.jcsp.net.tcpip.*;
*
* import java.io.IOException;
*
* public class CNSInSameJVM implements CSProcess {
*
* //main method for running example
* public static void main(String[] args) {
* CNSInSameJVM proc = new CNSInSameJVM();
* proc.run();
* }
*
* public void run() {
* NodeKey key = null;
* NodeID localNodeID = null;
* try {
* //Initialize a Node that does not have a CNS client
* key = Node.getInstance().init(new XMLNodeFactory("nocns.xml"));
* localNodeID = Node.getInstance().getNodeID();
*
* //Initialize the CNS Server Process
* CNS.install(key);
*
* //Dedicated server code could stop here
*
* //Initialize the CNS client
* //use the first address of the local Node as CNS address
* NodeAddressID cnsAddress = localNodeID.getAddresses()[0];
* CNSService.install(key, cnsAddress);
*
* //creating Channel named "in"
* NetChannelInput in = CNS.createNet2One("in");
* //resolve the channel
* NetChannelOutput out = CNS.createOne2Net("in");
*
* //could now use these channels for something!!
* //but this is only a test so will terminate
*
*
* } catch (NodeInitFailedException e) {
* e.printStackTrace();
* } catch (IOException e) {
* e.printStackTrace();
* }
* Node.info.log(this, "Done.");
* }
*
* }
*
* * This is the contents of the nocns.xml file: *
* <JCSP-CONFIG>* <PROTOCOLS>
* <PROTOCOL id="TCPIP" name="TCP/IP" idclass="org.jcsp.net.tcpip.TCPIPProtocolID">
* </PROTOCOL>
* </PROTOCOLS>
* <ADDRESSES>
* <ADDRESS protocolid="TCPIP" value="127.0.0.1:7896" unique="FALSE">
* </ADDRESS>
* </ADDRESSES>
* </JCSP-CONFIG>
*
* The above code can be copied into a file named CNSInSameJVM.java and compiled * an run in same directory as the nocns.xml file. *
**
Channel Factory Methods
* *
* In order to construct a ChannelInput object which can be
* resolved by other users of a channel name server, a client simply needs
* to to do this:
*
* NetChannelInput in = CNS.createNet2One("Fred");
*
*
* Another process using the same channel name server can create a
* ChannelOutput that will send objects to this channel
* by do this:
*
* NetChannelOutput out = CNS.createOne2Net("Fred");
*
*
* When these factory methods are called, various resources are used
* within the JCSP infrastructure. A channel name will be registered
* and held in the channel name server. These resources are taken for
* the duration of the JCSP Node's runtime unless the user manually
* frees the resources. When channel ends are constructed with these
* factory methods, the destroyChannelEnd(***) methods
* can be used to free all resources. It is only really necessary to
* do this if channels are being created for short term use within
* a long-lived Node.
*
* This is an example "Hello World" program which contains two * inner classes with main methods, each of which can be run in * separate JVMs. *
*
* import org.jcsp.lang.*;
* import org.jcsp.net.*;
* import org.jcsp.net.cns.*;
*
* public class TestCNS {
*
* public static class Rx {
* public static void main(String[] args) {
* try {
* Node.getInstance().init();
* NetChannelInput in = CNS.createNet2One("rx.in");
* System.out.println(in.read());
* CNS.destroyChannelEnd(in);
* } catch (NodeInitFailedException e) {
* e.printStackTrace();
* }
* }
* }
*
* public static class Tx {
* public static void main(String[] args) {
* try {
* Node.getInstance().init();
* NetChannelOutput out = CNS.createOne2Net("rx.in");
* out.write("Hello World");
* CNS.destroyChannelEnd(out);
* } catch (NodeInitFailedException e) {
* e.printStackTrace();
* }
* }
* }
* }
*
* * This code can be compiled and then the following run at two * command prompts: *
** java TestCNS$Rx *
** java TestCNS$Tx *
*
* The programs will connect to a default channel name server. The
* Rx program will create a NetChannelInput and wait
* for a message on the channel. Once it has received the message,
* it prints it, destroys its channel and then terminates.
* The Tx program creates a NetChannelOutput that will
* send to the Rx program's input channel. It sends a "Hello World"
* message. Once this has been accepted by the Rx process, it
* destoys its output channel and terminates.
*
*
CNS Client Methods
* ** The following code functions the same as the above code but does * not use the CNS class' factory methods. The code uses the CNS client * methods and manually registers and resolves the channel with the * channel name server. * *
*
* import org.jcsp.lang.*;
* import org.jcsp.net.*;
* import org.jcsp.net.cns.*;
*
* public class TestCNS {
*
* public static class Rx {
* public static void main(String[] args) {
* try {
* Node.getInstance().init();
* NetChannelInput in = NetChannelEnd.createNet2One();
* ChannelNameKey key = CNS.register(in, "rx.in");
* System.out.println(in.read());
* CNS.deregisterChannelName("rx.in", null, key);
* } catch (NodeInitFailedException e) {
* e.printStackTrace();
* }
* }
* }
*
* public static class Tx {
* public static void main(String[] args) {
* try {
* Node.getInstance().init();
* NetChannelLocation loc = CNS.resolve("rx.in");
* NetChannelOutput out = NetChannelEnd.createOne2Net(loc);
* out.write("Hello World");
* out.destroyWriter();
* } catch (NodeInitFailedException e) {
* e.printStackTrace();
* }
* }
* }
* }
*
*
* The CNS client methods provide the programmer with greater control
* over how the Channel Name Server is used. Interaction with the
* server need not be performed at the same time as construction of
* the channel. A channel can be registered with a Channel Name Server
* at any time after construction of its input end. A channel can be resolved
* at any time before construction of an output end. This allows one process
* to resolve a name into a NetChannelLocation object and
* then pass this object on for another process to use in constructing the
* channel.
*
* The Channel Name Server will allow a channel to be registered multiple
* times with different names and/or in different name spaces. Channel
* implementations that make direct use of the Channel Name Server may
* forbid this, so the behaviour of channel implemenations should be checked
* before this is carried out
*
NodeKey as a parameter which
* should be the key for the local Node.
*
* @param nodeKey a NodeKey object that should match
* the local Node's NodeKey.
* @throws IllegalStateException if the local Node has not been
* initialized.
* @throws SecurityException if the supplied NodeKey
* object cannot be verified by the local Node.
*/
public CNS(NodeKey nodeKey) throws IllegalStateException, SecurityException
{
if (!Node.getInstance().isInitialized())
throw new IllegalStateException();
if (!Node.getInstance().verifyKey(nodeKey))
throw new SecurityException();
}
/*---------------Public constants--------------------------------------------*/
public final static String CNS_DEFAULT_SERVICE_NAME = "org.jcsp.net.cns:Channel Name Server";
/*---------------Package level constants-------------------------------------*/
final static String CNS_CHANNEL_LABEL = "org.jcsp.net.cns.CNSLabel";
/*---------------Private fields----------------------------------------------*/
private final int INPUT_BUFFER_SIZE = 30;
private boolean running = false;
private Any2OneChannel stopChan = Channel.any2one();
private Hashtable toClientChans = new Hashtable();
private long channelKeyCount = 0;
private One2OneChannel startedReplyChan = Channel.one2one();
/**
* The registered channel names and indexes.
* This is a hashtable where the key is a
* NameAndLevel object and the value is the ChannelID.
*/
private Hashtable channels = new Hashtable();
private Hashtable leasedChannelKeys = new Hashtable();
/**
* This holds NameAndLevel objects as the keys that map to the
* associated ChannelNameKey objects.
*/
private Hashtable registeredChannelKeys = new Hashtable();
/**
* The registered channel names and indexes.
* This is a hashtable where the key is the
* channel name and the value is the ChannelID.
*/
private Hashtable pendingResolves = new Hashtable();
private static CNSChannelEndManager CHAN_FACTORY = new CNSChannelEndManager();
/*---------------Public Methods-from Service Interface------------------------*/
/** This starts the channel name server.
* @return true iff the channel name server is able to start.
*/
public boolean start()
{
new ProcessManager(this).start();
running = Boolean.TRUE.equals(startedReplyChan.in().read());
return running;
}
/**
* Stops the channel name server.
* @return true iff the Channel Name Server has accepted the stop request.
*/
public boolean stop()
{
//change this to a connection later
if (running)
{
stopChan.out().write(null);
running = false;
return true;
}
return false;
}
/** This method does not need to be called for the Channel Name Server. It returns true.
* @param settings A ServiceSettings object containing settings for the service.
* @return false
*/
public boolean init(ServiceSettings settings)
{
return true;
}
/** Returns whether the service is running.
* At the moment this always returns false.
* This will probably change in the future.
* Early JCSP.NET applications always had the CNS process running in its own JVM.
* @return false
*/
public boolean isRunning()
{
return false;
}
/**
* Returns a null reference as this method has no
* use with this service.
*
* @return null.
*/
public ServiceUserObject getUserObject() throws SecurityException
{
return null;
}
/*---------------Public Methods from CSProcess--------------------------------*/
public void run()
{
boolean run = true;
final int CHAN_STOP = 0;
final int CHAN_EVENT = 1;
final int CHAN_FROM_NET = 2;
//get a channel from the Node which can be used to received
//events notiying that a link to a particular Node has been
//dropped.
AltingChannelInput linkEvents = Node.getInstance().getLinkLostEventChannel();
NetAltingChannelInput fromNet = null;
try
{
fromNet = NetChannelEnd.createNet2One(CNS_CHANNEL_LABEL, new Buffer(INPUT_BUFFER_SIZE));
}
catch (DuplicateChannelLabelException e)
{
Node.err.log(this, "CNS unable to create a labelled channel. Another CNS service might be running.");
run = false;
startedReplyChan.out().write(Boolean.FALSE);
return;
}
catch (Exception e)
{
Node.err.log(this, "Exception occurred while starting CNS");
Node.err.log(this, e);
run = false;
startedReplyChan.out().write(Boolean.FALSE);
return;
}
Alternative alt = new Alternative(new Guard[] { stopChan.in(), linkEvents, fromNet });
startedReplyChan.out().write(Boolean.TRUE);
Node.info.log(this, "CNS server starting");
while (run)
{
switch (alt.priSelect())
{
case CHAN_STOP :
run = false;
break;
case CHAN_EVENT :
Object obj = linkEvents.read();
handleLinkDropped((NodeID) obj);
Node.info.log(this, "Received link event " + obj);
break;
case CHAN_FROM_NET :
try
{
Object o = fromNet.read();
if (o instanceof CNSMessage.LogonMessage)
handleLogonMessage((CNSMessage.LogonMessage) o);
else if (o instanceof CNSMessage.RegisterRequest)
handleRegisterRequest((CNSMessage.RegisterRequest) o);
else if (o instanceof CNSMessage.ResolveRequest)
handleResolveRequest((CNSMessage.ResolveRequest) o);
else if (o instanceof CNSMessage.LeaseRequest)
handleLeaseRequest((CNSMessage.LeaseRequest) o);
else if (o instanceof CNSMessage.DeregisterRequest)
handleDeregisterRequest((CNSMessage.DeregisterRequest) o);
}
catch (Exception e)
{
Node.err.log(this, "Error caught and ignored");
Node.err.log(this, e);
}
break;
}
}
//Destroy the fromNet channel so that all the
//CNS clients are notified that the CNS has gone down
fromNet.destroyReader();
if (stopChan.in().pending())
stopChan.in().read();
}
/*---------------Other Public Methods-----------------------------------------*/
/*---------------Public Static Methods----------------------------------------*/
/*-----------Resolving-------------------------*/
public static NetChannelLocation resolve(String name)
{
return CNSService.staticServiceRef.resolve(name);
}
public static NetChannelLocation resolve(String name, NameAccessLevel accessLevel)
{
return CNSService.staticServiceRef.resolve(name, accessLevel);
}
/*-----------Registration----------------------*/
public static ChannelNameKey register(Networked owner, String name)
{
return CNSService.staticServiceRef.register(owner, name);
}
public static ChannelNameKey register(Networked owner, String name, NameAccessLevel accessLevel)
{
return CNSService.staticServiceRef.register(owner, name, accessLevel);
}
public static ChannelNameKey register(Networked owner, String name, ChannelNameKey key)
{
return CNSService.staticServiceRef.register(owner, name, key);
}
public static ChannelNameKey register(Networked owner, String name, NameAccessLevel accessLevel, ChannelNameKey key)
{
return CNSService.staticServiceRef.register(owner, name, accessLevel, key);
}
public static ChannelNameKey register(NetChannelLocation ownerLocation,
String name,
NameAccessLevel accessLevel,
ChannelNameKey key)
{
return CNSService.staticServiceRef.register(ownerLocation, name, accessLevel, key);
}
/*-----------Leasing---------------------------*/
public static ChannelNameKey leaseChannelName(String name, NameAccessLevel accessLevel, ChannelNameKey channelKey)
throws ChannelNameException, NameAccessLevelException
{
return CNSService.staticServiceRef.leaseChannelName(name, accessLevel, channelKey);
}
/*-----------Deregistration--------------------*/
/**
* This deregisters a Channel name with the CNS. If the CNS Service is not
* running, this method will block until it is running.
* A boolean is returned to indicate whether deregistration was successful.
* This is also returned if the link to the CNS is lost.
*
* @param name the name of the channel as a String.
* @param nameAccessLevel the nameAccessLevel of the channel.
* @param channelKey the ChannelNameKey to use to deregister the
* Channel name.
*
* @return a boolean indicating success.
*/
public static boolean deregisterChannelName(String name, NameAccessLevel accessLevel, ChannelNameKey channelKey)
{
return CNSService.staticServiceRef.deregisterChannelName(name, accessLevel, channelKey);
}
/*---------------Private Methods----------------------------------------------*/
private void handleLogonMessage(CNSMessage.LogonMessage msg)
{
NetChannelOutput toClient = NetChannelEnd.createOne2Net(msg.replyLocation);
NodeID clientID = msg.replyLocation.getChannelNodeID();
CNSMessage.LogonReplyMessage reply = new CNSMessage.LogonReplyMessage();
if (clientID == null || toClientChans.containsKey(clientID))
//not going to allow Node to logon - does not have NodeID
//or a CNS service on that NodeID is already logged in
reply.success = false;
else
{
toClientChans.put(clientID, toClient);
reply.success = true;
}
toClient.write(reply);
}
private void handleRegisterRequest(CNSMessage.RegisterRequest msg)
{
//get the channel to reply down
ChannelOutput replyChan = (ChannelOutput)toClientChans.get(msg.replyLocation.getChannelNodeID());
if (replyChan == null || msg.name == null || (msg.channelLocation == null))
Node.info.log(this, "CNS server process received an invalid register request");
else
{
// set up reply
CNSMessage.RegisterReply reply = new CNSMessage.RegisterReply();
reply.RequestIndex = msg.RequestIndex;
//attempt to register the channel - key will be null if
//registration fails
reply.key = registerChannel(msg.name, msg.accessLevel, msg.channelLocation, msg.key);
//send the reply to the user
replyChan.write(reply);
if (reply.key != null)
{
Node.info.log(this, msg.name + ", " + msg.accessLevel + " registered to " + msg.channelLocation);
// Notify any waiting processes.
PendingResolve toPutBack = null;
PendingResolve ir = (PendingResolve) pendingResolves.remove(msg.name);
while (ir != null)
{
PendingResolve nextIr = ir.next;
ir.reply.channelLocation = getChannel(ir.channelName, ir.nameAccessLevel);
if (ir.reply.channelLocation == null)
{
//The new channel has the wrong nameAccessLevel
//for this queued request, so put request back
ir.next = toPutBack;
toPutBack = ir;
}
else
{
ir.txReplyChannel.write(ir.reply);
Node.info.log(this, "Queued resolve for " + ir.channelName + "," + ir.nameAccessLevel + " was completed");
}
ir = nextIr;
}
if (toPutBack != null)
pendingResolves.put(msg.name, toPutBack);
}
else
Node.err.log(msg.name + ", " + msg.accessLevel + " could not be registered to " +
msg.channelLocation + " - already registered.");
}
}
private void handleResolveRequest(CNSMessage.ResolveRequest msg)
{
Node.info.log(this, "ResolveRequest");
ChannelOutput replyChan = (ChannelOutput)toClientChans.get(msg.replyLocation.getChannelNodeID());
if (replyChan == null || msg.name == null)
Node.err.log(this, "CNS asked to resolve null name");
else
{
// set up reply
CNSMessage.ResolveReply reply = new CNSMessage.ResolveReply();
reply.RequestIndex = msg.RequestIndex;
reply.channelLocation = getChannel(msg.name, msg.accessLevel);
reply.name = msg.name;
reply.accessLevel = msg.accessLevel;
if (reply.channelLocation != null)
{
Node.info.log(this, "Channel " + msg.name + " resolved by " + msg.replyLocation + " to " + reply.channelLocation);
// Send reply
replyChan.write(reply);
}
else
{
Node.info.log(this, "Attempted resolve of " + msg.name + " by " + msg.replyLocation + " was queued");
// Queue request, reply when it registers.
PendingResolve ir = new PendingResolve(reply, replyChan, msg.name, msg.accessLevel);
ir.next = (PendingResolve) pendingResolves.put(msg.name, ir);
}
}
}
private void handleLeaseRequest(CNSMessage.LeaseRequest msg)
{
ChannelOutput replyChan = (ChannelOutput)toClientChans.get(msg.replyLocation.getChannelNodeID());
if (replyChan == null)
Node.err.log(this, "CNS received an invalid lease request.");
else
{
CNSMessage.LeaseReply reply = new CNSMessage.LeaseReply();
reply.RequestIndex = msg.RequestIndex;
if (msg.name == null)
reply.key = null;
else
{
NameAccessLevel nameAccessLevel = msg.accessLevel;
if (nameAccessLevel == null)
nameAccessLevel = NameAccessLevel.GLOBAL_ACCESS_LEVEL;
NameAndLevel nal = new NameAndLevel(msg.name, nameAccessLevel);
//check to see the channel has been registered
if (deregisterChannel(msg.name, nameAccessLevel, msg.key))
{
reply.key = new ChannelNameKey(channelKeyCount++);
leasedChannelKeys.put(nal, reply.key);
}
}
replyChan.write(reply);
}
}
private void handleDeregisterRequest(CNSMessage.DeregisterRequest msg)
{
ChannelOutput replyChan = (ChannelOutput)toClientChans.get(msg.replyLocation.getChannelNodeID());
if (replyChan == null)
Node.err.log(this, "CNS received an invalid deregister request.");
else
{
// set up reply
CNSMessage.DeregisterReply reply = new CNSMessage.DeregisterReply();
reply.RequestIndex = msg.RequestIndex;
// do the request
reply.success = deregisterChannel(msg.name, msg.accessLevel, msg.key);
// Send reply
replyChan.write(reply);
if (reply.success)
Node.info.log(this, msg.name + ", " + msg.accessLevel + " was deregistered.");
else
Node.info.log(this, msg.name + ", " + msg.accessLevel + " could not be deregistered");
}
}
private void handleLinkDropped(NodeID nodeID)
{
Object txChannel = toClientChans.get(nodeID);
// Iterating a Hashtable is a **nightmare**
// But we're going to do it twice!
//
// What happens if we change the Hashtable while
// we're enumerating is undefined, so we have to start
// all over again.
// Any pending requests?
boolean changed = true;
while (changed)
{
changed = false;
Enumeration e = pendingResolves.keys();
while ((!changed) && e.hasMoreElements())
{
String n = (String) e.nextElement();
PendingResolve ir = (PendingResolve) pendingResolves.get(n);
// Make sure we need to keep the first one.
while ((ir != null) && (ir.txReplyChannel == txChannel))
{
ir = ir.next;
changed = true; // must start again.
}
if (ir == null)
pendingResolves.remove(n);
else
{
if (changed)
pendingResolves.put(n, ir);
// Unlink any others we need to remove.
// (We can change here without starting again,
// since this isn't actually in the Hashtable)
while (ir.next != null)
{
if (ir.next.txReplyChannel == txChannel)
// Unlink
ir.next = ir.next.next;
else
// OK, check next.
ir = ir.next;
}
}
}
}
// Any registered channels?
// Well, unregister them.
changed = true;
while (changed)
{
changed = false;
Enumeration e = channels.keys();
while ((!changed) && e.hasMoreElements())
{
NameAndLevel n = (NameAndLevel) e.nextElement();
NetChannelLocation id = (NetChannelLocation) channels.get(n);
if (id.getChannelNodeID().equals(nodeID))
{
channels.remove(n);
// "Broken link, so unregistered.");
Node.info.log(this, "Broken link, so " + n + " unregistered.");
changed = true; // must start again.
}
}
}
}
/**
* Register a Channel in the database. Fails if the channel has already
* been registered to a different location. (Re-registering to
* the same ChannelID is allowed) or if it has been leased and the supplied
* key does not match the leased channel name's key.
*
* @param channelName The channel's name.
* @param channelId The channel's ChannelID.
* @return a ChannelNameKey on successful database update, null if the name
* is already registered elsewhere.
*/
private ChannelNameKey registerChannel(String channelName, NameAccessLevel nameAccessLevel,
NetChannelLocation channelLoc, ChannelNameKey channelKey)
{
if (channelName == null || nameAccessLevel == null)
return null;
NameAndLevel nal = new NameAndLevel(channelName, nameAccessLevel);
NetChannelLocation existingID = (NetChannelLocation) channels.get(nal);
//Check to see whether name has been leased, and if it has then
//the supplied channel key must equal the leased channel name's key,
//otherwise return null.
if (existingID == null)
{
Node.info.log(this, "Reg: channel not registered - might be leased");
ChannelNameKey leasedNameKey = (ChannelNameKey)leasedChannelKeys.get(nal);
if (leasedNameKey != null)
{
Node.info.log(this, "Has been leased");
if (!leasedNameKey.equals(channelKey))
{
Node.info.log(this, "Keys not equal - " + leasedNameKey + ", " + channelKey);
return null;
}
}
//key matches so remove from the leasedChannelKeys set
leasedChannelKeys.remove(nal);
}
if ((existingID != null) && (!existingID.equals(channelLoc)))
return null;
else
{
channels.put(nal, channelLoc);
ChannelNameKey newChannelKey = new ChannelNameKey(channelKeyCount++);
registeredChannelKeys.put(nal, newChannelKey);
Node.info.log(this, "Returning new key");
return newChannelKey;
}
}
/**
* Get a ChannelID for a channel with a name that matches the supplied name
* and whose name is within the supplied scope.
*
* @param channelName The channel's name.
* @param nameAccessLevel the channel's nameAccessLevel
* @return a ChannelID if one can be found that matches the name and
* nameAccessLevel, otherwise returns null.
*/
private NetChannelLocation getChannel(String channelName, NameAccessLevel nameAccessLevel)
{
//find most local matching channel
NetChannelLocation toReturn = null;
AbstractID abstractID = nameAccessLevel.getLevelAbstractID();
while (toReturn == null && abstractID != null)
{
toReturn = (NetChannelLocation)channels.get(new NameAndLevel(channelName, nameAccessLevel));
if (toReturn == null)
{
abstractID = abstractID.getParentID();
nameAccessLevel = new NameAccessLevel(abstractID);
}
}
return toReturn;
}
/**
* Deregisters a channel name and nameAccessLevel if a channel matches
* or removes a matching lease.
*
* @param channelName the channel's name.
* @param nameAccessLevel the channel's nameAccessLevel
* @return true iff a matching channel is not registered after returning.
*/
private boolean deregisterChannel(String channelName, NameAccessLevel nameAccessLevel, ChannelNameKey channelKey)
{
if (channelName == null || nameAccessLevel == null)
return true;
NameAndLevel nal = new NameAndLevel(channelName, nameAccessLevel);
ChannelNameKey registeredKey = (ChannelNameKey)registeredChannelKeys.get(nal);
if (registeredKey != null)
{
if (registeredKey.equals(channelKey))
{
registeredChannelKeys.remove(nal);
return (channels.remove(nal) != null);
}
else
return false;
}
//channel isn't registered - check to see if it has been leased
//If so, remove the lease
registeredKey = (ChannelNameKey) leasedChannelKeys.get(nal);
if (registeredKey != null)
{
if (registeredKey.equals(channelKey))
{
leasedChannelKeys.remove(nal);
return true;
}
else
return false;
}
return true;
}
/*----------------Factory Methods for Channels--------------------------------*/
/**
* @see org.jcsp.net.cns.NamedChannelEndFactory#createNet2One(String)
*/
public static NetAltingChannelInput createNet2One(String name)
{
return CHAN_FACTORY.createNet2One(name);
}
/**
* @see org.jcsp.net.cns.NamedChannelEndFactory#createNet2One(String, NameAccessLevel)
*/
public static NetAltingChannelInput createNet2One(String name, NameAccessLevel nameAccessLevel)
{
return CHAN_FACTORY.createNet2One(name, nameAccessLevel);
}
/**
* @see org.jcsp.net.cns.NamedChannelEndFactory#createNet2Any(String)
*/
public static NetSharedChannelInput createNet2Any(String name)
{
return CHAN_FACTORY.createNet2Any(name);
}
/**
* @see org.jcsp.net.cns.NamedChannelEndFactory#createNet2Any(String, NameAccessLevel)
*/
public static NetSharedChannelInput createNet2Any(String name, NameAccessLevel nameAccessLevel)
{
return CHAN_FACTORY.createNet2Any(name, nameAccessLevel);
}
/**
* @see org.jcsp.net.cns.NamedChannelEndFactory#createOne2Net(String)
*/
public static NetChannelOutput createOne2Net(String name)
{
return CHAN_FACTORY.createOne2Net(name);
}
/**
* @see org.jcsp.net.cns.NamedChannelEndFactory#createOne2Net(String, NameAccessLevel)
*/
public static NetChannelOutput createOne2Net(String name, NameAccessLevel accessLevel)
{
return CHAN_FACTORY.createOne2Net(name, accessLevel);
}
/**
* @see org.jcsp.net.cns.NamedChannelEndFactory#createAny2Net(String)
*/
public static NetSharedChannelOutput createAny2Net(String name)
{
return CHAN_FACTORY.createAny2Net(name);
}
/**
* @see org.jcsp.net.cns.NamedChannelEndFactory#createAny2Net(String, NameAccessLevel)
*/
public static NetSharedChannelOutput createAny2Net(String name, NameAccessLevel accessLevel)
{
return CHAN_FACTORY.createAny2Net(name, accessLevel);
}
public static void destroyChannelEnd(NetChannelInput chanInEnd)
{
CHAN_FACTORY.destroyChannelEnd(chanInEnd);
}
public static void destroyChannelEnd(NetChannelOutput chanOutEnd)
{
CHAN_FACTORY.destroyChannelEnd(chanOutEnd);
}
/*----------------Static method for installing CNS into current Node----------*/
/**
* Installs and starts a Channel Name Server on the local Node.
* The service is installed with the default service name as specified
* by CNS.CNS_DEFAULT_SERVICE_NAME. This method needs to be
* supplied with the local Node's NodeKey. This is
* required in order to obtain access to the Node's service manager.
*
* @param key the local Node's NodeKey.
*
* @throws ServiceInstallationException if installation fails.
*
* @return the CNS object installed.
*/
public static CNS install(NodeKey key)
{
return install(key, CNS_DEFAULT_SERVICE_NAME);
}
/**
* Installs and starts a Channel Name Server on the local Node.
* The service is installed with the specified service name. This
* method needs to be supplied with the local Node's NodeKey.
* This is required in order to obtain access to the Node's service
* manager.
*
* @param key the local Node's NodeKey.
* @param name the name to give the service.
*
* @throws ServiceInstallationException if installation fails.
*
* @return the CNS object installed.
*/
public static CNS install(NodeKey key, String serviceName)
{
ServiceManager sm = Node.getInstance().getServiceManager(key);
//Initialize the CNS Server Process
CNS cns = new CNS(key);
if (sm.installService(cns, serviceName))
{
if (sm.startService(serviceName))
{
Node.info.log("org.jcsp.net.cns.CNS", "CNS Started");
return cns;
}
else
{
sm.uninstallService(serviceName);
throw new ServiceInstallationException("Failed to start service.");
}
}
else
{
Node.info.log("org.jcsp.net.cns.CNS", "CNS failed to start");
throw new ServiceInstallationException("Failed to install service.");
}
}
/*----------------Inner Classes-----------------------------------------------*/
/**
* A data structure for holding a channel name and access level.
* This can be used as a key in a Hashtable.
*/
static class NameAndLevel
{
NameAndLevel(String name, NameAccessLevel nameAccessLevel)
{
this.name = name;
this.nameAccessLevel = nameAccessLevel;
}
/** Compares this object with another object.
* @param o An object to compare with this object.
* @return true iff o is a non-null NameAndLevel
* object which represents the same name and level as this object.
*/
public boolean equals(Object o)
{
if (o == null || !(o instanceof NameAndLevel))
return false;
NameAndLevel other = (NameAndLevel) o;
//should be able to use == check for nameAccessLevel as only
//static nameAccessLevel's are accessible
return name.equals(other.name) && nameAccessLevel.equals(other.nameAccessLevel);
}
/** Returns a hash code for this object.
* @return an int hash code for this object.
*/
public int hashCode()
{
return name.hashCode() + nameAccessLevel.hashCode();
}
/** Returns a human readable String representation of this NameAccessLevel object.
* @return the human readable string as a String object.
*/
public String toString()
{
return "[" + name + ", " + nameAccessLevel + "]";
}
private String name;
private NameAccessLevel nameAccessLevel;
}
static private class PendingResolve
{
CNSMessage.ResolveReply reply;
ChannelOutput txReplyChannel;
String channelName;
NameAccessLevel nameAccessLevel;
PendingResolve next;
PendingResolve(CNSMessage.ResolveReply reply, ChannelOutput txReplyChannel,
String channelName, NameAccessLevel nameAccessLevel)
{
this.channelName = channelName;
this.nameAccessLevel = nameAccessLevel;
this.reply = reply;
this.txReplyChannel = txReplyChannel;
next = null;
}
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/cns/CNSNetChannelLocation.java 0000644 0000000 0000000 00000010416 11105701167 021433 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.cns;
import org.jcsp.net.*;
/**
*
* Instances of this class are returned by the resolve methods
* of {@link CNSService}. JCSP.NET users cannot create
* the objects directly.
*
* The objects returned by the {@link CNSService} can be used
* in place of normal NetChannelLocation objects.
*
NetChannelInput from the channel name server.
*
* @return true if any information has changed, otherwise
* false.
*
*/
public boolean refresh()
{
NetChannelLocation refreshed = null;
if (cnsResolver == null)
//obtain a reference to the installed CNS
this.cnsResolver = (CNSUser) Node.getInstance().getServiceUserObject(this.cnsServiceName);
if (accessLevel == null)
refreshed = cnsResolver.resolve(name);
else
refreshed = cnsResolver.resolve(name, accessLevel);
if (!this.equals(refreshed))
{
//CNS has updated the location object
refreshFrom(refreshed);
return true;
}
else
//nothing has changed
return false;
}
/*-----------Other public methods--------------------------------------------*/
} jcsp-1.1-rc4.orig/src/org/jcsp/net/cns/ChannelNameException.java 0000644 0000000 0000000 00000004627 11105701167 021416 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.cns;
/**
* An exception caused by an invalid channel name.
*
* @author Quickstone Technologies Limited
*/
public class ChannelNameException extends IllegalArgumentException
{
/**
* Default constructor.
*/
public ChannelNameException()
{
super();
}
/**
* Constructor.
*
* @param description Description of the error.
*/
public ChannelNameException(String description)
{
super(description);
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/cns/ChannelNameKey.java 0000644 0000000 0000000 00000007046 11105701167 020206 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net.cns;
import java.util.*;
import java.io.*;
/**
* Instances of this hold a key for a particular channel.
* ChannelNameKey objects are issued by the channel
* name server. They must be supplied to the channel name server
* along with any channel management requests (channel deregistration,
* relocation etc.).
*
* This class has no public constructor.
*
* @author Quickstone Technologies Limited
*/
public final class ChannelNameKey implements Serializable
{
private int hashCode;
private final long val;
private final long key;
ChannelNameKey(long val)
{
this.val = val;
Random rnd = new Random(System.currentTimeMillis() - Runtime.getRuntime().freeMemory() + val);
key = rnd.nextLong();
hashCode = new Long(val).hashCode();
}
/**
* Compares another Object with this
* ChannelNameKey.
*
* @param o the other Object to compare with
* this Object.
* @return true iff o is a non-null
* ChannelNameKey object which holds the
* same key as this object.
*/
public boolean equals(Object o)
{
if (o == null || !(o instanceof ChannelNameKey))
return false;
ChannelNameKey other = (ChannelNameKey) o;
return val == other.val && key == other.key;
}
/**
* Returns an int hash code for this object.
*
* @return an int hash code.
*/
public int hashCode()
{
return hashCode;
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NodeUI.java 0000644 0000000 0000000 00000016255 11105701167 015726 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.io.*;
import java.lang.reflect.*;
/**
*
* A Unique Identifier for a Node.
* This class is different from NodeID in that it does not describe the
* Node's location.
*
* Implementations of this class should provide a constructor that takes a
* String parameter which is in the format of the String
* returned from the getImplStringForm() method.
*
String that can be supplied to the
* static createFromStringForm(String) method in order to
* create an equal NodeUI object.
*
* @return a String containing the necessary information to recreate this NodeUI object.
*/
protected abstract String getImplStringForm();
/** Creates a NodeUI from a String in the format of that returned from the
* getImplStringForm() method.
* @param stringForm the String to use in creating the NodeUI object.
* @return a newly created NodeUI object.
*/
public static final NodeUI createFromStringForm(String stringForm)
{
String[] strings = Utils.stringToArray(stringForm);
if(strings.length < 2)
throw new IllegalArgumentException("Incorrect string supplied.");
try
{
Class nodeUIClass = Class.forName(strings[0]);
Constructor constr = nodeUIClass.getConstructor(new Class[] {String.class});
NodeUI instance = (NodeUI)constr.newInstance(new Object[] {strings[1]});
return instance;
}
catch (NoSuchMethodException e)
{
throw new IllegalArgumentException("Constructor with String does not exist.");
}
catch (Exception e)
{
throw new IllegalArgumentException("Unable to create constructor from String provided.");
}
}
/** Compares this NodeUI with another object.
* This method checks that the supplied object is a NodeUI object
* and then calls the implementation of the checkEqual(NodeUI)
* method and returns its result value as the result of this method.
* @param o an object to compare with this object.
* @return true iff the supplied object is a NodeUI and the
* result of a call to the checkEqual(NodeUI) method is true.
*/
public final boolean equals(Object o)
{
if(o == null || !(o instanceof NodeUI) || !(this.getClass().equals(o.getClass())))
return false;
return checkEqual((NodeUI) o);
}
/** Compares this NodeUI with another object. This method
* calls the implementation of the getComparisonString() method
* on both this NodeUI object and the NodeUI object
* supplied. The String class' compareTo(Object) is
* used to perform the comparison. The method is called on the String
* returned by this object and the String returned by the other object
* is supplied as the parameter.
* @param o another object to compare with this object.
* @throws ClassCastException if the supplied object is not a NodeUI object.
* @return an int value that follows the rules of the
* compareTo(Object) method in the String class.
*/
public final int compareTo(Object o) throws ClassCastException
{
NodeUI other = (NodeUI) o;
return getComparisonString().compareTo(other.getComparisonString());
}
/**
* An abstract method to be implemented to return whether another
* NodeUI object is equal to this instance. If the the
* NodeUI is of a different implementation class, the method
* should return false.
* @param other a NodeUI to compare with this NodeUI.
* @return true iff the supplied NodeUI is equal to this one.
*/
protected abstract boolean checkEqual(NodeUI other);
/** This is an abstract method that should be implemented to return a
* String that can be used by the compareTo(Object)
* method in order to compare two NodeUI objects.
*
* Two NodeUI objects should return equal
* String objects iff the two NodeUI objects are equal.
* @return a String that follows the above rules.
*/
protected abstract String getComparisonString();
/** Returns an int hash code for this object.
* Two NodeUI objects will return equal hash codes if the two objects
* are equal.
* @return an int hash code.
*/
public abstract int hashCode();
} jcsp-1.1-rc4.orig/src/org/jcsp/net/DomainID.java 0000644 0000000 0000000 00000015266 11105701167 016230 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import java.io.*;
/**
* * A Class whose instances represent a unique identifier for a JCSP.NET domain. *
** See {@link AbstractID} for a further explanation of domains and the use * of this class. *
* * @author Quickstone Technologies Limited */ public final class DomainID extends AbstractID implements Serializable, Comparable { private boolean nullDom = false; private String name = ""; private static final String NullDomainStringForm = "NullDomain"; private static final String DomainStringFormPrefix = "Domain :"; /** * Constructor which constructs an ID for the Null Domain. * */ DomainID() { //constructor for null domain nullDom = true; } /** * Public constructor for aDomainID which takes
* the name of the domain as a parameter.
* @param name The name of the domain.
*/
public DomainID(String name)
{
this.name = name;
}
/**
*
* @deprecated not needed now channel names abstracted
*/
static DomainID createFromStringForm(String str) throws IllegalArgumentException
{
if (str == null)
throw new IllegalArgumentException("No String supplied");
if (str.equals(DomainStringFormPrefix + NullDomainStringForm))
return getNullDomainID();
else
return new DomainID(str.substring(DomainStringFormPrefix.length()));
}
/**
* This compares an object with this object.
* @param o an object to compare with this object.
* @return true iff the supplied object is a non-null DomainID which represents the same Domain.
*/
public boolean equals(Object o)
{
if (o == null || !(o instanceof DomainID))
return false;
DomainID other = (DomainID) o;
if (nullDom)
{
if (other.isNullDomain())
return true;
return false;
}
//change later to make more secure
return name.equals(other.getDomainName());
}
/**
*
* Returns an int hash code for the current object.
*
* This obeys the standard hash code rules. *
* @return anint hash code.
*/
public int hashCode()
{
return name.hashCode();
}
/**
* * Compares this object with another object and returns whether * the supplied object is equals, smaller or larger. *
* @param o The object to compare with this object. * @return 0 if the supplied object is equal, a negative integer if the supplied object is smaller or a positive integer if the other object is larger. */ public int compareTo(Object o) { DomainID other = (DomainID) o; if (nullDom && other.nullDom) return 0; return name.compareTo(other.name); } boolean onSameBranch(AbstractID abstractID) { if (abstractID == null) return false; if (abstractID instanceof GlobalID) return true; if (abstractID instanceof DomainID) return this.equals(abstractID); if (abstractID instanceof NodeID || abstractID instanceof ApplicationID) //abstractID below this in name hierachy - ask it return abstractID.onSameBranch(this); return false; } boolean isNullDomain() { return nullDom; } static DomainID getNullDomainID() { return new DomainID(); } /** ** Public accessor for the Domain name. *
** Returns "" if this represents the Null Domain. *
* @return the domain name as aString.
*/
public String getDomainName()
{
return name;
}
/**
*
* Returns a human readable String showing this domain
* name and any parent domains.
*
String.
*/
public String toString()
{
if (nullDom)
return "\\" + getParentID();
return getParentID() + "\\" + name;
}
/**
*
* @deprecated not needed now channel names abstracted
*/
String getStringForm()
{
if (nullDom)
return DomainStringFormPrefix + NullDomainStringForm;
else
return DomainStringFormPrefix + name;
}
/**
* * Returns the identifier representing this domain's parent * domain. *
** At present this always returns the global domain's ID. *
* @return the parentAbstractID.
*/
public AbstractID getParentID()
{
return GlobalID.instance;
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NetAltingConnectionServer.java 0000644 0000000 0000000 00000007076 11105701167 021700 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.lang.*;
/**
*
* Instances of this class are AltingConnectionServer
* objects which allow connections from ConnectionClient
* objects from over a JCSP.NET network.
*
* Instances of this class are not guaranteed to be safe to use
* by muliple concurrent processes. See
* {@link NetSharedConnectionServer} for a server
* class that may be used between multiple processes, however
* this may not be ALTed over.
*
* Instances can be constructed by using a
* {@link NetConnectionFactory} or by
* using the {@link NetConnection} class.
*
NetChannelLocation
* object.
*/
public NetChannelLocation getChannelLocation()
{
return chan.getChannelLocation();
}
/**
* Destroys the server and frees any resources used
* in the JCSP.NET infrastructure.
*/
public void destroyServer()
{
chan.destroyReader();
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NetConnection.java 0000644 0000000 0000000 00000006412 11105701167 017343 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
/**
*
* This class provides static methods for constructing
* NetConnectionServer and NetConnectionClient
* objects.
*
* The methods provided are equivalent to the methods defined in
* {@link NetConnectionFactory}.
*
null reference.
*/
private Net2OneChannel(String label, AltingChannelInput actualChan, RejectableChannel ch) throws IllegalArgumentException
{
super(actualChan);
if (label == null)
throw new IllegalArgumentException("Label supplied is null");
if (label != "")
Node.info.log(this, "Creating a channel with VCN label: " + label);
this.label = label;
netChannelInputProcess = new NetChannelInputProcess(label,ch);
new ProcessManager(netChannelInputProcess).start();
}
/**
* Creates a zero-buffered channel reader.
* The getChannelLocation() method can
* be called to obtain the location information of the constructed
* channel.
*/
private Net2OneChannel(AltingChannelInput actualChan, RejectableChannel ch)
{
super(actualChan);
this.label = null;
netChannelInputProcess = new NetChannelInputProcess(this.label,ch);
new ProcessManager(netChannelInputProcess).start();
}
/**
* Returns a new NetChannelLocation object which holds the
* information necessary for a networked ChannelOutput to
* establish a connection to this channel reader.
*
* @return the location information for this channel reader.
*/
public NetChannelLocation getChannelLocation()
{
return new NetChannelLocation(Node.getInstance().getNodeID(), netChannelInputProcess.getChannelIndex());
}
/**
* Destroys this end of the channel.
*/
public void destroyReader()
{
netChannelInputProcess.breakChannel();
}
/**
* This method should not be called. The implementation channel is not
* available to subclasses of Net2OneChannel.
*
* @return Always null.
*/
protected AltingChannelInput getChannel()
{
return null;
}
long getChannelIndex()
{
return netChannelInputProcess.getChannelIndex();
}
public Class getFactoryClass()
{
return StandardNetChannelEndFactory.class;
}
/**
* Currently, network channels are unpoisonable so this method has no effect.
*/
public void poison(PoisonException poison) {
}
/**
* Currently, network channels are unpoisonable so this method will never throw a PoisonException
*/
public void checkPoison() throws PoisonException {
}
/*-----------------Attributes-------------------------------------------------*/
private final String label;
private NetChannelInputProcess netChannelInputProcess;
} jcsp-1.1-rc4.orig/src/org/jcsp/net/ReaderIndexException.java 0000644 0000000 0000000 00000004312 11105701167 020643 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
/**
* An exception that is thrown if data is written to a
* Networked ChannelOutput and
* the destination address is incorrect.
*
* @author Quickstone Technologies Limited
*/
public class ReaderIndexException extends RuntimeException
{
} jcsp-1.1-rc4.orig/src/org/jcsp/net/NetChannelInputProcess.java 0000644 0000000 0000000 00000020321 11105701167 021166 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.lang.*;
/**
* A process for network input (RX).
*
* This is a package-private implementation class.
*
* @author Quickstone Technologies Limited
*/
// package-private
class NetChannelInputProcess implements CSProcess
{
/**
* Constructor which takes a label to assign to the channel's
* VCN and a
*
* @return The first Message read from the network.
*/
private Object readFromNetChannel()
{
int selection = alt.priSelect();
if(selection == 0)
{
stopChannel.in().read();
//request to stop the server - reject any more messages
while (fromNetIn.pending())
{
Object obj = fromNetIn.read();
if (obj instanceof LinkLost)
{
LinkLost cl = (LinkLost)obj;
cl.txChannel.write(cl); // acknowlegement.
}
else
{
ChannelMessage.Data message;
try
{
//reject any messages pending
message = (ChannelMessage.Data)obj;
}
catch (ClassCastException e)
{
Node.err.log(this, "NetChannelInputProcess received an unexpected message type");
break;
}
ChannelMessage.WriteRejected writeRejected = new ChannelMessage.WriteRejected();
writeRejected.destIndex = message.sourceIndex;
writeRejected.sourceIndex = channelIndex;
// Send the rejection
message.txReplyChannel.write(writeRejected);
}
}
return null;
}
else
{
Object obj = fromNetIn.read();
while (obj instanceof LinkLost)
{
LinkLost cl = (LinkLost)obj;
cl.txChannel.write(cl); // acknowlegement.
obj = fromNetIn.read();
}
return obj;
}
}
/**
* Handle this link. Gets data and sends acknowlegements.
* Runs forever.
*/
public void run()
{
boolean stop = false;
while (stop == false)
{
// Read a message from TCP/IP.
Object obj = readFromNetChannel();
if(obj == null)
{
stop = true;
Node.info.log(this, "NetChanInProc stopping");
}
else if (obj instanceof ChannelMessage.Data)
{
// Deal with it.
ChannelMessage.Data message = (ChannelMessage.Data)obj;
// Output the data (will block until the user process reads it)
try
{
out.out().write(message.data);
if (message.acknowledged)
{
// Prepare an acknowlegement message
//ChanndelMessage.Ack ack = new ChannelMessage.Ack();
ChannelMessage.Ack ack = null;
if(sendAckA)
ack = this.ackA;
else
ack = this.ackB;
this.sendAckA = !sendAckA;
ack.destIndex = message.sourceIndex;
ack.sourceIndex = channelIndex;
// Send the acknowlegement
message.txReplyChannel.write(ack);
}
}
catch (ChannelDataRejectedException e)
{
//data never read
e.printStackTrace();
if (message.acknowledged)
{
ChannelMessage.WriteRejected writeRejected = new ChannelMessage.WriteRejected();
writeRejected.destIndex = message.sourceIndex;
writeRejected.sourceIndex = channelIndex;
// Send the rejection
message.txReplyChannel.write(writeRejected);
}
}
}
else
{
Node.err.log(this, "Unexpected message type received: " + obj.getClass());
}
}
}
/**
* Our channel index.
*/
private long channelIndex;
/**
* Our channel ID.
*/
private ChannelID channelID;
/**
* The name of this channel.
*/
private String name;
/**
* The channel we use for recieving from the demuxes.
*/
private AltingChannelInput fromNetIn;
private SharedChannelOutput fromNetOut;
/**
* The channel used for output.
*/
private RejectableChannel out;
private Any2OneChannel stopChannel = Channel.any2one();
private Alternative alt;
private transient ChannelMessage.Ack ackA = new ChannelMessage.Ack();
private transient ChannelMessage.Ack ackB = new ChannelMessage.Ack();
private transient boolean sendAckA = true;
} jcsp-1.1-rc4.orig/src/org/jcsp/net/Profile.java 0000644 0000000 0000000 00000020003 11105701167 016165 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
import org.jcsp.net.settings.*;
import java.util.*;
/**
*
* This class is used to hold profiles of Nodes and Links.
*
* Node profiles are not currently used.
*
* This is an implementation of
* This class provides static factory methods for constructing
* Networked channel ends.
*
* The methods are equivalent to the methods defined in
*
* An object that is returned when the Node is initialized. It
* is required for any Node management operations.
*
* An interface implemented by classes wishing to be Networked
*
* Implementing this interface does not guarantee that the input
* end can be used by multiple concurrent processes nor can it
* necessarily be ALTed over.
*
* Returns a Class file of the factory used to construct the
* channel end.
*
* Destroys the channel end and frees any resources within
* the JCSP.NET infrastructure.
*
*
* Each of the fixed delay processes have a delay time of 100, 200 or 300
* microseconds.
*
* The anonymous CSProcess has an infinite loop which will ALT on the
* channels d, e & f. When one of these Channels becomes ready with data
* the process will write the index of the Channel and the data value down
* the g Channel.
*
* @author P.D. Austin
*/
public class AltTest implements CSProcess {
/**
* The main body of this process.
*/
public void run () {
One2OneChannel a = Channel.one2one ();
One2OneChannel b = Channel.one2one ();
One2OneChannel c = Channel.one2one ();
final One2OneChannel d = Channel.one2one ();
final One2OneChannel e = Channel.one2one ();
final One2OneChannel f = Channel.one2one ();
final One2OneChannel g = Channel.one2one ();
new Parallel (
new CSProcess[] {
new Numbers (a.out ()),
new Numbers (b.out ()),
new Numbers (c.out ()),
new FixedDelay (100, a.in (), d.out ()),
new FixedDelay (200, b.in (), e.out ()),
new FixedDelay (300, c.in (), f.out ()),
new CSProcess () {
public void run () {
Guard[] chans = {d.in (), e.in (), f.in ()};
Alternative alt = new Alternative (chans);
while (true) {
switch (alt.select ()) {
case 0:
g.out ().write ("Channel 0 read " + d.in ().read () + "\n");
break;
case 1:
g.out ().write (" Channel 1 read " + e.in ().read () + "\n");
break;
case 2:
g.out ().write (" Channel 2 read " + f.in ().read () + "\n");
break;
}
}
}
},
new Printer (g.in ())
}
).run ();
}
/**
* Main entry point for the application.
*/
public static void main (String argv[]) {
new AltTest ().run ();
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/test/TestExtendedRendezvous.java 0000644 0000000 0000000 00000034402 11103430320 021437 0 ustar package org.jcsp.test;
import java.util.Arrays;
import java.util.Collections;
import junit.framework.TestCase;
import org.jcsp.lang.AltingBarrier;
import org.jcsp.lang.Any2AnyChannel;
import org.jcsp.lang.Any2AnyChannelInt;
import org.jcsp.lang.Any2OneChannel;
import org.jcsp.lang.Any2OneChannelInt;
import org.jcsp.lang.CSProcess;
import org.jcsp.lang.Channel;
import org.jcsp.lang.ChannelInput;
import org.jcsp.lang.ChannelInputInt;
import org.jcsp.lang.ChannelInt;
import org.jcsp.lang.ChannelOutput;
import org.jcsp.lang.ChannelOutputInt;
import org.jcsp.lang.Guard;
import org.jcsp.lang.One2AnyChannel;
import org.jcsp.lang.One2AnyChannelInt;
import org.jcsp.lang.One2OneChannel;
import org.jcsp.lang.One2OneChannelInt;
import org.jcsp.lang.Parallel;
import org.jcsp.lang.Sequence;
import org.jcsp.util.Buffer;
import org.jcsp.util.OverFlowingBuffer;
import org.jcsp.util.ints.BufferInt;
public class TestExtendedRendezvous extends TestCase {
/**
* Asserts that the two arrays are equal. The arrays are equal iff
* they are the same length, and the Object references in them
* are the same references (and in the same order)
*/
public void assertArraysEqual(Object[] a,Object[] b) {
assertEquals(a.length,b.length);
for (int i = 0;i < a.length;i++) {
assertSame(a[i],b[i]);
}
}
public void assertArraysEqual(int[] a,int[] b) {
assertEquals(a.length,b.length);
for (int i = 0;i < a.length;i++) {
assertEquals(a[i],b[i]);
}
}
public void helper_testChannelOneWriter(ChannelInput in,ChannelOutput out) {
/*
* This test checks that the reads and writes occur in the right order during an extended rendezvous
*
* Specifically , it checks that the extended action always occurs before the write has finished
*
* The event-recorder offers a read event, a write event and a terminate event
* The terminate event is only done (by the BarrierSyncer) once the other processes have finished
*
* The writer offers the write event *after* each write.
* The reader offers the single read event during each extended rendezvous.
*
* Therefore the events should be in lock-step:
* read,write,read,write...
*/
AltingBarrier[] terminateEvent = AltingBarrier.create(2);
AltingBarrier[] writeEvent = AltingBarrier.create(2);
AltingBarrier[] readEvent = AltingBarrier.create(2);
EventRecorder recorder;
new Parallel( new CSProcess[] {
recorder = new EventRecorder(new Guard[] {writeEvent[0],readEvent[0],terminateEvent[0]},2),
new Sequence(new CSProcess[] {
new Parallel( new CSProcess[] {
new WriterProcess(out,Collections.nCopies(100,null),writeEvent[1]),
new ExtendedReaderSync(readEvent[1],in,100)
}),
new BarrierSyncer(terminateEvent[1])
})
}).run();
Guard[] expectedEvents = new Guard[201];
for (int i = 0;i < 100;i++) {
expectedEvents[i*2 + 0] = readEvent[0];
expectedEvents[i*2 + 1] = writeEvent[0];
}
expectedEvents[200] = terminateEvent[0];
assertArraysEqual(expectedEvents,recorder.getObservedEvents());
}
public void testNormalOne2OneChannel() {
One2OneChannel chan = Channel.one2one();
helper_testChannelOneWriter(chan.in(), chan.out());
}
public void testNormalAny2OneChannel() {
Any2OneChannel chan = Channel.any2one();
helper_testChannelOneWriter(chan.in(), chan.out());
}
public void testNormalOne2AnyChannel() {
One2AnyChannel chan = Channel.one2any();
helper_testChannelOneWriter(chan.in(), chan.out());
}
public void testNormalAny2AnyChannel() {
Any2AnyChannel chan = Channel.any2any();
helper_testChannelOneWriter(chan.in(), chan.out());
}
public void helper_testIntChannelOneWriter(ChannelInputInt in,ChannelOutputInt out) {
/*
* This test checks that the reads and writes occur in the right order during an extended rendezvous
*
* Specifically , it checks that the extended action always occurs before the write has finished
*
* The event-recorder offers a read event, a write event and a terminate event
* The terminate event is only done (by the BarrierSyncer) once the other processes have finished
*
* The writer offers the write event *after* each write.
* The reader offers the single read event during each extended rendezvous.
*
* Therefore the events should be in lock-step:
* read,write,read,write...
*/
AltingBarrier[] terminateEvent = AltingBarrier.create(2);
AltingBarrier[] writeEvent = AltingBarrier.create(2);
AltingBarrier[] readEvent = AltingBarrier.create(2);
EventRecorder recorder;
new Parallel( new CSProcess[] {
recorder = new EventRecorder(new Guard[] {writeEvent[0],readEvent[0],terminateEvent[0]},2),
new Sequence(new CSProcess[] {
new Parallel( new CSProcess[] {
new WriterProcessInt(out,new int[100],writeEvent[1]),
new ExtendedReaderSyncInt(readEvent[1],in,100)
}),
new BarrierSyncer(terminateEvent[1])
})
}).run();
Guard[] expectedEvents = new Guard[201];
for (int i = 0;i < 100;i++) {
expectedEvents[i*2 + 0] = readEvent[0];
expectedEvents[i*2 + 1] = writeEvent[0];
}
expectedEvents[200] = terminateEvent[0];
assertArraysEqual(expectedEvents,recorder.getObservedEvents());
}
public void testNormalOne2OneChannelInt() {
One2OneChannelInt chan = Channel.one2oneInt();
helper_testIntChannelOneWriter(chan.in(), chan.out());
}
public void testNormalAny2OneChannelInt() {
Any2OneChannelInt chan = ChannelInt.any2one();
helper_testIntChannelOneWriter(chan.in(), chan.out());
}
public void testNormalOne2AnyChannelInt() {
One2AnyChannelInt chan = ChannelInt.one2any();
helper_testIntChannelOneWriter(chan.in(), chan.out());
}
public void testNormalAny2AnyChannelInt() {
Any2AnyChannelInt chan = ChannelInt.any2any();
helper_testIntChannelOneWriter(chan.in(), chan.out());
}
public void helper_testFIFOChannelOneWriter(ChannelInput in,ChannelOutput out) {
/*
* Since the reads and writes are fairly independent, this test instead checks
* that all the data flows in the correct write order without getting lost, even when the
* reader is slower than the writer
*
*/
AltingBarrier[] delayEvent = AltingBarrier.create(2);
ExtendedReaderSync reader;
Object[] values = new Object[100];
for (int i = 0;i < 100;i++) {
values[i] = new Object();
}
new Parallel( new CSProcess[] {
new DelaySyncer(delayEvent[0],5,100),
new WriterProcess(out,Arrays.asList(values),(AltingBarrier)null),
reader = new ExtendedReaderSync(delayEvent[1],in,100)
}).run();
assertArraysEqual(values,reader.getValuesRead());
}
public void testFIFO_One2OneChannel() {
One2OneChannel chan4 = Channel.one2one(new Buffer(4));
helper_testFIFOChannelOneWriter(chan4.in(), chan4.out());
One2OneChannel chan1 = Channel.one2one(new Buffer(1));
helper_testFIFOChannelOneWriter(chan1.in(), chan1.out());
}
public void testFIFO_Any2OneChannel() {
Any2OneChannel chan4 = Channel.any2one(new Buffer(4));
helper_testFIFOChannelOneWriter(chan4.in(), chan4.out());
Any2OneChannel chan1 = Channel.any2one(new Buffer(1));
helper_testFIFOChannelOneWriter(chan1.in(), chan1.out());
}
public void testFIFO_One2AnyChannel() {
One2AnyChannel chan4 = Channel.one2any(new Buffer(4));
helper_testFIFOChannelOneWriter(chan4.in(), chan4.out());
One2AnyChannel chan1 = Channel.one2any(new Buffer(1));
helper_testFIFOChannelOneWriter(chan1.in(), chan1.out());
}
public void testFIFO_Any2AnyChannel() {
Any2AnyChannel chan4 = Channel.any2any(new Buffer(4));
helper_testFIFOChannelOneWriter(chan4.in(), chan4.out());
Any2AnyChannel chan1 = Channel.any2any(new Buffer(1));
helper_testFIFOChannelOneWriter(chan1.in(), chan1.out());
}
//The given channel should be using a FIFO buffer (of any size >= 1)
public void helper_testFIFOChannelOneWriterInt(ChannelInputInt in,ChannelOutputInt out) {
/*
* Since the reads and writes are fairly independent, this test instead checks
* that all the data flows in the correct write order without getting lost, even when the
* reader is slower than the writer
*
*/
AltingBarrier[] delayEvent = AltingBarrier.create(2);
ExtendedReaderSyncInt reader;
int[] values = new int[100];
for (int i = 0;i < 100;i++) {
values[i] = i;
}
new Parallel( new CSProcess[] {
new DelaySyncer(delayEvent[0],5,100),
new WriterProcessInt(out,values,(AltingBarrier)null),
reader = new ExtendedReaderSyncInt(delayEvent[1],in,100)
}).run();
assertArraysEqual(values,reader.getValuesRead());
}
public void testFIFO_One2OneChannelInt() {
One2OneChannelInt chan4 = Channel.one2oneInt(new BufferInt(4));
helper_testFIFOChannelOneWriterInt(chan4.in(), chan4.out());
One2OneChannelInt chan1 = Channel.one2oneInt(new BufferInt(1));
helper_testFIFOChannelOneWriterInt(chan1.in(), chan1.out());
}
public void testFIFO_Any2OneChannelInt() {
Any2OneChannelInt chan4 = Channel.any2oneInt(new BufferInt(4));
helper_testFIFOChannelOneWriterInt(chan4.in(), chan4.out());
Any2OneChannelInt chan1 = Channel.any2oneInt(new BufferInt(1));
helper_testFIFOChannelOneWriterInt(chan1.in(), chan1.out());
}
public void testFIFO_One2AnyChannelInt() {
One2AnyChannelInt chan4 = Channel.one2anyInt(new BufferInt(4));
helper_testFIFOChannelOneWriterInt(chan4.in(), chan4.out());
One2AnyChannelInt chan1 = Channel.one2anyInt(new BufferInt(1));
helper_testFIFOChannelOneWriterInt(chan1.in(), chan1.out());
}
public void testFIFO_Any2AnyChannelInt() {
Any2AnyChannelInt chan4 = Channel.any2anyInt(new BufferInt(4));
helper_testFIFOChannelOneWriterInt(chan4.in(), chan4.out());
Any2AnyChannelInt chan1 = ChannelInt.any2anyInt(new BufferInt(1));
helper_testFIFOChannelOneWriterInt(chan1.in(), chan1.out());
}
public void testOverflowingFIFOOne2OneChannel() {
/*
* This test checks that the buffer does overflow if the reader is in the middle
* of an extended rendezvous
*
* The buffer is size 4. We let the writer send 4 times, then send our fifth item before syncing
* (the fifth should overflow and be lost) with the reader's sync during the 1st item.
* Repeat until 100 items have been sent (80 received)
*/
One2OneChannel chan = Channel.one2one(new OverFlowingBuffer(4));
AltingBarrier[] syncEvent = AltingBarrier.create(2);
Object[] sendValues = new Object[100];
Object[] expValues = new Object[80];
AltingBarrier[][] readerSync = new AltingBarrier[80][];
AltingBarrier[][] writerSync = new AltingBarrier[100][];
/*
* The syncs are confusing. We need this to happen:
*
* WRITE}
* WRITE}
* WRITE}begin READ
* WRITE}
* WRITE}
* end READ
* READ
* READ
* READ
* WRITE}
* WRITE}
* WRITE}begin READ
* WRITE}
* WRITE}
* end READ
* READ
* READ
* READ
*
* Therefore we use these syncs:
*
* WRITE}
* WRITE}
* WRITE}begin READ
* WRITE}
* WRITE}
* sync sync
* end READ
* READ
* READ
* READ
* sync sync
* WRITE}
* WRITE}
* WRITE}begin READ
* WRITE}
* WRITE}
* sync sync
* READ
* READ
* READ
* READ
* ...
* WRITE}
* WRITE}
* WRITE}begin READ
* WRITE}
* WRITE}
* sync sync
* READ
* READ
* READ
* READ
* sync sync
* DONE DONE
*
*/
for (int i = 0;i < 100;i++) {
sendValues[i] = new Object();
if (i % 5 == 4) {
writerSync[i] = new AltingBarrier[] {syncEvent[1] , syncEvent[1]};
} else {
writerSync[i] = new AltingBarrier[0];
}
}
for (int i = 0;i < 80;i++) {
if (i % 4 == 0) {
readerSync[i] = new AltingBarrier[] {syncEvent[0]};
} else if (i % 4 == 3) {
readerSync[i] = new AltingBarrier[] {null,syncEvent[0]};
} else {
readerSync[i] = new AltingBarrier[0];
}
expValues[i] = sendValues[((i / 4) * 5) + (i % 4)];
}
ExtendedReaderSync reader;
new Parallel( new CSProcess[] {
new WriterProcess(chan.out(),Arrays.asList(sendValues),writerSync),
reader = new ExtendedReaderSync(readerSync,chan.in(),80)
}).run();
assertArraysEqual(expValues,reader.getValuesRead());
}
public void testOverwritingOldestOne2OneChannel() {
//This buffer should over-write the oldest item
//If a write is made during an extended rendezvous that would over-write the
//most recent item, it should succeed but the item should not be removed by the
//reader at the end of the sync
//Imagine a buffer of size 3. If the writer writes 0, and then the reader starts an
//extended rendezvous, if the writer then writes 1,2,3 and then the reader finishes
//the rendezvous, the buffer should still contain 1,2,3.
//TODO work out what the expected behaviour is!
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/test/WriterProcessInt.java 0000644 0000000 0000000 00000003321 10660321725 020253 0 ustar package org.jcsp.test;
import java.security.InvalidParameterException;
import java.util.Arrays;
import org.jcsp.lang.AltingBarrier;
import org.jcsp.lang.CSProcess;
import org.jcsp.lang.ChannelOutputInt;
/**
* A process that writes out a list of values, synchronizing on the corresponding barrier after each.
*
*
* @author N.C.C. Brown
*
*/
public class WriterProcessInt implements CSProcess {
private ChannelOutputInt out;
private int[] values;
private AltingBarrier[][] events;
public WriterProcessInt(ChannelOutputInt out,int[] values,AltingBarrier[][] events) {
if (values.length != events.length) {
throw new InvalidParameterException("Values must be the same length as Events");
}
this.out = out;
this.values = values;
this.events = events;
}
public WriterProcessInt(ChannelOutputInt out,int[] values,AltingBarrier event) {
this.out = out;
this.values = values;
this.events = new AltingBarrier[values.length][];
Arrays.fill(this.events,new AltingBarrier[] {event});
}
public void run() {
for (int i = 0;i < events.length;i++) {
AltingBarrier[] barriers = events[i];
for (int j = 0;j < barriers.length;j++) {
AltingBarrier barrier = barriers[j];
if (barrier != null) {
barrier.mark();
}
}
}
for (int i = 0;i < values.length;i++) {
out.write(values[i]);
AltingBarrier[] barriers = events[i];
for (int j = 0;j < barriers.length;j++) {
AltingBarrier barrier = barriers[j];
if (barrier != null) {
barrier.sync();
}
}
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/test/BarrierSyncer.java 0000644 0000000 0000000 00000000762 10657566574 017570 0 ustar package org.jcsp.test;
import org.jcsp.lang.AltingBarrier;
import org.jcsp.lang.CSProcess;
/**
* A process that syncs on one alting barrier and finishes
*
*
* @author N.C.C. Brown
*
*/
public class BarrierSyncer implements CSProcess {
private AltingBarrier barrier;
public BarrierSyncer(AltingBarrier barrier) {
super();
this.barrier = barrier;
}
public void run() {
barrier.mark();
barrier.sync();
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/test/DelaySyncer.java 0000644 0000000 0000000 00000001243 10657566574 017233 0 ustar package org.jcsp.test;
import org.jcsp.lang.AltingBarrier;
import org.jcsp.lang.CSProcess;
import org.jcsp.lang.CSTimer;
public class DelaySyncer implements CSProcess {
AltingBarrier barrier;
CSTimer timer;
int milliSeconds;
int iterations;
public DelaySyncer(AltingBarrier barrier, int milliSeconds,int iterations) {
this.barrier = barrier;
timer = new CSTimer();
this.milliSeconds = milliSeconds;
this.iterations = iterations;
}
public void run() {
barrier.mark();
for (int i = 0;i < iterations;i++) {
timer.sleep(milliSeconds);
barrier.sync();
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/test/EventRecorder.java 0000644 0000000 0000000 00000002203 10657566574 017555 0 ustar package org.jcsp.test;
import java.util.LinkedList;
import java.util.List;
import org.jcsp.lang.Alternative;
import org.jcsp.lang.CSProcess;
import org.jcsp.lang.Guard;
/**
* A class that listens out for many guards, and records the order in which they occur
*
* Note: do not pass in channel guards, as the process will not perform the necessary
* input after the guard is selected
*
* @author nccb
*
*/
class EventRecorder implements CSProcess {
private Guard originalGuards[];
private int stopOnGuard;
private List observedGuards = new LinkedList();
public EventRecorder(Guard[] guards, int terminateEvent) {
originalGuards = guards;
stopOnGuard = terminateEvent;
}
public Guard[] getObservedEvents() {
return (Guard[])observedGuards.toArray(new Guard[observedGuards.size()]);
}
public void run() {
Alternative alt = new Alternative(originalGuards);
int selected;
do {
selected = alt.select();
observedGuards.add(originalGuards[selected]);
} while (selected != stopOnGuard);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/ 0000755 0000000 0000000 00000000000 11410045055 014112 5 ustar jcsp-1.1-rc4.orig/src/org/jcsp/util/ChannelDataStore.java 0000644 0000000 0000000 00000017435 11105701167 020152 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util;
/**
* This is the interface for object channel plug-ins that define their buffering
* characteristics.
*
* Channels are constructed using the static construction methods of {@link org.jcsp.lang.Channel}.
* By default, channels will be constructed with standard CSP semantics –
* no buffering and full synchronisation between reading and writing processes
* (e.g. {@link org.jcsp.lang.Channel#one2one()}).
* To construct buffered channels, plug in the appropriate ChannelDataStore
* (e.g. {@link org.jcsp.lang.Channel#one2one(org.jcsp.util.ChannelDataStore)}).
*
* Note: JCSP users should not normally need to define their own implementations
* of this interface.
* However, implementors may assume that ChannelDataStore methods
* are always invoked (by the various channel classes within org.org.jcsp.lang)
* in a thread-safe way – i.e. that there will be no race hazards between invocations
* of {@link #get() get} and {@link #put(java.lang.Object) put}).
* They may also assume that the documented pre-conditions for invoking the get
* and put methods will be met.
* ChannelDataStore is only intended for defining the behaviour of buffers –
* it is not intended for any other purpose (e.g. for data-processing or filtering channels).
*
*
* @see org.jcsp.util.ZeroBuffer
* @see org.jcsp.util.Buffer
* @see org.jcsp.util.OverWriteOldestBuffer
* @see org.jcsp.util.OverWritingBuffer
* @see org.jcsp.util.OverFlowingBuffer
* @see org.jcsp.util.InfiniteBuffer
* @see org.jcsp.lang.Channel
*
* @author P.D. Austin
*/
public interface ChannelDataStore extends Cloneable
{
/** Indicates that the ChannelDataStore is empty
* -- it can accept only a put.
*/
public final static int EMPTY = 0;
/**
* Indicates that the ChannelDataStore is neither empty nor full
* -- it can accept either a put or a get call.
*/
public final static int NONEMPTYFULL = 1;
/** Indicates that the ChannelDataStore is full
* -- it can accept only a get.
*/
public final static int FULL = 2;
/**
* Returns the current state of the ChannelDataStore.
*
* @return the current state of the ChannelDataStore (EMPTY,
* NONEMPTYFULL or FULL)
*/
public abstract int getState();
/**
* Puts a new Object into the ChannelDataStore.
*
* Pre-condition: getState must not currently return FULL.
*
* @param value the Object to put into the ChannelDataStore
*/
public abstract void put(Object value);
/**
* Returns an Object from the ChannelDataStore.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return an Object from the ChannelDataStore
*/
public abstract Object get();
/**
* Begins an extended read on the buffer, returning the data for the extended read.
*
* Pre-condition: getState must not currently return EMPTY.
*
* The exact behaviour of this method depends on your buffer. When a process performs an
* extended rendezvous on a buffered channel, it will first call this method, then the
* {@link #endGet} method.
*
* A FIFO buffer would implement this method as returning the value from the front of the buffer
* and the next call would remove the value. An overflowing buffer would do the same.
*
* However, for an overwriting buffer it is more complex. Refer to the documentation for
* {@link OverWritingBuffer#startGet} and {@link OverWriteOldestBuffer#startGet}
* for details
*
* @return The object to be read from the channel at the beginning of the extended rendezvous
*
* @see #endGet
*/
public abstract Object startGet();
/**
* Ends an extended read on the buffer.
*
* The channels guarantee that this method will be called exactly once after each
* {@link #startGet
* Note: Only the size and structure of the ChannelDataStore should
* be cloned, not any stored data.
*
* @return the cloned instance of this ChannelDataStore.
*/
public abstract Object clone();
/**
* Deletes all items in the buffer, leaving it empty.
*
*/
public abstract void removeAll();
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/Buffer.java 0000644 0000000 0000000 00000015025 11105701167 016175 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util;
import java.io.Serializable;
/**
* This is used to create a buffered object channel that never loses data.
*
* The getState method returns EMPTY, NONEMPTYFULL or
* FULL according to the state of the buffer.
*
* @see org.jcsp.util.ZeroBuffer
* @see org.jcsp.util.OverWriteOldestBuffer
* @see org.jcsp.util.OverWritingBuffer
* @see org.jcsp.util.OverFlowingBuffer
* @see org.jcsp.util.InfiniteBuffer
* @see org.jcsp.lang.Channel
*
* @author P.D. Austin
*/
public class Buffer implements ChannelDataStore, Serializable
{
/** The storage for the buffered Objects */
private final Object[] buffer;
/** The number of Objects stored in the Buffer */
private int counter = 0;
/** The index of the oldest element (when counter > 0) */
private int firstIndex = 0;
/** The index of the next free element (when counter < buffer.length) */
private int lastIndex = 0;
/**
* Construct a new Buffer with the specified size.
*
* @param size the number of Objects the Buffer can store.
* @throws BufferSizeError if size is negative. Note: no action
* should be taken to try/catch this exception
* - application code generating it is in error and needs correcting.
*/
public Buffer(int size)
{
if (size < 0)
throw new BufferSizeError("\n*** Attempt to create a buffered channel with negative capacity");
buffer = new Object[size + 1]; // the extra one is a subtlety needed by
// the current channel algorithms.
}
/**
* Returns the oldest Object from the Buffer and removes it.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return the oldest Object from the Buffer
*/
public Object get()
{
Object value = buffer[firstIndex];
buffer[firstIndex] = null;
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
return value;
}
/**
* Returns the oldest object from the buffer but does not remove it.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return the oldest Object from the Buffer
*/
public Object startGet()
{
return buffer[firstIndex];
}
/**
* Removes the oldest object from the buffer.
*/
public void endGet()
{
buffer[firstIndex] = null;
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
}
/**
* Puts a new Object into the Buffer.
*
* Pre-condition: getState must not currently return FULL.
*
* @param value the Object to put into the Buffer
*/
public void put(Object value)
{
buffer[lastIndex] = value;
lastIndex = (lastIndex + 1) % buffer.length;
counter++;
}
/**
* Returns the current state of the Buffer.
*
* @return the current state of the Buffer (EMPTY,
* NONEMPTYFULL or FULL)
*/
public int getState()
{
if (counter == 0)
return EMPTY;
else if (counter == buffer.length)
return FULL;
else
return NONEMPTYFULL;
}
/**
* Returns a new (and EMPTY) Buffer with the same
* creation parameters as this one.
*
* Note: Only the size and structure of the Buffer is
* cloned, not any stored data.
*
* @return the cloned instance of this Buffer
*/
public Object clone()
{
return new Buffer(buffer.length - 1);
}
public void removeAll()
{
counter = 0;
firstIndex = 0;
lastIndex = 0;
for (int i = 0;i < buffer.length;i++) {
//Null the objects so they can be garbage collected:
buffer[i] = null;
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/ 0000755 0000000 0000000 00000000000 11410045055 015377 5 ustar jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredSharedChannelOutput.java 0000644 0000000 0000000 00000004735 11105701167 023656 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.SharedChannelOutput;
/**
* Interface for an output channel end that supports filtering operations and can be shared by multiple
* concurrent processes.
*
* @see org.jcsp.lang.SharedChannelOutput
* @see org.jcsp.util.filter.WriteFiltered
*
* @author Quickstone Technologies Limited
*/
public interface FilteredSharedChannelOutput
extends SharedChannelOutput, FilteredChannelOutput
{
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/ReadFiltered.java 0000644 0000000 0000000 00000012104 11105701167 020576 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
/**
* Interface for a channel end supporting read filtering operations. A channel end that implements this
* interface can have instances of the Multiple filters can be installed and referenced by a zero-based index to specify a specific
* ordering. If multiple filters are installed, they are applied in order of increasing index. For example: The
This defines filtering channels that can apply transformations to objects
as they are read and/or written.
A completely filtered channel can be created using the
Only a Interface for a channel end supporting write filtering operations. A channel end that implements this
* interface can have instances of the Multiple filters can be installed and referenced by a zero-based index to specify a specific
* ordering. If multiple filters are installed, they are applied in order of increasing index. For example: The This class is used for constructing Filtered Channels.
* The objects returned by instances of this class will implement
* the appropriate Filtered Channel interfaces even though the return
* types are not declared as being Filtered Channels. This is so
* that this class can implement the A set of read and/or write filters can be specified so that all of the channels created by this
* factory will have the same buffering properties. All channels constructed with this Factory instance will have the
* specified Either of the parameters may be Factory for creating filtered channel ends around existing channel ends. An instance of this class can be created and used, or alternatively the static factory
*
By default, channels are zero-buffered and fully synchronised: both a reader
and a writer have to be ready for a communication to proceed. Whoever
gets to the communication point first has to wait for the other party.
This package provides a variety of classes conforming
to the {@link org.jcsp.util.ChannelDataStore} interface.
These classes can be used as plug-ins to the static
{@link org.jcsp.lang.Channel} manufacturing methods to customise their semantics.
Classes are provided for blocking FIFO buffers,
overwriting buffers (losing either the newest or oldest data) and
infinite (within the realms of your virtual memory) buffers.
Users may write and use their own implementations of
the {@link org.jcsp.util.ChannelDataStore} interface, but
great care must be taken to specify its semantics.
It should not normally be necessary to do this.
jcsp-1.1-rc4.orig/src/org/jcsp/util/OverWriteOldestBuffer.java 0000644 0000000 0000000 00000020713 11105701167 021217 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util;
import java.io.Serializable;
/**
* This is used to create a buffered object channel that always accepts input,
* overwriting its oldest data if full.
*
* The getState method returns EMPTY or NONEMPTYFULL, but
* never FULL.
*
* @see org.jcsp.util.ZeroBuffer
* @see org.jcsp.util.Buffer
* @see org.jcsp.util.OverWritingBuffer
* @see org.jcsp.util.OverFlowingBuffer
* @see org.jcsp.util.InfiniteBuffer
* @see org.jcsp.lang.Channel
*
* @author P.D. Austin
*/
public class OverWriteOldestBuffer implements ChannelDataStore, Serializable
{
/** The storage for the buffered Objects */
private final Object[] buffer;
/** The number of Objects stored in the Buffer */
private int counter = 0;
/** The index of the oldest element (when counter > 0) */
private int firstIndex = 0;
/** The index of the next free element (when counter < buffer.length) */
private int lastIndex = 0;
private boolean valueWrittenWhileFull = false;
/**
* Construct a new OverWriteOldestBuffer with the specified size.
*
* @param size the number of Objects the OverWriteOldestBuffer can store.
* @throws BufferSizeError if size is zero or negative. Note: no action
* should be taken to try/catch this exception
* - application code generating it is in error and needs correcting.
*/
public OverWriteOldestBuffer(int size)
{
if (size <= 0)
throw new BufferSizeError
("\n*** Attempt to create an overwriting buffered channel with negative or zero capacity");
buffer = new Object[size];
}
/**
* Returns the oldest Object from the OverWriteOldestBuffer and removes it.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return the oldest Object from the OverWriteOldestBuffer
*/
public Object get()
{
Object value = buffer[firstIndex];
buffer[firstIndex] = null;
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
return value;
}
/**
* Begins an extended rendezvous by the reader.
* The semantics of an extended rendezvous on an overwrite-oldest buffer are slightly
* complicated, but hopefully intuitive.
*
* When a reader begins an extended rendezvous, the oldest value is returned from the buffer
* (as it would be for a call to {@link #get()}). While an extended rendezvous is ongoing, the
* writer may (repeatedly) write to the buffer, without ever blocking.
*
* When the reader finishes an extended rendezvous, the following options are possible:
*
* If OverWriteOldestBuffer is full, the oldest item
* left unread in the buffer will be overwritten.
*
* @param value the Object to put into the OverWriteOldestBuffer
*/
public void put(Object value)
{
if (counter == buffer.length)
{
firstIndex = (firstIndex + 1) % buffer.length;
valueWrittenWhileFull = true;
}
else
{
counter++;
}
buffer[lastIndex] = value;
lastIndex = (lastIndex + 1) % buffer.length;
}
/**
* Returns the current state of the OverWriteOldestBuffer.
*
* @return the current state of the OverWriteOldestBuffer (EMPTY or
* NONEMPTYFULL)
*/
public int getState()
{
if (counter == 0)
return EMPTY;
else
return NONEMPTYFULL;
}
/**
* Returns a new (and EMPTY) OverWriteOldestBuffer with the same
* creation parameters as this one.
*
* Note: Only the size and structure of the OverWriteOldestBuffer is
* cloned, not any stored data.
*
* @return the cloned instance of this OverWriteOldestBuffer.
*/
public Object clone()
{
return new OverWriteOldestBuffer(buffer.length);
}
public void removeAll()
{
counter = 0;
firstIndex = 0;
lastIndex = 0;
for (int i = 0;i < buffer.length;i++) {
//Null the objects so they can be garbage collected:
buffer[i] = null;
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/ints/ 0000755 0000000 0000000 00000000000 11410045055 015067 5 ustar jcsp-1.1-rc4.orig/src/org/jcsp/util/ints/package.html 0000644 0000000 0000000 00000001772 11077376055 017377 0 ustar
By default, channels are zero-buffered and fully synchronised: both a reader
and a writer have to be ready for a communication to proceed. Whoever
gets to the communication point first has to wait for the other party.
This package provides a variety of classes conforming
to the {@link org.jcsp.util.ints.ChannelDataStoreInt} interface.
These classes can be used as plug-ins to the static
{@link org.jcsp.lang.Channel} manufacturing methods to customise their semantics.
Classes are provided for blocking FIFO buffers,
overwriting buffers (losing either the newest or oldest data) and
infinite (within the realms of your virtual memory) buffers.
Users may write and use their own implementations of
the {@link org.jcsp.util.ints.ChannelDataStoreInt} interface, but
great care must be taken to specify its semantics.
It should not normally be necessary to do this.
jcsp-1.1-rc4.orig/src/org/jcsp/util/ints/OverWriteOldestBufferInt.java 0000644 0000000 0000000 00000020450 11105701167 022645 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.ints;
import java.io.Serializable;
/**
* This is used to create a buffered integer channel that always accepts input,
* overwriting its oldest data if full.
*
* The getState method returns EMPTY or NONEMPTYFULL, but
* never FULL.
*
* @see org.jcsp.util.ints.ZeroBufferInt
* @see org.jcsp.util.ints.BufferInt
* @see org.jcsp.util.ints.OverWritingBufferInt
* @see org.jcsp.util.ints.OverFlowingBufferInt
* @see org.jcsp.util.ints.InfiniteBufferInt
* @see org.jcsp.lang.ChannelInt
*
* @author P.D. Austin
*/
//}}}
public class OverWriteOldestBufferInt implements ChannelDataStoreInt, Serializable
{
/** The storage for the buffered ints */
private final int[] buffer;
/** The number of ints stored in the Buffer */
private int counter = 0;
/** The index of the oldest element (when counter > 0) */
private int firstIndex = 0;
/** The index of the next free element (when counter < buffer.length) */
private int lastIndex = 0;
private boolean valueWrittenWhileFull = false;
/**
* Construct a new OverWriteOldestBufferInt with the specified size.
*
* @param size the number of ints the OverWriteOldestBufferInt can store.
* @throws BufferIntSizeError if size is zero or negative. Note: no action
* should be taken to try/catch this exception
* - application code generating it is in error and needs correcting.
*/
public OverWriteOldestBufferInt(int size)
{
if (size <= 0)
throw new BufferIntSizeError
("\n*** Attempt to create an overwriting buffered channel with negative or zero capacity");
buffer = new int[size];
}
/**
* Returns the oldest int from the OverWriteOldestBufferInt and removes it.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return the oldest int from the OverWriteOldestBufferInt
*/
public int get()
{
int value = buffer[firstIndex];
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
return value;
}
/**
* Begins an extended rendezvous by the reader.
*
* The semantics of an extended rendezvous on an overwrite-oldest buffer are slightly
* complicated, but hopefully intuitive.
*
* When a reader begins an extended rendezvous, the oldest value is returned from the buffer
* (as it would be for a call to {@link #get()}). While an extended rendezvous is ongoing, the
* writer may (repeatedly) write to the buffer, without ever blocking.
*
* When the reader finishes an extended rendezvous, the following options are possible:
*
* If OverWriteOldestBufferInt is full, the oldest item
* left unread in the buffer will be overwritten.
*
* @param value the int to put into the OverWriteOldestBufferInt
*/
public void put(int value)
{
if (counter == buffer.length)
{
firstIndex = (firstIndex + 1) % buffer.length;
valueWrittenWhileFull = true;
}
else
{
counter++;
}
buffer[lastIndex] = value;
lastIndex = (lastIndex + 1) % buffer.length;
}
/**
* Returns the current state of the OverWriteOldestBufferInt.
*
* @return the current state of the OverWriteOldestBufferInt (EMPTY or
* NONEMPTYFULL)
*/
public int getState()
{
if (counter == 0)
return EMPTY;
else
return NONEMPTYFULL;
}
/**
* Returns a new (and EMPTY) OverWriteOldestBufferInt with the same
* creation parameters as this one.
*
* Note: Only the size and structure of the OverWriteOldestBufferInt is
* cloned, not any stored data.
*
* @return the cloned instance of this OverWriteOldestBufferInt.
*/
public Object clone()
{
return new OverWriteOldestBufferInt(buffer.length);
}
public void removeAll() {
counter = 0;
firstIndex = 0;
lastIndex = 0;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/ints/BufferInt.java 0000644 0000000 0000000 00000014315 11105701167 017626 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.ints;
import java.io.Serializable;
/**
* This is used to create a buffered integer channel that never loses data.
*
* The getState method returns EMPTY, NONEMPTYFULL or
* FULL according to the state of the buffer.
*
* @see org.jcsp.util.ints.ZeroBufferInt
* @see org.jcsp.util.ints.OverWriteOldestBufferInt
* @see org.jcsp.util.ints.OverWritingBufferInt
* @see org.jcsp.util.ints.OverFlowingBufferInt
* @see org.jcsp.util.ints.InfiniteBufferInt
* @see org.jcsp.lang.ChannelInt
*
* @author P.D. Austin
*/
public class BufferInt implements ChannelDataStoreInt, Serializable
{
/** The storage for the buffered ints */
private final int[] buffer;
/** The number of ints stored in the BufferInt */
private int counter = 0;
/** The index of the oldest element (when counter > 0) */
private int firstIndex = 0;
/** The index of the next free element (when counter < buffer.length) */
private int lastIndex = 0;
/**
* Construct a new BufferInt with the specified size.
*
* @param size the number of ints the BufferInt can store.
* @throws BufferIntSizeError if size is negative. Note: no action
* should be taken to try/catch this exception
* - application code generating it is in error and needs correcting.
*/
public BufferInt (int size) {
if (size < 0) {
throw new BufferIntSizeError (
"\n*** Attempt to create a buffered channel with negative capacity"
);
}
buffer = new int[size + 1]; // the extra one is a subtlety needed by
// the current channel algorithms.
}
/**
* Returns the oldest int from the BufferInt and removes it.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return the oldest int from the BufferInt
*/
public int get () {
int value = buffer[firstIndex];
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
return value;
}
/**
* Returns the oldest integer from the buffer but does not remove it.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return the oldest int from the Buffer
*/
public int startGet()
{
return buffer[firstIndex];
}
/**
* Removes the oldest integer from the buffer.
*/
public void endGet()
{
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
}
/**
* Puts a new int into the BufferInt.
*
* Pre-condition: getState must not currently return FULL.
*
* @param value the int to put into the BufferInt
*/
public void put (int value) {
buffer[lastIndex] = value;
lastIndex = (lastIndex + 1) % buffer.length;
counter++;
}
/**
* Returns the current state of the BufferInt.
*
* @return the current state of the BufferInt (EMPTY,
* NONEMPTYFULL or FULL)
*/
public int getState () {
if (counter == 0) {
return EMPTY;
}
else if (counter == buffer.length) {
return FULL;
} else {
return NONEMPTYFULL;
}
}
/**
* Returns a new (and EMPTY) BufferInt with the same
* creation parameters as this one.
*
* Note: Only the size and structure of the BufferInt is
* cloned, not any stored data.
*
* @return the cloned instance of this BufferInt
*/
public Object clone () {
return new BufferInt (buffer.length - 1);
}
public void removeAll() {
counter = 0;
firstIndex = 0;
lastIndex = 0;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/ints/BufferIntSizeError.java 0000644 0000000 0000000 00000007332 11105701167 021474 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.ints;
/**
* This is thrown if an attempt is made to create some variety of buffered channel
* with a zero or negative sized buffer.
*
*
* The getState method returns EMPTY or NONEMPTYFULL, but
* never FULL.
*
* An initial size for the buffer can be specified during construction.
*
* @see org.jcsp.util.ints.ZeroBufferInt
* @see org.jcsp.util.ints.BufferInt
* @see org.jcsp.util.ints.OverWriteOldestBufferInt
* @see org.jcsp.util.ints.OverWritingBufferInt
* @see org.jcsp.util.ints.OverFlowingBufferInt
* @see org.jcsp.lang.ChannelInt
*
* @author P.D. Austin
*/
//}}}
public class InfiniteBufferInt implements ChannelDataStoreInt, Serializable
{
/** The default size of the buffer */
private static final int DEFAULT_SIZE = 8;
/** The initial size of the buffer */
private int initialSize;
/** The storage for the buffered ints */
private int[] buffer;
/** The number of ints stored in the InfiniteBufferInt */
private int counter = 0;
/** The index of the oldest element (when counter > 0) */
private int firstIndex = 0;
/** The index of the next free element (when counter < buffer.length) */
private int lastIndex = 0;
/**
* Construct a new InfiniteBufferInt with the default size (of 8).
*/
public InfiniteBufferInt()
{
this(DEFAULT_SIZE);
}
/**
* Construct a new InfiniteBufferInt with the specified initial size.
*
* @param initialSize the number of ints
* the InfiniteBufferInt can initially store.
* @throws BufferIntSizeError if initialSize is zero or negative. Note: no action
* should be taken to try/catch this exception
* - application code generating it is in error and needs correcting.
*/
public InfiniteBufferInt(int initialSize)
{
if (initialSize <= 0)
throw new BufferIntSizeError
("\n*** Attempt to create a buffered channel with an initially negative or zero capacity");
this.initialSize = initialSize;
buffer = new int[initialSize];
}
/**
* Returns the oldest int from the InfiniteBufferInt and removes it.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return the oldest int from the InfiniteBufferInt
*/
public int get()
{
int value = buffer[firstIndex];
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
return value;
}
/**
* Returns the oldest integer from the buffer but does not remove it.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return the oldest int from the Buffer
*/
public int startGet()
{
return buffer[firstIndex];
}
/**
* Removes the oldest integer from the buffer.
*/
public void endGet()
{
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
}
/**
* Puts a new int into the InfiniteBufferInt.
*
* Implementation note: if InfiniteBufferInt is full, a new internal
* buffer with double the capacity is constructed and the old data copied across.
*
* @param value the int to put into the InfiniteBufferInt
*/
public void put(int value)
{
if (counter == buffer.length)
{
int[] temp = buffer;
buffer = new int[buffer.length * 2];
System.arraycopy(temp, firstIndex, buffer, 0, temp.length - firstIndex);
System.arraycopy(temp, 0, buffer, temp.length - firstIndex, firstIndex);
firstIndex = 0;
lastIndex = temp.length;
}
buffer[lastIndex] = value;
lastIndex = (lastIndex + 1) % buffer.length;
counter++;
}
/**
* Returns the current state of the InfiniteBufferInt.
*
* @return the current state of the InfiniteBufferInt (EMPTY or
* NONEMPTYFULL)
*/
public int getState()
{
if (counter == 0)
return EMPTY;
else
return NONEMPTYFULL;
}
/**
* Returns a new (and EMPTY) InfiniteBufferInt with the same
* creation parameters as this one.
*
* Note: Only the initial size and structure of the InfiniteBufferInt
* is cloned, not any stored data.
*
* @return the cloned instance of this InfiniteBufferInt.
*/
public Object clone()
{
return new InfiniteBufferInt(initialSize);
}
public void removeAll() {
counter = 0;
firstIndex = 0;
lastIndex = 0;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/ints/ZeroBufferInt.java 0000644 0000000 0000000 00000012414 11105701167 020464 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.ints;
import java.io.Serializable;
/**
* This is used to create a zero-buffered integer channel that never loses data.
*
* The getState method will return FULL if there is an output
* waiting on the channel and EMPTY if there is not.
*
* @see org.jcsp.util.ints.BufferInt
* @see org.jcsp.util.ints.OverWriteOldestBufferInt
* @see org.jcsp.util.ints.OverWritingBufferInt
* @see org.jcsp.util.ints.OverFlowingBufferInt
* @see org.jcsp.util.ints.InfiniteBufferInt
* @see org.jcsp.lang.ChannelInt
*
* @author P.D. Austin
*/
//}}}
public class ZeroBufferInt implements ChannelDataStoreInt, Serializable
{
/** The current state */
private int state = EMPTY;
/** The int */
private int value;
/**
* Returns the int from the ZeroBufferInt.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return the int from the ZeroBufferInt
*/
public int get()
{
state = EMPTY;
int o = value;
return o;
}
/**
* Begins an extended rendezvous - simply returns the next integer in the buffer.
* This function does not remove the integer.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return The integer in the buffer.
*/
public int startGet() {
return value;
}
/**
* Ends the extended rendezvous by clearing the buffer.
*/
public void endGet() {
state = EMPTY;
}
/**
* Puts a new int into the ZeroBufferInt.
*
* Pre-condition: getState must not currently return FULL.
*
* @param value the int to put into the ZeroBufferInt
*/
public void put(int value)
{
state = FULL;
this.value = value;
}
/**
* Returns the current state of the ZeroBufferInt.
*
* @return the current state of the ZeroBufferInt (EMPTY
* or FULL)
*/
public int getState()
{
return state;
}
/**
* Returns a new (and EMPTY) ZeroBufferInt with the same
* creation parameters as this one.
*
* Note: Only the size and structure of the ZeroBufferInt is
* cloned, not any stored data.
*
* @return the cloned instance of this ZeroBufferInt.
*/
public Object clone()
{
return new ZeroBufferInt();
}
public void removeAll()
{
state = EMPTY;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/ints/OverFlowingBufferInt.java 0000644 0000000 0000000 00000015172 11105701167 022012 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.ints;
import java.io.Serializable;
/**
* This is used to create a buffered integer channel that always accepts input,
* discarding its last entered data if full.
*
* The getState method returns EMPTY or NONEMPTYFULL, but
* never FULL.
*
* @see org.jcsp.util.ints.ZeroBufferInt
* @see org.jcsp.util.ints.BufferInt
* @see org.jcsp.util.ints.OverWriteOldestBufferInt
* @see org.jcsp.util.ints.OverWritingBufferInt
* @see org.jcsp.util.ints.InfiniteBufferInt
* @see org.jcsp.lang.ChannelInt
*
* @author P.D. Austin
*/
public class OverFlowingBufferInt implements ChannelDataStoreInt, Serializable
{
/** The storage for the buffered ints */
private final int[] buffer;
/** The number of ints stored in the Buffer */
private int counter = 0;
/** The index of the oldest element (when counter > 0) */
private int firstIndex = 0;
/** The index of the next free element (when counter < buffer.length) */
private int lastIndex = 0;
/**
* Construct a new OverFlowingBufferInt with the specified size.
*
* @param size the number of ints the OverFlowingBufferInt can store.
* @throws BufferIntSizeError if size is zero or negative. Note: no action
* should be taken to try/catch this exception
* - application code generating it is in error and needs correcting.
*/
public OverFlowingBufferInt(int size)
{
if (size <= 0)
throw new BufferIntSizeError
("\n*** Attempt to create an overflowing buffered channel with negative or zero capacity");
buffer = new int[size];
}
/**
* Returns the oldest int from the OverFlowingBufferInt and removes it.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return the oldest int from the OverFlowingBufferInt
*/
public int get()
{
int value = buffer[firstIndex];
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
return value;
}
/**
* Returns the oldest integer from the buffer but does not remove it.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return the oldest int from the Buffer
*/
public int startGet()
{
return buffer[firstIndex];
}
/**
* Removes the oldest integer from the buffer.
*/
public void endGet()
{
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
}
/**
* Puts a new int into the OverFlowingBufferInt.
*
* If OverFlowingBufferInt is full, the item is discarded.
*
* @param value the int to put into the OverFlowingBufferInt
*/
public void put(int value)
{
if (counter < buffer.length)
{
buffer[lastIndex] = value;
lastIndex = (lastIndex + 1) % buffer.length;
counter++;
}
}
/**
* Returns the current state of the OverFlowingBufferInt.
*
* @return the current state of the OverFlowingBufferInt (EMPTY or
* NONEMPTYFULL)
*/
public int getState()
{
if (counter == 0)
return EMPTY;
else
return NONEMPTYFULL;
}
/**
* Returns a new (and EMPTY) OverFlowingBufferInt with the same
* creation parameters as this one.
*
* Note: Only the size and structure of the OverFlowingBufferInt is
* cloned, not any stored data.
*
* @return the cloned instance of this OverFlowingBufferInt.
*/
public Object clone()
{
return new OverFlowingBufferInt(buffer.length);
}
public void removeAll() {
counter = 0;
firstIndex = 0;
lastIndex = 0;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/ints/OverWritingBufferInt.java 0000644 0000000 0000000 00000017437 11105701167 022036 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.ints;
import java.io.Serializable;
import org.jcsp.util.OverWriteOldestBuffer;
//{{{ javadoc
/**
* This is used to create a buffered integer channel that always accepts input,
* overwriting its last entered data if full.
*
* The getState method returns EMPTY or NONEMPTYFULL, but
* never FULL.
*
* @see org.jcsp.util.ints.ZeroBufferInt
* @see org.jcsp.util.ints.BufferInt
* @see org.jcsp.util.ints.OverWriteOldestBufferInt
* @see org.jcsp.util.ints.OverFlowingBufferInt
* @see org.jcsp.util.ints.InfiniteBufferInt
* @see org.jcsp.lang.ChannelInt
*
* @author P.D. Austin
*/
//}}}
public class OverWritingBufferInt implements ChannelDataStoreInt, Serializable
{
/** The storage for the buffered ints */
private final int[] buffer;
/** The number of ints stored in the Buffer */
private int counter = 0;
/** The index of the oldest element (when counter > 0) */
private int firstIndex = 0;
/** The index of the next free element (when counter < buffer.length) */
private int lastIndex = 0;
private boolean valueWrittenWhileFull = false;
/**
* Construct a new OverWritingBufferInt with the specified size.
*
* @param size the number of ints the OverWritingBufferInt can store.
* @throws BufferIntSizeError if size is zero or negative. Note: no action
* should be taken to try/catch this exception
* - application code generating it is in error and needs correcting.
*/
public OverWritingBufferInt(int size)
{
if (size <= 0)
throw new BufferIntSizeError
("\n*** Attempt to create an overwriting buffered channel with negative or zero capacity");
buffer = new int[size];
}
/**
* Returns the oldest int from the OverWritingBufferInt and removes it.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return the oldest int from the OverWritingBufferInt
*/
public int get()
{
int value = buffer[firstIndex];
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
return value;
}
/**
* Begins an extended rendezvous by the reader.
*
* The semantics of an extended rendezvous on an overwrite-newest buffer are slightly
* complicated, but hopefully intuitive.
*
* If the buffer is of size 2 or larger, the semantics are as follows.
* Beginning an extended rendezvous will return the oldest value in the buffer, but not remove it.
* If the writer writes to the buffer during the rendezvous, it will grow the buffer and end up
* overwriting the newest value as normal. At the end of the extended rendezvous, the oldest
* value is removed.
*
* If the buffer is of size 1, the semantics are identical to those of an {@link OverWriteOldestBuffer}.
* For a complete description, refer to the documentation for the {@link OverWriteOldestBuffer#startGet()} method.
*
* @return The oldest value in the buffer at this time
*/
public int startGet()
{
valueWrittenWhileFull = false;
return buffer[firstIndex];
}
/**
* See {@link #startGet()} for a description of the semantics of this method.
*/
public void endGet()
{
if (false == valueWrittenWhileFull || buffer.length != 1) {
//Our data hasn't been over-written so remove it:
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
}
}
/**
* Puts a new int into the OverWritingBufferInt.
*
* If OverWritingBufferInt is full, the last item
* previously put into the buffer will be overwritten.
*
* @param value the int to put into the OverWritingBufferInt
*/
public void put(int value)
{
if (counter == buffer.length)
{
buffer[(lastIndex - 1 + buffer.length) % buffer.length] = value;
valueWrittenWhileFull = true;
}
else
{
buffer[lastIndex] = value;
lastIndex = (lastIndex + 1) % buffer.length;
counter++;
}
}
/**
* Returns the current state of the OverWritingBufferInt.
*
* @return the current state of the OverWritingBufferInt (EMPTY or
* NONEMPTYFULL)
*/
public int getState()
{
if (counter == 0)
return EMPTY;
else
return NONEMPTYFULL;
}
/**
* Returns a new (and EMPTY) OverWritingBufferInt with the same
* creation parameters as this one.
*
* Note: Only the size and structure of the OverWritingBufferInt is
* cloned, not any stored data.
*
* @return the cloned instance of this OverWritingBufferInt.
*/
public Object clone()
{
return new OverWritingBufferInt(buffer.length);
}
public void removeAll() {
counter = 0;
firstIndex = 0;
lastIndex = 0;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/ints/ChannelDataStoreInt.java 0000644 0000000 0000000 00000015726 11105701167 021603 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.ints;
import org.jcsp.util.OverWriteOldestBuffer;
import org.jcsp.util.OverWritingBuffer;
/**
* This is the interface for integer channel plug-ins that define their buffering
* characteristics.
*
* This enables that logic to be varied by creating channels specifying
* a particular implementation of this interface. This reduces the number of
* classes that would otherwise need to be defined. The default channel
* constructor (with no parameters) uses the ZeroBuffer implementation,
* which gives the standard CSP semantics -- no buffering and full synchronisation
* between reading and writing processes.
* See the static construction methods of {@link org.jcsp.lang.Channel}
* ({@link org.jcsp.lang.Channel#one2oneInt(org.jcsp.util.ints.ChannelDataStoreInt)} etc.).
*
* Note: instances of ChannelDataStoreInt implementations are
* used by the various channel classes within org.jcsp.lang
* in a thread-safe way. They are not intended for any other purpose.
* Developers of new ChannelDataStoreInt implementations,
* therefore, do not need to worry about thread safety (e.g. by making its
* methods synchronized). Also, developers can assume that
* the documented pre-conditions for invoking the get
* and put methods will be met.
*
* @see org.jcsp.util.ints.ZeroBufferInt
* @see org.jcsp.util.ints.BufferInt
* @see org.jcsp.util.ints.OverWriteOldestBufferInt
* @see org.jcsp.util.ints.OverWritingBufferInt
* @see org.jcsp.util.ints.OverFlowingBufferInt
* @see org.jcsp.util.ints.InfiniteBufferInt
* @see org.jcsp.lang.ChannelInt
*
* @author P.D. Austin
*/
//}}}
public interface ChannelDataStoreInt extends Cloneable {
/** Indicates that the ChannelDataStoreInt is empty
* -- it can accept only a put.
*/
public final static int EMPTY = 0;
/**
* Indicates that the ChannelDataStoreInt is neither empty nor full
* -- it can accept either a put or a get call.
*/
public final static int NONEMPTYFULL = 1;
/** Indicates that the ChannelDataStoreInt is full
* -- it can accept only a get.
*/
public final static int FULL = 2;
/**
* Returns the current state of the ChannelDataStoreInt.
*
* @return the current state of the ChannelDataStoreInt (EMPTY,
* NONEMPTYFULL or FULL)
*/
public abstract int getState ();
/**
* Puts a new int into the ChannelDataStoreInt.
*
* Pre-condition: getState must not currently return FULL.
*
* @param value the int to put into the ChannelDataStoreInt
*/
public abstract void put (int value);
/**
* Returns an int from the ChannelDataStoreInt.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return an int from the ChannelDataStoreInt
*/
public abstract int get ();
/**
* Begins an extended read on the buffer, returning the data for the extended read
*
* Pre-condition: getState must not currently return EMPTY.
*
* The exact behaviour of this method depends on your buffer. When a process performs an
* extended rendezvous on a buffered channel, it will first call this method, then the
* {@link #endGet} method.
*
* A FIFO buffer would implement this method as returning the value from the front of the buffer
* and the next call would remove the value. An overflowing buffer would do the same.
*
* However, for an overwriting buffer it is more complex. Refer to the documentation for
* {@link OverWritingBuffer#startGet} and {@link OverWriteOldestBuffer#startGet}
* for details
*
* @return The int to be read from the channel at the beginning of the extended rendezvous
*
* @see #endGet
*/
public abstract int startGet();
/**
* Ends an extended read on the buffer.
*
* The channels guarantee that this method will be called exactly once after each beginExtRead call.
* During the period between startGet and endGet, it is possible that {@link #put} will be called,
* but not {@link #get}.
*
* @see #startGet
*/
public abstract void endGet();
/**
* Returns a new (and EMPTY) ChannelDataStoreInt with the same
* creation parameters as this one.
*
* Note: Only the size and structure of the ChannelDataStoreInt should
* be cloned, not any stored data.
*
* @return the cloned instance of this ChannelDataStoreInt.
*/
public abstract Object clone ();
public abstract void removeAll();
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/InfiniteBuffer.java 0000644 0000000 0000000 00000017326 11105701167 017671 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util;
import java.io.Serializable;
/**
* This is used to create a buffered object channel that always accepts and
* never loses any input.
*
* The getState method returns EMPTY or NONEMPTYFULL, but
* never FULL.
*
* An initial size for the buffer can be specified during construction.
*
* @see org.jcsp.util.ZeroBuffer
* @see org.jcsp.util.Buffer
* @see org.jcsp.util.OverWriteOldestBuffer
* @see org.jcsp.util.OverWritingBuffer
* @see org.jcsp.util.OverFlowingBuffer
* @see org.jcsp.lang.Channel
*
* @author P.D. Austin
*/
public class InfiniteBuffer implements ChannelDataStore, Serializable
{
/** The default size of the buffer */
private static final int DEFAULT_SIZE = 8;
/** The initial size of the buffer */
private int initialSize;
/** The storage for the buffered Objects */
private Object[] buffer;
/** The number of Objects stored in the InfiniteBuffer */
private int counter = 0;
/** The index of the oldest element (when counter > 0) */
private int firstIndex = 0;
/** The index of the next free element (when counter < buffer.length) */
private int lastIndex = 0;
/**
* Construct a new InfiniteBuffer with the default size (of 8).
*/
public InfiniteBuffer()
{
this(DEFAULT_SIZE);
}
/**
* Construct a new InfiniteBuffer with the specified initial size.
*
* @param initialSize the number of Objects
* the InfiniteBuffer can initially store.
* @throws BufferSizeError if size is zero or negative. Note: no action
* should be taken to try/catch this exception
* - application code generating it is in error and needs correcting.
*/
public InfiniteBuffer(int initialSize)
{
if (initialSize <= 0)
throw new BufferSizeError
("\n*** Attempt to create a buffered channel with an initially negative or zero capacity");
this.initialSize = initialSize;
buffer = new Object[initialSize];
}
/**
* Returns the oldest Object from the InfiniteBuffer and removes it.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return the oldest Object from the InfiniteBuffer
*/
public Object get()
{
Object value = buffer[firstIndex];
buffer[firstIndex] = null;
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
return value;
}
/**
* Returns the oldest object from the buffer but does not remove it.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return the oldest Object from the Buffer
*/
public Object startGet()
{
return buffer[firstIndex];
}
/**
* Removes the oldest object from the buffer.
*/
public void endGet()
{
buffer[firstIndex] = null;
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
}
/**
* Puts a new Object into the InfiniteBuffer.
*
* Implementation note: if InfiniteBuffer is full, a new internal
* buffer with double the capacity is constructed and the old data copied across.
*
* @param value the Object to put into the InfiniteBuffer
*/
public void put(Object value)
{
if (counter == buffer.length)
{
Object[] temp = buffer;
buffer = new Object[buffer.length * 2];
System.arraycopy(temp, firstIndex, buffer, 0, temp.length - firstIndex);
System.arraycopy(temp, 0, buffer, temp.length - firstIndex, firstIndex);
firstIndex = 0;
lastIndex = temp.length;
}
buffer[lastIndex] = value;
lastIndex = (lastIndex + 1) % buffer.length;
counter++;
}
/**
* Returns the current state of the InfiniteBuffer.
*
* @return the current state of the InfiniteBuffer (EMPTY or
* NONEMPTYFULL)
*/
public int getState()
{
if (counter == 0)
return EMPTY;
else
return NONEMPTYFULL;
}
/**
* Returns a new (and EMPTY) InfiniteBuffer with the same
* creation parameters as this one.
*
* Note: Only the initial size and structure of the InfiniteBuffer
* is cloned, not any stored data.
*
* @return the cloned instance of this InfiniteBuffer.
*/
public Object clone()
{
return new InfiniteBuffer(initialSize);
}
public void removeAll()
{
counter = 0;
firstIndex = 0;
lastIndex = 0;
for (int i = 0;i < buffer.length;i++) {
//Null the objects so they can be garbage collected:
buffer[i] = null;
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/ZeroBuffer.java 0000644 0000000 0000000 00000012620 11105701167 017033 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util;
import java.io.Serializable;
//{{{ javadoc
/**
* This is used to create a zero-buffered object channel that never loses data.
*
* The getState method will return FULL if there is an output
* waiting on the channel and EMPTY if there is not.
*
* @see org.jcsp.util.Buffer
* @see org.jcsp.util.OverWriteOldestBuffer
* @see org.jcsp.util.OverWritingBuffer
* @see org.jcsp.util.OverFlowingBuffer
* @see org.jcsp.util.InfiniteBuffer
* @see org.jcsp.lang.One2OneChannelImpl
* @see org.jcsp.lang.Any2OneChannelImpl
* @see org.jcsp.lang.One2AnyChannelImpl
* @see org.jcsp.lang.Any2AnyChannelImpl
*
* @author P.D. Austin
*/
//}}}
public class ZeroBuffer implements ChannelDataStore, Serializable
{
/** The current state */
private int state = EMPTY;
/** The Object */
private Object value;
/**
* Returns the Object from the ZeroBuffer.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return the Object from the ZeroBuffer
*/
public Object get()
{
state = EMPTY;
Object o = value;
value = null;
return o;
}
/**
* Begins an extended rendezvous - simply returns the next object in the buffer.
* This function does not remove the object.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return The object in the buffer.
*/
public Object startGet() {
return value;
}
/**
* Ends the extended rendezvous by clearing the buffer.
*/
public void endGet() {
value = null;
state = EMPTY;
}
/**
* Puts a new Object into the ZeroBuffer.
*
* Pre-condition: getState must not currently return FULL.
*
* @param value the Object to put into the ZeroBuffer
*/
public void put(Object value)
{
state = FULL;
this.value = value;
}
/**
* Returns the current state of the ZeroBuffer.
*
* @return the current state of the ZeroBuffer (EMPTY
* or FULL)
*/
public int getState()
{
return state;
}
/**
* Returns a new (and EMPTY) ZeroBuffer with the same
* creation parameters as this one.
*
* Note: Only the size and structure of the ZeroBuffer is
* cloned, not any stored data.
*
* @return the cloned instance of this ZeroBuffer.
*/
public Object clone()
{
return new ZeroBuffer();
}
public void removeAll()
{
state = EMPTY;
value = null;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/OverWritingBuffer.java 0000644 0000000 0000000 00000017561 11105701167 020404 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util;
import java.io.Serializable;
/**
* This is used to create a buffered object channel that always accepts input,
* overwriting its last entered data if full.
*
* The getState method returns EMPTY or NONEMPTYFULL, but
* never FULL.
*
* @see org.jcsp.util.ZeroBuffer
* @see org.jcsp.util.Buffer
* @see org.jcsp.util.OverWriteOldestBuffer
* @see org.jcsp.util.OverFlowingBuffer
* @see org.jcsp.util.InfiniteBuffer
* @see org.jcsp.lang.Channel
*
* @author P.D. Austin
*/
//}}}
public class OverWritingBuffer implements ChannelDataStore, Serializable
{
/** The storage for the buffered Objects */
private final Object[] buffer;
/** The number of Objects stored in the Buffer */
private int counter = 0;
/** The index of the oldest element (when counter > 0) */
private int firstIndex = 0;
/** The index of the next free element (when counter < buffer.length) */
private int lastIndex = 0;
private boolean valueWrittenWhileFull = false;
/**
* Construct a new OverWritingBuffer with the specified size.
*
* @param size the number of Objects the OverWritingBuffer can store.
* @throws BufferSizeError if size is zero or negative. Note: no action
* should be taken to try/catch this exception
* - application code generating it is in error and needs correcting.
*/
public OverWritingBuffer(int size)
{
if (size <= 0)
throw new BufferSizeError
("\n*** Attempt to create an overwriting buffered channel with negative or zero capacity");
buffer = new Object[size];
}
/**
* Returns the oldest Object from the OverWritingBuffer and removes it.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return the oldest Object from the OverWritingBuffer
*/
public Object get()
{
Object value = buffer[firstIndex];
buffer[firstIndex] = null;
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
return value;
}
/**
* Puts a new Object into the OverWritingBuffer.
*
* If OverWritingBuffer is full, the last item
* previously put into the buffer will be overwritten.
*
* @param value the Object to put into the OverWritingBuffer
*/
public void put(Object value)
{
if (counter == buffer.length)
{
buffer[(lastIndex - 1 + buffer.length) % buffer.length] = value;
valueWrittenWhileFull = true;
}
else
{
buffer[lastIndex] = value;
lastIndex = (lastIndex + 1) % buffer.length;
counter++;
}
}
/**
* This begins an extended rendezvous by the reader.
* The semantics of an extended rendezvous on an overwrite-newest buffer are slightly
* complicated, but hopefully intuitive.
*
* If the buffer is of size 2 or larger, the semantics are as follows.
* Beginning an extended rendezvous will return the oldest value in the buffer, but not remove it.
* If the writer writes to the buffer during the rendezvous, it will grow the buffer and end up
* overwriting the newest value as normal. At the end of the extended rendezvous, the oldest
* value is removed.
*
* If the buffer is of size 1, the semantics are identical to those of an {@link OverWriteOldestBuffer}.
* For a complete description, refer to the documentation for the {@link OverWriteOldestBuffer#startGet()} method.
*
* @return The oldest value in the buffer at this time
*/
public Object startGet()
{
valueWrittenWhileFull = false;
return buffer[firstIndex];
}
/**
* This ends an extended rendezvous by the reader.
*
* @see #startGet()
*/
public void endGet()
{
if (false == valueWrittenWhileFull || buffer.length != 1) {
//Our data hasn't been over-written so remove it:
buffer[firstIndex] = null;
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
}
}
/**
* Returns the current state of the OverWritingBuffer.
*
* @return the current state of the OverWritingBuffer (EMPTY or
* NONEMPTYFULL)
*/
public int getState()
{
if (counter == 0)
return EMPTY;
else
return NONEMPTYFULL;
}
/**
* Returns a new (and EMPTY) OverWritingBuffer with the same
* creation parameters as this one.
*
* Note: Only the size and structure of the OverWritingBuffer is
* cloned, not any stored data.
*
* @return the cloned instance of this OverWritingBuffer.
*/
public Object clone()
{
return new OverWritingBuffer(buffer.length);
}
public void removeAll()
{
counter = 0;
firstIndex = 0;
lastIndex = 0;
for (int i = 0;i < buffer.length;i++) {
//Null the objects so they can be garbage collected:
buffer[i] = null;
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/OverFlowingBuffer.java 0000644 0000000 0000000 00000015415 11105701167 020362 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util;
import java.io.Serializable;
/**
* This is used to create a buffered object channel that always accepts input,
* discarding its last entered data if full.
*
* The getState method returns EMPTY or NONEMPTYFULL, but
* never FULL.
*
* @see org.jcsp.util.ZeroBuffer
* @see org.jcsp.util.Buffer
* @see org.jcsp.util.OverWriteOldestBuffer
* @see org.jcsp.util.OverWritingBuffer
* @see org.jcsp.util.InfiniteBuffer
* @see org.jcsp.lang.Channel
*
* @author P.D. Austin
*/
public class OverFlowingBuffer implements ChannelDataStore, Serializable {
/** The storage for the buffered Objects */
private final Object[] buffer;
/** The number of Objects stored in the Buffer */
private int counter = 0;
/** The index of the oldest element (when counter > 0) */
private int firstIndex = 0;
/** The index of the next free element (when counter < buffer.length) */
private int lastIndex = 0;
/**
* Construct a new OverFlowingBuffer with the specified size.
*
* @param size the number of Objects the OverFlowingBuffer can store.
* @throws BufferSizeError if size is zero or negative. Note: no action
* should be taken to try/catch this exception
* - application code generating it is in error and needs correcting.
*/
public OverFlowingBuffer(int size) {
if (size <= 0) {
throw new BufferSizeError(
"\n*** Attempt to create an overflowing buffered channel with negative or zero capacity"
);
}
buffer = new Object[size];
}
/**
* Returns the oldest Object from the OverFlowingBuffer and removes it.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return the oldest Object from the OverFlowingBuffer
*/
public Object get() {
Object value = buffer[firstIndex];
buffer[firstIndex] = null;
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
return value;
}
/**
* Returns the oldest object from the buffer but does not remove it.
*
* Pre-condition: getState must not currently return EMPTY.
*
* @return the oldest Object from the Buffer
*/
public Object startGet()
{
return buffer[firstIndex];
}
/**
* Removes the oldest object from the buffer.
*/
public void endGet()
{
buffer[firstIndex] = null;
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
}
/**
* Puts a new Object into the OverFlowingBuffer.
*
* If OverFlowingBuffer is full, the item is discarded.
*
* @param value the Object to put into the OverFlowingBuffer
*/
public void put(Object value) {
if (counter < buffer.length) {
buffer[lastIndex] = value;
lastIndex = (lastIndex + 1) % buffer.length;
counter++;
}
}
/**
* Returns the current state of the OverFlowingBuffer.
*
* @return the current state of the OverFlowingBuffer (EMPTY or
* NONEMPTYFULL)
*/
public int getState()
{
if (counter == 0)
return EMPTY;
else
return NONEMPTYFULL;
}
/**
* Returns a new (and EMPTY) OverFlowingBuffer with the same
* creation parameters as this one.
*
* Note: Only the size and structure of the OverFlowingBuffer is
* cloned, not any stored data.
*
* @return the cloned instance of this OverFlowingBuffer.
*/
public Object clone()
{
return new OverFlowingBuffer(buffer.length);
}
public void removeAll()
{
counter = 0;
firstIndex = 0;
lastIndex = 0;
for (int i = 0;i < buffer.length;i++) {
//Null the objects so they can be garbage collected:
buffer[i] = null;
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/ 0000755 0000000 0000000 00000000000 11410045045 014055 5 ustar jcsp-1.1-rc4.orig/src/org/jcsp/lang/BufferedChannelArrayFactory.java 0000644 0000000 0000000 00000007574 11105701167 022304 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.*;
/**
* Defines an interface for a factory that can create arrays of channels with user-definable
* buffering semantics.
*
* @author Quickstone Technologies Limited
*
* @deprecated These channel factories are deprecated in favour of the new one2one() methods in the Channel class.
*/
public interface BufferedChannelArrayFactory
{
/**
* Creates a populated array of
* It can also be used as a {@link Guard} in
* an {@link Alternative} that is always ready.
* This makes it useful for polling
* a set of guards to test if any are ready:
* include it as the last element of the guard array and
* {@link Alternative#priSelect() priSelect}.
*
* Note: the process is also included for completeness – it is one of
* the fundamental primitives of CSP, where it is a unit of sequential
* composition and parallel interleaving.
* In JCSP, it is a unit of {@link Sequence}, {@link Parallel} and {@link PriParallel} .
*
* @see org.jcsp.lang.Stop
*
* @author P.D. Austin
* @author P.H. Welch
*
*/
public class Skip extends Guard implements CSProcess
{
/**
* Enables this guard.
*
* @param alt the Alternative doing the enabling.
*/
boolean enable(Alternative alt)
{
Thread.yield();
return true;
}
/**
* Disables this guard.
*/
boolean disable()
{
return true;
}
/**
* The main body of this process.
*/
public void run()
{
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Any2OneIntImpl.java 0000644 0000000 0000000 00000006215 11113671251 017500 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
class Any2OneIntImpl implements ChannelInternalsInt, Any2OneChannelInt {
private ChannelInternalsInt channel;
private final Object writeMonitor = new Object();
Any2OneIntImpl(ChannelInternalsInt _channel) {
channel = _channel;
}
//Begin never used:
public void endRead() {
channel.endRead();
}
public int read() {
return channel.read();
}
public boolean readerDisable() {
return channel.readerDisable();
}
public boolean readerEnable(Alternative alt) {
return channel.readerEnable(alt);
}
public boolean readerPending() {
return channel.readerPending();
}
public void readerPoison(int strength) {
channel.readerPoison(strength);
}
public int startRead() {
return channel.startRead();
}
//End never used
public void write(int n) {
synchronized (writeMonitor) {
channel.write(n);
}
}
public void writerPoison(int strength) {
synchronized (writeMonitor) {
channel.writerPoison(strength);
}
}
public AltingChannelInputInt in() {
return new AltingChannelInputIntImpl(channel,0);
}
public SharedChannelOutputInt out() {
return new SharedChannelOutputIntImpl(this,0);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/AltingConnectionClientImpl.java 0000644 0000000 0000000 00000015013 11105701167 022144 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This class does not need to be used by standard JCSP users. It is exposed so that the connection
* mechanism can be extended for custom connections.
*
* @author Quickstone Technologies Limited
*/
public class AltingConnectionClientImpl extends AltingConnectionClient
{
private int currentClientState;
private static final int CLIENT_STATE_CLOSED = 1;
private static final int CLIENT_STATE_MADE_REQ = 2;
private static final int CLIENT_STATE_OPEN = 3;
private AltingChannelInput fromServer;
private ChannelOutput openToServer;
private ChannelOutput reqToServer;
private ChannelOutput backToClient;
private ConnectionClientMessage msg = new ConnectionClientMessage();
private ConnectionClientOpenMessage msgOpen = new ConnectionClientOpenMessage();
/**
* Constructs a new instance. This constructor must be called by a subclass which is responsible
* for creating the channels used by the connection and must pass them into this constructor.
*/
protected AltingConnectionClientImpl(AltingChannelInput fromServer,
ChannelOutput openToServer,
ChannelOutput reqToServer,
ChannelOutput backToClient)
{
super(fromServer);
this.fromServer = fromServer;
this.openToServer = openToServer;
this.reqToServer = reqToServer;
this.backToClient = backToClient;
currentClientState = CLIENT_STATE_CLOSED;
}
/**
* Sends some data over the connection to server once the
* connection has been opened.
*
* @param data the This implements a one-to-any object channel with user-definable buffering,
* safe for use by a single writer and many readers. Refer to {@link One2AnyChannel} for a
* description of this behaviour. Additionally, this channel supports a
* A writing-end, obtained from an any-one or any-any
* channel by invoking its in() method, will implement this interface.
*
* @author Quickstone Technologies Limited
*/
public interface SharedChannelOutput extends ChannelOutput
{
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/AltingConnectionClient.java 0000644 0000000 0000000 00000013277 11105701167 021334 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
*
* This class is sub-classed by JCSP.NET classes
* to provide
* Although JCSP users could sub-class this class, under most
* circumstances, there is no need.
* Constructor.
*
* Note that this is only intended for use by JCSP, and should
* not be called by user processes. Users should use one of the
* subclasses.
*
* Returns the channel used to implement the Guard.
*
* Note that this method is only intended for use by
* JCSP, and should not be called by user processes.
*
* Concrete subclasses should override this method to
* return null, to ensure that the alting channel is
* kept private.
*
*
* This method allows sub-classes to specify which channel should
* be the next one to be alted over.
*
* Returns true if the event is ready. Otherwise, this enables the guard
* for selection and returns false.
*
* Note: this method should only be called by the Alternative class
*
* Disables the guard for selection. Returns true if the event was ready.
*
* Note: this method should only be called by the Alternative class
*
* Returns whether there is an open() pending on this connection.
*
* Note: if there is, it won't go away until you accept it. But if
* there isn't, there may be one by the time you check the result of
* this method.
*
* It can also be used as a {@link Guard} in an {@link Alternative} that is
* never ready.
* Of course, this is equivalent to it (and its defended process) not being
* there at all!
*
* Note: this process is included for completeness – it is one of the fundamental
* primitives of CSP, where it represents a broken process and is a unit of
* external choice.
* In JCSP, it is a unit of {@link Alternative}.
*
* @see org.jcsp.lang.Skip
*
* @author P.D. Austin and P.H. Welch
*
*/
//}}}
public class Stop extends Guard implements CSProcess {
/**
* Enables this guard.
*
* @param alt the Alternative doing the enabling.
*/
boolean enable (Alternative alt) {
Thread.yield ();
return false;
}
/**
* Disables this guard.
*/
boolean disable () {
return false;
}
/**
* This process starts, engages in no events, performs no computation
* and refuses to terminate.
*
*/
public void run () {
Object lock = new Object ();
synchronized (lock) {
try {
lock.wait ();
while (true) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.StopRun);
}
lock.wait ();
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException ("*** Thrown from Stop.run ()\n"
+ e.toString ());
}
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/StandardChannelIntFactory.java 0000644 0000000 0000000 00000032141 11105701167 021762 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.ints.ChannelDataStoreInt;
/**
* This class acts as a Factory for creating
* channels. It can create non-buffered and buffered channels
* and also arrays of non-buffered and buffered channels. The Channel objects created by this Factory are formed of
* separate objects for the read and write ends. Therefore the
* The current implementation uses an instance of the
* Constructs and returns a The buffer supplied to this method is cloned before it is inserted into
* the channel.
* Constructs and returns a The buffer supplied to this method is cloned before it is inserted into
* the channel.
* Constructs and returns a The buffer supplied to this method is cloned before it is inserted into
* the channel.
* Constructs and returns a The buffer supplied to this method is cloned before it is inserted into
* the channel.
* Constructs and returns an array of The buffer supplied to this method is cloned before it is inserted into
* the channel. This is why an array of buffers is not required.
* Constructs and returns an array of The buffer supplied to this method is cloned before it is inserted into
* the channel. This is why an array of buffers is not required.
* Constructs and returns an array of The buffer supplied to this method is cloned before it is inserted into
* the channel. This is why an array of buffers is not required.
* Constructs and returns an array of The buffer supplied to this method is cloned before it is inserted into
* the channel. This is why an array of buffers is not required.
* This implements a one-to-any object channel,
* safe for use by a single writer and many readers. Refer to {@link One2AnyChannel} for a
* description of this behaviour. Additionally, this channel supports a This is an interface to be implemented by classes that wish
* to act as a client to connect to a Users of classes implementing this interface should call
* After calling This is an example of typical code structure for using a
* ConnectionClient: This method is used to send data to a Once this method has returned, the client may do some computation but
* must then guarantee to call Once a server replies, if the connection has been kept open, then
* this method should be called again to make a further request. Programs using Receives some data back from the server after
* After calling this method, Implementations may make this operation ALTable. Returns whether the server has kept its end of the Connection open.
* This should only be called after a call to
* Shortcut to the Constructor and Method Summaries.
*
*
* For example, using the same Foo
* interface as before, we derive:
*
* For example, the network consisting of one client and several servers:
*
* A reading-end, obtained from a one-one or any-one
* channel by invoking its in() method, will extend this abstract class.
* ChannelOutput object on which to output
* any data received from over the network.
*
* @param label the label to assign to the VCN. If this is
* null then no label will be assigned.
* @param out the Profile to obtain.
* @return a matching link profile or null if no match is found.
*/
public static Profile getLinkProfile(String name)
{
return (Profile)linkProfiles.get(name);
}
/** Returns a Node profile of a certain name from a static collection of
* Node profiles.
* @param name the name of the Profile to obtain.
* @return a matching Node profile or null if no match is found.
*/
public static Profile getNodeProfile(String name)
{
return (Profile)nodeProfiles.get(name);
}
static Profile getAlwaysMatchProfile()
{
return alwaysMatchProfile;
}
private static Profile alwaysMatchProfile = new Profile("AlwaysMatchProfile", new Requirement[] {}, false, true);
static Profile getProtocolProfile(ProtocolID protocolID)
{
return new Profile("ProtocolProfile " + protocolID.getPosition(),
new Requirement[]
{
new Requirement(XMLConfigConstants.REQ_NAME_PROTOCOL,
XMLConfigConstants.SPEC_NAME_PROTOCOL,
XMLConfigConstants.REQ_COMPARATOR_EQUALS,
protocolID.getClass().toString())
},
false, true);
}
private static Hashtable linkProfiles = new Hashtable();
private static Hashtable nodeProfiles = new Hashtable();
private Profile(String name, Requirement[] requirements, boolean exact, boolean system)
{
this.name = name;
this.exact = exact;
this.system = system;
this.requirements = requirements;
Arrays.sort(requirements, new Comparator()
{
public int compare(Object o1, Object o2)
{
Requirement r1 = (Requirement) o1;
Requirement r2 = (Requirement) o2;
return r1.specName.compareTo(r2.specName);
}
});
}
/**
* This tests whether a an array of Specification objects meet the
* requirements of this profile.
*
* This method will sort the array of specs in order of name. This sort
* will change the original array.
*
* @returns -1 if the specs do not match, 0 if they do not contradict or
* 1 if they are a positive match.
*/
int matches(Specification[] specs)
{
//sort the array
if(specs == null)
{
if(requirements == null || requirements.length == 0)
return 1;
else
return 0;
}
Arrays.sort(specs, new Comparator()
{
public int compare(Object o1, Object o2)
{
Specification s1 = (Specification) o1;
Specification s2 = (Specification) o2;
return s1.name.compareTo(s2.name);
}
});
int match = 0;
int rPos = 0;
int sPos = 0;
while(rPos < requirements.length && sPos < specs.length && match != -1)
{
int comparison = requirements[rPos].specName.compareTo(specs[sPos].name);
if(comparison == 0)
{
if(requirements[rPos].matches(specs[sPos]))
match++;
else
//match failed - return as profile definitely doesn't match
return -1;
rPos++;
}
else if(comparison < 0)
rPos++;
else if(comparison > 0)
sPos++;
}
if (match == requirements.length)
//every requirement had a match
return 1;
else
//no requirement was contradicted by a specification but
//there were insufficient specifications to match
//all the requirements
return 0;
}
boolean requiresExactMatch()
{
return exact;
}
/** Compares this Profile with another object.
* @param o another object to compare with this object.
* @return true iff the supplied object is a Profile object that
* is exactly equal.
*/
public boolean equals(Object o)
{
if(o==null || !(o instanceof Profile))
return false;
Profile other = (Profile) o;
return name.equals(other.name)
&& Arrays.equals(requirements, other.requirements)
&& exact == other.exact
&& system == other.system;
}
/**
* Returns a hash code for this object that follows the
* standard rule for hash codes stated in the Object class.
* @return an int hash code for this object.
*/
public int hashCode()
{
return name.hashCode();
}
private String name;
private boolean exact;
private boolean system;
private Requirement[] requirements;
} jcsp-1.1-rc4.orig/src/org/jcsp/net/StandardNetConnectionFactory.java 0000644 0000000 0000000 00000006273 11105701167 022361 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.net;
/**
* {@link NetConnectionFactory}.
* {@link NetChannelEndFactory}.
* Message objects from SerializedMessage objects.
* Dynamic class loading can be enabled by using the constructor which takes a ClassManager.
* If dynamic class loading is enabled and a DynamicClassLoaderMessage is filtered,
* the ClassManager object is supplied to the Message object and the underlying message extracted.
* Any classes that need loading from the remote Node are requested and loaded as necessary.
*
* @author Quickstone Technologies Limited
*/
class DeserializeChannelFilter implements Filter
{
/* 5 Jun 2002
*
* This class was originally used by the dynamic class loading
* mechanism as well as the LoopBackLink
*
* Have now moved dynamic class loading mechanism into separate
* package and so have modified this class just to be used
* by LoopbackLink.
*
DeserializeChannelFilter(ClassManager cm) {
this.cm = cm;
this.dynamic = true;
}
*/
DeserializeChannelFilter()
{
}
/** This method takes an object and substitutes it for another object based upon the following rules:
*
* If the object is an instance of the DynamicClassLoaderMessage class and dynamic class loading is enabled,
* then the filter will return the object returned by the supplied object's get method. A ClassManager will be
* supplied to the method.
*
* If the object is an instance of the SerializedMessage class then the object's get
* method will be called. The message being held by the SerializedMessage will be deserialized
* but classes will not be dynamically loaded.
*
* If the object is not a SerializedMessage object, then the object itself will be returned without
* modification.
* @param object The object to filter.
* @return the substituted object.
*/
public Object filter(Object object)
{
try
{
if (object instanceof SerializedMessage)
return ((SerializedMessage)object).get();
else
return object;
}
catch (ClassNotFoundException e)
{
Node.err.log(this, e);
}
catch (IOException e)
{
Node.err.log(this, e);
}
//return object at the moment decide later - this is only prototype version
return object;
}
} jcsp-1.1-rc4.orig/src/org/jcsp/net/cns.xml 0000644 0000000 0000000 00000001024 10520670125 015230 0 ustar
ChannelInput objects.
* Class of the factory class.
*/
public Class getFactoryClass();
/**
* NetConnectionLocation
* objects. One for a connection's server channel and one for a
* connection's further request channel.
*
* Instances of this class can be used as the open channel's
* NetChannelLocation object while the further request
* channel's can be obtained by calling
* getRequestChannelLocation().
*
* @author Quickstone Technologies Limited
*/
class NetConnectionLocation extends NetChannelLocation
{
private NetChannelLocation reqLoc;
/**
* Constructor for NetConnectionLocation.
* @param other
* @throws IllegalArgumentException
*/
public NetConnectionLocation(NetChannelLocation open, NetChannelLocation req) throws IllegalArgumentException
{
super(open);
this.reqLoc = req;
}
public NetChannelLocation getRequestChannelLocation()
{
return this.reqLoc;
}
} jcsp-1.1-rc4.orig/src/org/jcsp/test/ 0000755 0000000 0000000 00000000000 11410045043 014111 5 ustar jcsp-1.1-rc4.orig/src/org/jcsp/test/WriterProcess.java 0000644 0000000 0000000 00000003325 10657566574 017627 0 ustar package org.jcsp.test;
import java.security.InvalidParameterException;
import java.util.Arrays;
import java.util.List;
import org.jcsp.lang.AltingBarrier;
import org.jcsp.lang.CSProcess;
import org.jcsp.lang.ChannelOutput;
/**
* A process that writes out a list of values, synchronizing on the corresponding barrier after each.
*
*
* @author N.C.C. Brown
*
*/
public class WriterProcess implements CSProcess {
private ChannelOutput out;
private List values;
private AltingBarrier[][] events;
public WriterProcess(ChannelOutput out,List values,AltingBarrier[][] events) {
if (values.size() != events.length) {
throw new InvalidParameterException("Values must be the same length as Events");
}
this.out = out;
this.values = values;
this.events = events;
}
public WriterProcess(ChannelOutput out,List values,AltingBarrier event) {
this.out = out;
this.values = values;
this.events = new AltingBarrier[values.size()][];
Arrays.fill(this.events,new AltingBarrier[] {event});
}
public void run() {
for (int i = 0;i < events.length;i++) {
AltingBarrier[] barriers = events[i];
for (int j = 0;j < barriers.length;j++) {
AltingBarrier barrier = barriers[j];
if (barrier != null) {
barrier.mark();
}
}
}
for (int i = 0;i < values.size();i++) {
out.write(values.get(i));
AltingBarrier[] barriers = events[i];
for (int j = 0;j < barriers.length;j++) {
AltingBarrier barrier = barriers[j];
if (barrier != null) {
barrier.sync();
}
}
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/test/ExtendedReaderSyncInt.java 0000644 0000000 0000000 00000004171 10657566574 021207 0 ustar package org.jcsp.test;
import java.security.InvalidParameterException;
import java.util.Arrays;
import org.jcsp.lang.AltingBarrier;
import org.jcsp.lang.CSProcess;
import org.jcsp.lang.ChannelInputInt;
/**
* A process that performs a set number of extended inputs, syncing on a barrier
* as its extended action for each
*
* @author N.C.C. Brown
*
*/
public class ExtendedReaderSyncInt implements CSProcess {
private AltingBarrier[][] events;
private ChannelInputInt input;
private int iterations;
private int[] valuesRead;
public ExtendedReaderSyncInt(AltingBarrier[][] barriers, ChannelInputInt in, int iterations) {
if (barriers.length != iterations) {
throw new InvalidParameterException("Barriers must be the same length as iterations");
}
this.events = barriers;
this.input = in;
this.iterations = iterations;
valuesRead = new int[iterations];
}
public ExtendedReaderSyncInt(AltingBarrier barrier, ChannelInputInt in, int iterations) {
this.events = new AltingBarrier[iterations][];
Arrays.fill(this.events,new AltingBarrier[] {barrier});
this.input = in;
this.iterations = iterations;
valuesRead = new int[iterations];
}
public void run() {
for (int i = 0;i < events.length;i++) {
AltingBarrier[] barriers = events[i];
for (int j = 0;j < barriers.length;j++) {
AltingBarrier barrier = barriers[j];
if (barrier != null) {
barrier.mark();
}
}
}
for (int i = 0;i < iterations;i++) {
valuesRead[i] = input.startRead();
AltingBarrier[] barriers = events[i];
if (barriers.length > 0) {
AltingBarrier barrier = barriers[0];
if (barrier != null) {
barrier.sync();
}
}
input.endRead();
if (barriers.length > 1) {
AltingBarrier barrier = barriers[1];
if (barrier != null) {
barrier.sync();
}
}
}
}
public int[] getValuesRead() {
return valuesRead;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/test/ExtendedReaderSync.java 0000644 0000000 0000000 00000004160 10657566574 020532 0 ustar package org.jcsp.test;
import java.security.InvalidParameterException;
import java.util.Arrays;
import org.jcsp.lang.AltingBarrier;
import org.jcsp.lang.CSProcess;
import org.jcsp.lang.ChannelInput;
/**
* A process that performs a set number of extended inputs, syncing on a barrier
* as its extended action for each
*
* @author N.C.C. Brown
*
*/
public class ExtendedReaderSync implements CSProcess {
private AltingBarrier[][] events;
private ChannelInput input;
private int iterations;
private Object[] valuesRead;
public ExtendedReaderSync(AltingBarrier[][] barriers, ChannelInput in, int iterations) {
if (barriers.length != iterations) {
throw new InvalidParameterException("Barriers must be the same length as iterations");
}
this.events = barriers;
this.input = in;
this.iterations = iterations;
valuesRead = new Object[iterations];
}
public ExtendedReaderSync(AltingBarrier barrier, ChannelInput in, int iterations) {
this.events = new AltingBarrier[iterations][];
Arrays.fill(this.events,new AltingBarrier[] {barrier});
this.input = in;
this.iterations = iterations;
valuesRead = new Object[iterations];
}
public void run() {
for (int i = 0;i < events.length;i++) {
AltingBarrier[] barriers = events[i];
for (int j = 0;j < barriers.length;j++) {
AltingBarrier barrier = barriers[j];
if (barrier != null) {
barrier.mark();
}
}
}
for (int i = 0;i < iterations;i++) {
valuesRead[i] = input.startRead();
AltingBarrier[] barriers = events[i];
if (barriers.length > 0) {
AltingBarrier barrier = barriers[0];
if (barrier != null) {
barrier.sync();
}
}
input.endRead();
if (barriers.length > 1) {
AltingBarrier barrier = barriers[1];
if (barrier != null) {
barrier.sync();
}
}
}
}
public Object[] getValuesRead() {
return valuesRead;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/test/AltTest.java 0000644 0000000 0000000 00000010443 11113671251 016344 0 ustar /*******************************************************************************
*
* $Archive: /jcsp/src/test/jcsp/AltTest.java $
*
* $Date: 1998/07/21 14:17:09 $
*
* $Revision: 1.1 $
*
* (C) Copyright 1997/8 Paul Austin Process Diagram
* External View
*
* _________
* | |
* | AltTest |
* |_________|
*
* Internal View
*
* ________________________________________________
* | _____ _____ _____ |
* | | | | | | | |
* | | Nos | | Nos | | Nos | |
* | |_____| |_____| |_____| |
* | | | | |
* | a v b v c v |
* | ______|_____ ______|_____ ______|_____ |
* | | | | | | | |
* | | FixedDelay | | FixedDelay | | FixedDelay | |
* | |____________| |____________| |____________| |
* | | | | |
* | d v e v f v |
* | | | | |
* | +----->-----+ | +-----<-----+ |
* | __|___|___|_ _________ |
* | | | g | | |
* | | |-->--| Printer | |
* | |____________| |_________| |
* | |
* | AltTest |
* |________________________________________________|
*
* Description
* The AltTest process is designed to test the Alternative class.
* Description
* ChannelDataStore defines the interface to optional logic used by
* channels defined in the org.jcsp.lang package to manage the data
* being communicated.
* Implementations are provided yielding a range of buffering properties
* (e.g. {@link Buffer fixed sized (block when full)},
* {@link OverWriteOldestBuffer fixed size (overwrite oldest data when full)},
* {@link OverFlowingBuffer fixed size (accept but discard new data when full)},
* {@link InfiniteBuffer infinitely expandable}).
* startGet} call.
* During the period between {@link #startGet startGet} and
* {@link #endGet endGet}, it is possible that
* {@link #put put} will be called, but not {@link #get get}.
*
* @see #startGet
*/
public abstract void endGet();
/**
* Returns a new (and EMPTY) ChannelDataStore with the same
* creation parameters as this one.
* Description
* Buffer is an implementation of ChannelDataStore that yields
* a blocking FIFO buffered semantics for a channel.
* See the static construction methods of {@link org.jcsp.lang.Channel}
* ({@link org.jcsp.lang.Channel#one2one(org.jcsp.util.ChannelDataStore)} etc.).
* Filter interface installed to apply transformations
* on data as it is read from the channel.
* FilteredChannelInput in = ...;
*
* Filter f1 = ...;
* Filter f2 = ...;
*
* in.addReadFilter (f1, 0);
* in.addReadFilter (f2, 1);
*
*
* in.read() method will return f2.filter (f1.filter (obj)) where
* obj is the data value that would have been delivered in the absence of filters.read method of the
* channel end. The filter will be appended to the end of the current list, making it the last to
* be applied.
*
* @param filter the filter to be installed; may not be null.
*/
public void addReadFilter(Filter filter);
/**
* Installs a read filter defining a transformation to be applied by the read method of the
* channel end at a specific index. If there is already a filter at that index position the existing
* filters are shifted to make room. If the index is greater than the number of filters already
* installed the filter is placed at the end.
*
* @param filter the filter to be installed; may not be null.
* @param index the zero based index; may not be negative.
*/
public void addReadFilter(Filter filter, int index);
/**
* Removes the first read filter (lowest index) matching the filter given as a parameter. The filter
* removed, r, will satisfy the condition r.equals (filter). The remaining
* filters are shifted to close the gap in the index allocation.
*
* @param filter the filter to be removed; may not be null.
*/
public void removeReadFilter(Filter filter);
/**
* Removes the read filter installed at the given index. The remaining filters are shifted to close the
* gap in the index allocation.
*
* @param index zero-based index of the filter to be removed.
*/
public void removeReadFilter(int index);
/**
* Returns the read filter installed at the given index.
*
* @param index zero-based index of the filter to return.
* @return the filter at that position.
*/
public Filter getReadFilter(int index);
/**
* Returns the number of read filters currently installed.
*/
public int getReadFilterCount();
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredSharedChannelInput.java 0000644 0000000 0000000 00000004662 11105701167 023454 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.SharedChannelInput;
/**
* Interface for a channel input end that supports filtering and can be shared by multiple processes.
*
* @see org.jcsp.lang.SharedChannelInput
* @see org.jcsp.util.filter.ReadFiltered
*
* @author Quickstone Technologies Limited
*/
public interface FilteredSharedChannelInput extends SharedChannelInput, FilteredChannelInput
{
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredOne2OneChannel.java 0000644 0000000 0000000 00000005306 11105701167 022467 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.*;
/**
* Interface for a One2One channel that supports filtering operations at each end.
*
* @see org.jcsp.lang.One2OneChannel
* @see org.jcsp.util.filter.ReadFiltered
* @see org.jcsp.util.filter.WriteFiltered
*
* @author Quickstone Technologies Limited
*/
public interface FilteredOne2OneChannel extends One2OneChannel
{
/**
* Returns the control interface for configuring the read filters on the channel.
*/
public ReadFiltered inFilter();
/**
* Returns the control interface for configuring the write filters on the channel.
*/
public WriteFiltered outFilter();
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/package.html 0000644 0000000 0000000 00000001011 11077340707 017664 0 ustar
FilteredChannel
factory, or a filtered end can be created for an existing channel.
PoisonFilter is included in this package.
User-defined filters can be created by implementing the Filter
interface to define the transformation operation to apply on data objects.
ReadFiltered or WriteFiltered interface which
* allows instances of Filter to be installed or removed from the channel.
*
* @see org.jcsp.util.filter.FilteredChannel
* @see org.jcsp.util.filter.FilteredChannelEnd
* @see org.jcsp.util.filter.ReadFiltered
* @see org.jcsp.util.filter.WriteFiltered
*
* @author Quickstone Technologies Limited
*/
public interface Filter
{
/**
* Applies the filter operation. The object given can be modified and returned or another object
* substituted in its place.
*
* @param obj the original object in the channel communication.
* @return the modified/substituted object after filtration.
*/
public Object filter(Object obj);
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredAny2AnyChannelImpl.java 0000644 0000000 0000000 00000006177 11105701167 023334 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.*;
/**
* This wraps up an Any2AnyChannel object so that its
* input and output ends are separate objects. Both ends of the channel
* have filtering enabled.
*
* @author Quickstone Technologies Limited
*/
class FilteredAny2AnyChannelImpl implements FilteredAny2AnyChannel
{
/**
* The input end of the channel.
*/
private FilteredSharedChannelInput in;
/**
* The output end of the channel.
*/
private FilteredSharedChannelOutput out;
/**
* Constructs a new filtered channel object based on an existing channel.
*/
FilteredAny2AnyChannelImpl(Any2AnyChannel chan)
{
in = new FilteredSharedChannelInputWrapper(chan.in());
out = new FilteredSharedChannelOutputWrapper(chan.out());
}
public SharedChannelInput in()
{
return in;
}
public SharedChannelOutput out()
{
return out;
}
public ReadFiltered inFilter()
{
return in;
}
public WriteFiltered outFilter()
{
return out;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/WriteFiltered.java 0000644 0000000 0000000 00000012200 11105701167 021012 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
/**
* Filter interface installed to apply transformations
* on data as it is written to the channel.
* FilteredChannelOutput out = ...;
*
* Filter f1 = ...;
* Filter f2 = ...;
*
* out.addWriteFilter (f1, 0);
* out.addWriteFilter (f2, 1);
*
*
* out.write() method will deliver f2.filter (f1.filter (obj)) to
* the reader of the channel where obj is the data value that would have been delivered in
* the absence of filters.write method of
* the channel end. The filter will be appended to the end of the current list, making it the last to
* be applied.
*
* @param filter the filter to be installed; may not be null.
*/
public void addWriteFilter(Filter filter);
/**
* Installs a write filter defining a transformation to be applied by the write method of the
* channel end at a specific index. If there is already a filter at that index position the existing
* filters are shifted to make room. If the index is greater than the number of filters already
* installed the filter is placed at the end.
*
* @param filter the filter to be installed; may not be null.
* @param index the zero based index; may not be negative.
*/
public void addWriteFilter(Filter filter, int index);
/**
* Removes the first write filter (lowest index) matching the filter given as a parameter. The filter
* removed, r, will satisfy the condition r.equals (filter). The remaining
* filters are shifted to close the gap in the index allocation.
*
* @param filter the filter to be removed; may not be null.
*/
public void removeWriteFilter(Filter filter);
/**
* Removes the write filter installed at the given index. The remaining filters are shifted to close the
* gap in the index allocation.
*
* @param index zero-based index of the filter to be removed.
*/
public void removeWriteFilter(int index);
/**
* Returns the write filter installed at the given index.
*
* @param index zero-based index of the filter to return.
* @return the filter at that position.
*/
public Filter getWriteFilter(int index);
/**
* Returns the number of write filters currently installed.
*/
public int getWriteFilterCount();
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredChannelInput.java 0000644 0000000 0000000 00000004442 11105701167 022321 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.ChannelInput;
/**
* Interface for a channel input end that supports filtering operations.
*
* @author Quickstone Technologies Limited
*/
public interface FilteredChannelInput extends ChannelInput, ReadFiltered
{
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredAny2AnyChannel.java 0000644 0000000 0000000 00000005254 11105701167 022505 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.Any2AnyChannel;
/**
* Interface for an Any2Any channel that has support for filtering at both ends.
*
* @see org.jcsp.lang.Any2AnyChannel
* @see org.jcsp.util.filter.ReadFiltered
* @see org.jcsp.util.filter.WriteFiltered
*
* @author Quickstone Technologies Limited
*/
public interface FilteredAny2AnyChannel extends Any2AnyChannel
{
/**
* Returns an interface for configuring read filters on the channel.
*/
public ReadFiltered inFilter();
/**
* Returns an interface for configuring write filters on the channel.
*/
public WriteFiltered outFilter();
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredChannelEnd.java 0000644 0000000 0000000 00000011164 11105701167 021727 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.*;
/**
* Static factory for creating channel end wrappers that support filtering.
*
* @author Quickstone Technologies Limited
*/
public class FilteredChannelEnd
{
/**
* The default factory for creating the channel ends.
*/
private static final FilteredChannelEndFactory factory = new FilteredChannelEndFactory();
/**
* Private constructor to prevent any instances of this static factory from being created.
*/
private FilteredChannelEnd()
{
// Noone's creating one of these
}
/**
* Creates a new filtered input channel end around an existing input channel end. The channel end
* can be used as a guard in an Alternative.
*
* @param in the existing channel end to create a filtered form of.
* @return the new channel end with filtering ability.
*/
public static FilteredAltingChannelInput createFiltered(AltingChannelInput in)
{
return factory.createFiltered(in);
}
/**
* Creates a new filtered input channel end around an existing input channel end.
*
* @param in the existing channel end to create a filtered form of.
* @return the new channel end with filtering ability.
*/
public static FilteredChannelInput createFiltered(ChannelInput in)
{
return factory.createFiltered(in);
}
/**
* Creates a new filtered input channel end around an existing input channel end that can be
* shared by multiple processes.
*
* @param in the existing channel end to create a filtered form of,
* @return the new channel end with filtering ability.
*/
public static FilteredSharedChannelInput createFiltered(SharedChannelInput in)
{
return factory.createFiltered(in);
}
/**
* Creates a new filtered output channel end around an existing output channel end.
*
* @param out the existing channel end to create a filtered form of.
*/
public static FilteredChannelOutput createFiltered(ChannelOutput out)
{
return factory.createFiltered(out);
}
/**
* Creates a new filtered output channel end around an existing output channel end that can be
* shared by multiple processes.
*
* @param out the existing channel end to create a filtered form of.
* @return the new channel end with filtering ability.
*/
public static FilteredSharedChannelOutput createFiltered(SharedChannelOutput out)
{
return factory.createFiltered(out);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredOne2AnyChannel.java 0000644 0000000 0000000 00000005054 11105701167 022475 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.One2AnyChannel;
/**
* Interface for an Any2Any channel that supports both read and write filters.
*
* @author Quickstone Technologies Limited
*/
public interface FilteredOne2AnyChannel extends One2AnyChannel
{
/**
* Returns the control interface to manipulate the read filters.
*/
public ReadFiltered inFilter();
/**
* Returns the control interface to manipulate the write filters.
*/
public WriteFiltered outFilter();
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/PoisonFilter.java 0000644 0000000 0000000 00000005755 11105701167 020677 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
/**
* This filter will throw a PoisonException
* when filter(Object) is called. This can be
* used to prevent a channel from being written to or read from.
*
* @author Quickstone Technologies Limited
*/
public class PoisonFilter implements Filter
{
/**
* The message to be placed in the PoisonException raised.
*/
private String message;
/**
* Default message.
*/
private static String defaultMessage = "Channel end has been poisoned.";
/**
* Constructs a new filter with the default message.
*/
public PoisonFilter()
{
this(defaultMessage);
}
/**
* Constructs a new filter with a specific message.
*/
public PoisonFilter(String message)
{
this.message = message;
}
public Object filter(Object obj)
{
throw new PoisonFilterException(this.message);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredSharedChannelInputWrapper.java 0000644 0000000 0000000 00000010030 11105701167 024777 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.*;
/**
* This is wrapper for a SharedChannelInput that adds
* read filtering. Instances of this class can be safely used by
* multiple concurrent processes.
*
* @author Quickstone Technologies Limited
*/
public class FilteredSharedChannelInputWrapper
extends FilteredChannelInputWrapper
implements FilteredSharedChannelInput
{
/**
* The object used for synchronization by the methods here to protect the readers from each other
* when manipulating the filters and reading data.
*/
private Object synchObject;
/**
* Constructs a new wrapper for the given channel input end.
*
* @param in the existing channel end.
*/
public FilteredSharedChannelInputWrapper(SharedChannelInput in)
{
super(in);
synchObject = new Object();
}
public Object read()
{
synchronized (synchObject)
{
return super.read();
}
}
public void addReadFilter(Filter filter)
{
synchronized (synchObject)
{
super.addReadFilter(filter);
}
}
public void addReadFilter(Filter filter, int index)
{
synchronized (synchObject)
{
super.addReadFilter(filter, index);
}
}
public void removeReadFilter(Filter filter)
{
synchronized (synchObject)
{
super.removeReadFilter(filter);
}
}
public void removeReadFilter(int index)
{
synchronized (synchObject)
{
super.removeReadFilter(index);
}
}
public Filter getReadFilter(int index)
{
synchronized (synchObject)
{
return super.getReadFilter(index);
}
}
public int getReadFilterCount()
{
synchronized (synchObject)
{
return super.getReadFilterCount();
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredChannelFactory.java 0000644 0000000 0000000 00000032551 11105701167 022633 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.*;
import org.jcsp.util.ChannelDataStore;
/**
* ChannelFactory and
* ChannelArrayFactory interfaces. Instances of this class
* can therefore be used in place of the standard channel factory classes.Filter objects inserted into them. The same
* instances of the filters will be inserted into each channel.null if read/write filters are not required.One2OneChannel
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createOne2One(int)
*/
public One2OneChannel[] createOne2One(int n)
{
One2OneChannel[] toReturn = new One2OneChannel[n];
for (int i = 0; i < n; i++) {
toReturn[i] = createOne2One();
}
return toReturn;
}
/**
* Constructs and returns an array of Any2OneChannel
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createAny2One(int)
*/
public Any2OneChannel[] createAny2One(int n)
{
Any2OneChannel[] toReturn = new Any2OneChannel[n];
for (int i = 0; i < n; i++)
toReturn[i] = createAny2One();
return toReturn;
}
/**
* Constructs and returns an array of One2AnyChannel
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createOne2Any(int)
*/
public One2AnyChannel[] createOne2Any(int n)
{
One2AnyChannel[] toReturn = new One2AnyChannel[n];
for (int i = 0; i < n; i++)
toReturn[i] = createOne2Any();
return toReturn;
}
/**
* Constructs and returns an array of Any2AnyChannel
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createAny2Any(int)
*/
public Any2AnyChannel[] createAny2Any(int n)
{
Any2AnyChannel[] toReturn = new Any2AnyChannel[n];
for (int i = 0; i < n; i++)
toReturn[i] = createAny2Any();
return toReturn;
}
/**
* Creates a new One2One channel with the filtering options set for this factory and the specified
* data buffer.
*
* @param buffer the buffer implementation to use.
* @return the created filtered channel.
*/
public One2OneChannel createOne2One(ChannelDataStore buffer)
{
FilteredOne2OneChannelImpl toReturn =
new FilteredOne2OneChannelImpl(factory.createOne2One(buffer));
installFilters(toReturn.inFilter(), toReturn.outFilter());
return toReturn;
}
/**
* Creates a new Any2One channel with the filtering options set for this factory and the specified
* data buffer.
*
* @param buffer the buffer implementation to use.
* @return the created filtered channel.
*/
public Any2OneChannel createAny2One(ChannelDataStore buffer)
{
FilteredAny2OneChannelImpl toReturn =
new FilteredAny2OneChannelImpl(factory.createAny2One(buffer));
installFilters(toReturn.inFilter(), toReturn.outFilter());
return toReturn;
}
/**
* Creates a new One2Any channel with the filtering options set for this factory and the specified
* data buffer.
*
* @param buffer the buffer implementation to use.
* @return the created filtered channel.
*/
public One2AnyChannel createOne2Any(ChannelDataStore buffer)
{
FilteredOne2AnyChannelImpl toReturn =
new FilteredOne2AnyChannelImpl(factory.createOne2Any(buffer));
installFilters(toReturn.inFilter(), toReturn.outFilter());
return toReturn;
}
/**
* Creates a new Any2Any channel with the filtering options set for this factory and the specified
* data buffer.
*
* @param buffer the buffer implementation to use.
* @return the created filtered channel.
*/
public Any2AnyChannel createAny2Any(ChannelDataStore buffer)
{
FilteredAny2AnyChannelImpl toReturn =
new FilteredAny2AnyChannelImpl(factory.createAny2Any(buffer));
installFilters(toReturn.inFilter(), toReturn.outFilter());
return toReturn;
}
/**
* Constructs and returns an array of One2OneChannel
* objects with a given buffering behaviour.
*
* @param n the size of the array of channels.
* @param buffer the buffer implementation to use.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createOne2One(int)
*/
public One2OneChannel[] createOne2One(ChannelDataStore buffer, int n)
{
One2OneChannel[] toReturn = new One2OneChannel[n];
for (int i = 0; i < n; i++)
toReturn[i] = createOne2One(buffer);
return toReturn;
}
/**
* Constructs and returns an array of Any2OneChannel
* objects with a given buffering behaviour.
*
* @param n the size of the array of channels.
* @param buffer the buffer implementation to use.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createAny2One(int)
*/
public Any2OneChannel[] createAny2One(ChannelDataStore buffer, int n)
{
Any2OneChannel[] toReturn = new Any2OneChannel[n];
for (int i = 0; i < n; i++)
toReturn[i] = createAny2One(buffer);
return toReturn;
}
/**
* Constructs and returns an array of One2AnyChannel
* objects with a given buffering behaviour.
*
* @param n the size of the array of channels.
* @param buffer the buffer implementation to use.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createOne2Any(int)
*/
public One2AnyChannel[] createOne2Any(ChannelDataStore buffer, int n)
{
One2AnyChannel[] toReturn = new One2AnyChannel[n];
for (int i = 0; i < n; i++)
toReturn[i] = createOne2Any(buffer);
return toReturn;
}
/**
* Constructs and returns an array of Any2AnyChannel
* objects with a given buffering behaviour.
*
* @param n the size of the array of channels.
* @param buffer the buffer implementation to use.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createAny2Any(int)
*/
public Any2AnyChannel[] createAny2Any(ChannelDataStore buffer, int n)
{
Any2AnyChannel[] toReturn = new Any2AnyChannel[n];
for (int i = 0; i < n; i++)
toReturn[i] = createAny2Any(buffer);
return toReturn;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredOne2OneChannelImpl.java 0000644 0000000 0000000 00000006141 11105701167 023307 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.*;
/**
* Implements a One2One channel that supports filtering at each end.
*
* @author Quickstone Technologies Limited
*/
class FilteredOne2OneChannelImpl implements FilteredOne2OneChannel
{
/**
* The filtered input end of the channel.
*/
private FilteredAltingChannelInput in;
/**
* The filtered output end of the channel.
*/
private FilteredChannelOutput out;
/**
* Constructs a new filtered channel based on an existing channel.
*
* @param chan the existing channel.
*/
public FilteredOne2OneChannelImpl(One2OneChannel chan)
{
in = new FilteredAltingChannelInput(chan.in());
out = new FilteredChannelOutputWrapper(chan.out());
}
public AltingChannelInput in()
{
return in;
}
public ChannelOutput out()
{
return out;
}
public ReadFiltered inFilter()
{
return in;
}
public WriteFiltered outFilter()
{
return out;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredChannelInputWrapper.java 0000644 0000000 0000000 00000007667 11105701167 023676 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.*;
/**
* Wrapper for an input channel end to include read filtering functionality.
*
* @author Quickstone Technologies Limited
*/
class FilteredChannelInputWrapper
extends ChannelInputWrapper
implements FilteredChannelInput
{
/**
* Set of read filters installed.
*/
private FilterHolder filters = null;
/**
* Constructs a new FilteredChannelInputWrapper around the existing channel end.
*
* @param in channel end to create the wrapper around.
*/
FilteredChannelInputWrapper(ChannelInput in)
{
super(in);
}
public Object read()
{
Object toFilter = super.read();
for (int i = 0; filters != null && i < filters.getFilterCount(); i++)
toFilter = filters.getFilter(i).filter(toFilter);
return toFilter;
}
public void addReadFilter(Filter filter)
{
if (filters == null)
filters = new FilterHolder();
filters.addFilter(filter);
}
public void addReadFilter(Filter filter, int index)
{
if (filters == null)
filters = new FilterHolder();
filters.addFilter(filter, index);
}
public void removeReadFilter(Filter filter)
{
if (filters == null)
filters = new FilterHolder();
filters.removeFilter(filter);
}
public void removeReadFilter(int index)
{
if (filters == null)
filters = new FilterHolder();
filters.removeFilter(index);
}
public Filter getReadFilter(int index)
{
if (filters == null)
filters = new FilterHolder();
return filters.getFilter(index);
}
public int getReadFilterCount()
{
if (filters == null)
return 0;
return filters.getFilterCount();
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilterHolder.java 0000644 0000000 0000000 00000015172 11105701167 020637 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
/**
* Storage scheme for a set of filters that is dynamically sized and supports insert and remove
* operations to keep the filters in a contiguous block.
*
* @author Quickstone Technologies Limited
*/
class FilterHolder
{
/**
* The array of filters. The installed filters are in a block at the start of the array.
*/
private Filter[] filters;
/**
* Number of filters currently installed.
*/
private int count = 0;
/**
* Constructs a new FilterHolder with an intial capacity of 2.
*/
FilterHolder()
{
this(2);
}
/**
* Constructs a new FilterHolder with the given initial capacity.
*
* @param initialSize the initial size for the array.
*/
FilterHolder(int initialSize)
{
filters = new Filter[initialSize];
}
/**
* Adds a filter to the end of the array, possibly enlarging it if it is full.
*
* @param filter the filter to add.
*/
public void addFilter(Filter filter)
{
makeSpace();
filters[count] = filter;
count++;
}
/**
* Adds a filter at the given index. If the index is past the end of the array, the filter is placed
* at the end of the array. If the index is in use, filter is inserted, shifting the existing ones.
* If necessary, the array may be enlarged.
*
* @param filter the filter to add.
* @param index the position to add the filter.
*/
public void addFilter(Filter filter, int index)
{
if (index >= count)
//add filter to end
addFilter(filter);
else
{
makeSpace();
//shift all elements from specifed index and above along one
System.arraycopy(filters, index, filters, index + 1, count - index);
filters[index] = filter;
count++;
}
}
/**
* Removes a filter from the set. The first filter, f, satisfying the condition
* f.equals (filter) is removed and the remaining filters shifted to close the gap.
*
* @param filter the filter to remove.
*/
public void removeFilter(Filter filter)
{
if (filter == null)
throw new IllegalArgumentException("filter parameter cannot be null");
for (int i = 0; i < count; i++)
if (filters[i].equals(filter))
{
removeFilter(i);
return;
}
throw new IllegalArgumentException("supplied filter not installed.");
}
/**
* Removes a filter at a given index. The remaining filters are shifted to close the gap.
*
* @param index the array index to remove the filter.
*/
public void removeFilter(int index)
{
if (index > (count - 1) || index < 0)
throw new IndexOutOfBoundsException("Invalid filter index.");
filters[index] = null;
//if filter not the last item in the array
//then need to shift all elements after the
//specified filter
if (index < filters.length - 1)
{
System.arraycopy(filters, index + 1, filters, index, count - index - 1);
count--;
}
else
{
count--;
compact();
}
}
/**
* Returns a filter at the given array index.
*/
public Filter getFilter(int index)
{
return filters[index];
}
/**
* Returns the number of filters current installed.
*/
public int getFilterCount()
{
return count;
}
/**
* Enlarges the size of the array to make room for more filters. Currently the array is doubled
* in size.
*/
private void makeSpace()
{
//if array of filters is full - double size
if (count == filters.length)
{
Filter[] filters = new Filter[count * 2];
System.arraycopy(this.filters, 0, filters, 0, this.filters.length);
this.filters = filters;
}
}
/**
* Shrinks the array to save space if it is 75% empty.
*/
private void compact()
{
int newSize = count + 1;
if (count < (filters.length / 4) && newSize < filters.length)
{
//create a new array which
Filter[] filters = new Filter[newSize];
System.arraycopy(this.filters, 0, filters, 0, count);
this.filters = filters;
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredAny2OneChannelImpl.java 0000644 0000000 0000000 00000006177 11105701167 023326 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.*;
/**
* This wraps up an Any2OneChannel object so that its
* input and output ends are separate objects. Both ends of the channel
* have filtering enabled.
*
* @author Quickstone Technologies Limited
*/
class FilteredAny2OneChannelImpl implements FilteredAny2OneChannel
{
/**
* The input end of the channel.
*/
private FilteredAltingChannelInput in;
/**
* The output end of the channel.
*/
private FilteredSharedChannelOutput out;
/**
* Constructs a new filtered channel over the top of an existing channel.
*/
public FilteredAny2OneChannelImpl(Any2OneChannel chan)
{
in = new FilteredAltingChannelInput(chan.in());
out = new FilteredSharedChannelOutputWrapper(chan.out());
}
public AltingChannelInput in()
{
return in;
}
public SharedChannelOutput out()
{
return out;
}
public ReadFiltered inFilter()
{
return in;
}
public WriteFiltered outFilter()
{
return out;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredChannelOutput.java 0000644 0000000 0000000 00000004455 11105701167 022526 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.ChannelOutput;
/**
* Interface for a channel output end that supports write filtering operations.
*
* @author Quickstone Technologies Limited
*/
public interface FilteredChannelOutput extends ChannelOutput, WriteFiltered
{
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/PoisonFilterException.java 0000644 0000000 0000000 00000000555 10660320603 022544 0 ustar package org.jcsp.util.filter;
import org.jcsp.lang.PoisonException;
/**
*
* @deprecated Use poison directly instead
*/
public class PoisonFilterException extends PoisonException {
public PoisonFilterException(String message) {
//In lieu of knowing a specific poison strength,
//we supply the maximum:
super(Integer.MAX_VALUE);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredOne2AnyChannelImpl.java 0000644 0000000 0000000 00000006346 11105701167 023324 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.*;
/**
* Implements an One2Any channel that supports filtering at each end.
*
* @see org.jcsp.lang.One2AnyChannel
* @see org.jcsp.util.filter.ReadFiltered
* @see org.jcsp.util.filter.WriteFiltered
*
* @author Quickstone Technologies Limited
*/
class FilteredOne2AnyChannelImpl implements FilteredOne2AnyChannel
{
/**
* The filtered input end of the channel.
*/
private FilteredSharedChannelInput in;
/**
* The filtered output end of the channel.
*/
private FilteredChannelOutput out;
/**
* Constructs a new filtered channel from an existing channel.
*
* @param chan the existing channel.
*/
public FilteredOne2AnyChannelImpl(One2AnyChannel chan)
{
in = new FilteredSharedChannelInputWrapper(chan.in());
out = new FilteredChannelOutputWrapper(chan.out());
}
public SharedChannelInput in()
{
return in;
}
public ChannelOutput out()
{
return out;
}
public ReadFiltered inFilter()
{
return in;
}
public WriteFiltered outFilter()
{
return out;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredChannel.java 0000644 0000000 0000000 00000021377 11105701167 021307 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.util.*;
/**
* Static factory for creating filtered channels.
*
* @author Quickstone Technologies Limited
*/
public class FilteredChannel
{
/**
* Default factory for creating the channels.
*/
private static FilteredChannelFactory factory = new FilteredChannelFactory();
/**
* Private constructor to prevent any instances of this static factory from being created.
*/
private FilteredChannel()
{
//private constructor to stop construction
}
/**
* Creates a new One2One filtered channel.
*
* @return the created channel.
*/
public static FilteredOne2OneChannel createOne2One()
{
return (FilteredOne2OneChannel)factory.createOne2One();
}
/**
* Creates a new Any2One filtered channel.
*
* @return the created channel.
*/
public static FilteredAny2OneChannel createAny2One()
{
return (FilteredAny2OneChannel)factory.createAny2One();
}
/**
* Creates a new One2Any filtered channel.
*
* @return the created channel.
*/
public static FilteredOne2AnyChannel createOne2Any()
{
return (FilteredOne2AnyChannel)factory.createOne2Any();
}
/**
* Creates a new Any2Any filtered channel.
*
* @return the created channel.
*/
public static FilteredAny2AnyChannel createAny2Any()
{
return (FilteredAny2AnyChannel)factory.createAny2Any();
}
/**
* Constructs and returns an array of One2OneChannel
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createOne2One(int)
*/
public static FilteredOne2OneChannel[] createOne2One(int n)
{
return (FilteredOne2OneChannel[])factory.createOne2One(n);
}
/**
* Constructs and returns an array of Any2OneChannel
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createAny2One(int)
*/
public static FilteredAny2OneChannel[] createAny2One(int n)
{
return (FilteredAny2OneChannel[])factory.createAny2One(n);
}
/**
* Constructs and returns an array of One2AnyChannel
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createOne2Any(int)
*/
public static FilteredOne2AnyChannel[] createOne2Any(int n)
{
return (FilteredOne2AnyChannel[])factory.createOne2Any(n);
}
/**
* Constructs and returns an array of Any2AnyChannel
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createAny2Any(int)
*/
public static FilteredAny2AnyChannel[] createAny2Any(int n)
{
return (FilteredAny2AnyChannel[])factory.createAny2Any(n);
}
/**
* Creates a new One2One filtered channel with a given buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @return the created channel.
*/
public static FilteredOne2OneChannel createOne2One(ChannelDataStore buffer)
{
return (FilteredOne2OneChannel)factory.createOne2One(buffer);
}
/**
* Creates a new Any2One filtered channel with a given buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @return the created channel.
*/
public static FilteredAny2OneChannel createAny2One(ChannelDataStore buffer)
{
return (FilteredAny2OneChannel)factory.createAny2One(buffer);
}
/**
* Creates a new One2Any filtered channel with a given buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @return the created channel.
*/
public static FilteredOne2AnyChannel createOne2Any(ChannelDataStore buffer)
{
return (FilteredOne2AnyChannel)factory.createOne2Any(buffer);
}
/**
* Creates a new Any2Any filtered channel with a given buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @return the created channel.
*/
public static FilteredAny2AnyChannel createAny2Any(ChannelDataStore buffer)
{
return (FilteredAny2AnyChannel)factory.createAny2Any(buffer);
}
/**
* Constructs and returns an array of One2OneChannel
* objects using a given buffer.
*
* @param n the size of the array of channels.
* @param buffer the buffer implementation to use.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createOne2One(int)
*/
public static FilteredOne2OneChannel[] createOne2One(ChannelDataStore buffer, int n)
{
return (FilteredOne2OneChannel[])factory.createOne2One(buffer, n);
}
/**
* Constructs and returns an array of Any2OneChannel
* objects with a given buffer.
*
* @param n the size of the array of channels.
* @param buffer the buffer implementation to use.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createAny2One(int)
*/
public static FilteredAny2OneChannel[] createAny2One(ChannelDataStore buffer, int n)
{
return (FilteredAny2OneChannel[])factory.createAny2One(buffer, n);
}
/**
* Constructs and returns an array of One2AnyChannel
* objects with a given buffer.
*
* @param n the size of the array of channels.
* @param buffer the buffer implementation to use.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createOne2Any(int)
*/
public static FilteredOne2AnyChannel[] createOne2Any(ChannelDataStore buffer, int n)
{
return (FilteredOne2AnyChannel[])factory.createOne2Any(buffer, n);
}
/**
* Constructs and returns an array of Any2AnyChannel
* objects with a given buffer.
*
* @param n the size of the array of channels.
* @param buffer the buffer implementation to use.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createAny2Any(int)
*/
public static FilteredAny2AnyChannel[] createAny2Any(ChannelDataStore buffer, int n)
{
return (FilteredAny2AnyChannel[]) factory.createAny2Any(buffer, n);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredAny2OneChannel.java 0000644 0000000 0000000 00000005255 11105701167 022500 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.Any2OneChannel;
/**
* Interface for an Any2One channel that supports filtering operations at each end.
*
* @see org.jcsp.lang.Any2OneChannel
* @see org.jcsp.util.filter.ReadFiltered
* @see org.jcsp.util.filter.WriteFiltered
*
* @author Quickstone Technologies Limited
*/
public interface FilteredAny2OneChannel extends Any2OneChannel
{
/**
* Returns an interface for configuring read filters on the channel.
*/
public ReadFiltered inFilter();
/**
* Returns an interface for configuring write filters on the channel.
*/
public WriteFiltered outFilter();
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredChannelEndFactory.java 0000644 0000000 0000000 00000010670 11105701167 023260 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.*;
/**
* FilteredChannelEnd may be more convenient.FilteredChannelEndFactory.
*/
public FilteredChannelEndFactory()
{
super();
}
/**
* Creates a new filtered channel input end around an existing channel end. The created channel end
* can be used as a guard in an Alternative.
*
* @param in the existing channel end.
* @return the created channel end.
*/
public FilteredAltingChannelInput createFiltered(AltingChannelInput in)
{
return new FilteredAltingChannelInput(in);
}
/**
* Creates a new filtered channel input end around an existing channel end.
*
* @param in the existing channel end.
* @return the created channel end.
*/
public FilteredChannelInput createFiltered(ChannelInput in)
{
return new FilteredChannelInputWrapper(in);
}
/**
* Creates a new filtered channel input end around an existing channel end. The created channel end
* can be shared by multiple processes.
*
* @param in the existing channel end.
* @return the created channel end.
*/
public FilteredSharedChannelInput createFiltered(SharedChannelInput in)
{
return new FilteredSharedChannelInputWrapper(in);
}
/**
* Creates a new filtered channel output end around an existing channel end.
*
* @param out the existing channel end.
* @return the created channel end.
*/
public FilteredChannelOutput createFiltered(ChannelOutput out)
{
return new FilteredChannelOutputWrapper(out);
}
/**
* Creates a new filtered channel output end around an existing channel end. The created channel end
* can be shared by multiple processes.
*
* @param out the existing channel end.
* @return the created channel end.
*/
public FilteredSharedChannelOutput createFiltered(SharedChannelOutput out)
{
return new FilteredSharedChannelOutputWrapper(out);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredAltingChannelInput.java 0000644 0000000 0000000 00000010163 11105701167 023455 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.*;
/**
* Implements an AltingChannelInput channel end that also supports read filters.
*
* @see org.jcsp.lang.AltingChannelInput
* @see org.jcsp.util.filter.ReadFiltered
*
* @author Quickstone Technologies Limited
*/
public class FilteredAltingChannelInput
extends AltingChannelInputWrapper
implements FilteredChannelInput
{
/**
* Holds the filters installed for the read end of this channel.
*/
private FilterHolder filters = null;
/**
* Constructs a new channel end that supports filtering by wrapping up an existing channel end.
*
* @param altingChannelInput the existing channel end.
*/
FilteredAltingChannelInput(AltingChannelInput altingChannelInput)
{
super(altingChannelInput);
}
public Object read()
{
Object toFilter = super.read();
for (int i = 0; filters != null && i < filters.getFilterCount(); i++)
toFilter = filters.getFilter(i).filter(toFilter);
return toFilter;
}
public void addReadFilter(Filter filter)
{
if (filters == null)
filters = new FilterHolder();
filters.addFilter(filter);
}
public void addReadFilter(Filter filter, int index)
{
if (filters == null)
filters = new FilterHolder();
filters.addFilter(filter, index);
}
public void removeReadFilter(Filter filter)
{
if (filters == null)
filters = new FilterHolder();
filters.removeFilter(filter);
}
public void removeReadFilter(int index)
{
if (filters == null)
filters = new FilterHolder();
filters.removeFilter(index);
}
public Filter getReadFilter(int index)
{
if (filters == null)
filters = new FilterHolder();
return filters.getFilter(index);
}
public int getReadFilterCount()
{
if (filters == null)
return 0;
return filters.getFilterCount();
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredChannelOutputWrapper.java 0000644 0000000 0000000 00000007634 11105701167 024071 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.*;
/**
* Wrapper for an output channel end to include write filtering ability.
*
* @author Quickstone Technologies Limited
*/
class FilteredChannelOutputWrapper
extends ChannelOutputWrapper
implements FilteredChannelOutput
{
/**
* Set of write filters installed.
*/
private FilterHolder filters = null;
/**
* Constructs a new FilteredChannelOutputWrapper around the given output channel end.
*
* @param out the existing output channel.
*/
public FilteredChannelOutputWrapper(ChannelOutput out)
{
super(out);
}
public void write(Object data)
{
for (int i = 0; filters != null && i < filters.getFilterCount(); i++)
data = filters.getFilter(i).filter(data);
super.write(data);
}
public void addWriteFilter(Filter filter)
{
if (filters == null)
filters = new FilterHolder();
filters.addFilter(filter);
}
public void addWriteFilter(Filter filter, int index)
{
if (filters == null)
filters = new FilterHolder();
filters.addFilter(filter, index);
}
public void removeWriteFilter(Filter filter)
{
if (filters == null)
filters = new FilterHolder();
filters.removeFilter(filter);
}
public void removeWriteFilter(int index)
{
if (filters == null)
filters = new FilterHolder();
filters.removeFilter(index);
}
public Filter getWriteFilter(int index)
{
if (filters == null)
filters = new FilterHolder();
return filters.getFilter(index);
}
public int getWriteFilterCount()
{
if (filters == null)
return 0;
return filters.getFilterCount();
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/filter/FilteredSharedChannelOutputWrapper.java 0000644 0000000 0000000 00000010025 11105701167 025204 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.filter;
import org.jcsp.lang.*;
/**
* This is wrapper for a SharedChannelOutput that adds
* write filtering. Instances of this class can be safely used by
* multiple concurrent processes.
*
* @author Quickstone Technologies Limited
*/
public class FilteredSharedChannelOutputWrapper
extends FilteredChannelOutputWrapper
implements FilteredSharedChannelOutput
{
/**
* The synchronization object to protect the writers from each other when they read data or update
* the write filters.
*/
private Object synchObject;
/**
* Constructs a new wrapper for the given channel output end.
*
* @param out the existing channel end.
*/
public FilteredSharedChannelOutputWrapper(SharedChannelOutput out)
{
super(out);
synchObject = new Object();
}
public void write(Object data)
{
synchronized (synchObject)
{
super.write(data);
}
}
public void addWriteFilter(Filter filter)
{
synchronized (synchObject)
{
super.addWriteFilter(filter);
}
}
public void addWriteFilter(Filter filter, int index)
{
synchronized (synchObject)
{
super.addWriteFilter(filter, index);
}
}
public void removeWriteFilter(Filter filter)
{
synchronized (synchObject)
{
super.removeWriteFilter(filter);
}
}
public void removeWriteFilter(int index)
{
synchronized (synchObject)
{
super.removeWriteFilter(index);
}
}
public Filter getWriteFilter(int index)
{
synchronized (synchObject)
{
return super.getWriteFilter(index);
}
}
public int getWriteFilterCount()
{
synchronized (synchObject)
{
return super.getWriteFilterCount();
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/BufferSizeError.java 0000644 0000000 0000000 00000006755 11105701167 020054 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util;
/**
* This is thrown if an attempt is made to create some variety of buffered channel
* with a zero or negative sized buffer.
*
* Description
* Buffered channels must have (usually non-zero) positive sized buffers.
* The following constructions will all throw this {@link java.lang.Error}:
*
* One2OneChannel c = Channel.one2one (new Buffer (-42)); // must be >= 0
* One2OneChannel c = Channel.one2one (new OverFlowingBuffer (-42)); // must be > 0
* One2OneChannel c = Channel.one2one (new OverWriteOldestBuffer (-42)); // must be > 0
* One2OneChannel c = Channel.one2one (new OverWritingBuffer (-42)); // must be > 0
* One2OneChannel c = Channel.one2one (new InfiniteBuffer (-42)); // must be > 0
*
* Zero-buffered non-overwriting channels are, of course, the default channel semantics.
* The following constructions are all legal and equivalent:
*
* One2OneChannel c = Channel.one2one ();
* One2OneChannel c = Channel.one2one (new ZeroBuffer ()); // less efficient
* One2OneChannel c = Channel.one2one (new Buffer (0)); // less efficient
*
* No action should be taken to catch BufferSizeError.
* Application code generating it is in error and needs correcting.
*
* @author P.H. Welch
*/
public class BufferSizeError extends Error
{
public BufferSizeError (String s)
{
super (s);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/package.html 0000644 0000000 0000000 00000001756 11077376055 016424 0 ustar
This provides classes and interfaces to customise the semantics of Object
channels.
Description
* OverWriteOldestBuffer is an implementation of ChannelDataStore that yields
* a FIFO buffered semantics for a channel. When empty, the channel blocks readers.
* When full, a writer will overwrite the oldest item left unread in the channel.
* See the static construction methods of {@link org.jcsp.lang.Channel}
* ({@link org.jcsp.lang.Channel#one2one(org.jcsp.util.ChannelDataStore)} etc.).
*
*
*
* @return The oldest value in the buffer at this time
*/
public Object startGet()
{
valueWrittenWhileFull = false;
return buffer[firstIndex];
}
/**
* This ends an extended rendezvous by the reader.
*
* @see #startGet()
*/
public void endGet()
{
if (false == valueWrittenWhileFull) {
//Our data hasn't been over-written so remove it:
buffer[firstIndex] = null;
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
}
}
/**
* Puts a new Object into the OverWriteOldestBuffer.
* Description
* OverWriteOldestBufferInt is an implementation of ChannelDataStoreInt that yields
* a FIFO buffered semantics for a channel. When empty, the channel blocks readers.
* When full, a writer will overwrite the oldest item left unread in the channel.
* See the static construction methods of {@link org.jcsp.lang.Channel}
* ({@link org.jcsp.lang.Channel#one2oneInt(org.jcsp.util.ints.ChannelDataStoreInt)} etc.).
*
*
*
* @return The oldest value in the buffer at this time
*/
public int startGet()
{
valueWrittenWhileFull = false;
return buffer[firstIndex];
}
/**
* See {@link #startGet()} for a description of the semantics of this method.
*/
public void endGet()
{
if (false == valueWrittenWhileFull) {
//Our data hasn't been over-written so remove it:
firstIndex = (firstIndex + 1) % buffer.length;
counter--;
}
}
/**
* Puts a new int into the OverWriteOldestBufferInt.
* Description
* BufferInt is an implementation of ChannelDataStoreInt that yields
* a blocking FIFO buffered semantics for a channel.
* See the static construction methods of {@link org.jcsp.lang.Channel}
* ({@link org.jcsp.lang.Channel#one2oneInt(org.jcsp.util.ints.ChannelDataStoreInt)} etc.).
* Description
* Buffered channels must have (usually non-zero) positive sized buffers.
* The following constructions will all throw this {@link java.lang.Error}:
*
* One2OneChannelInt c = Channel.one2oneInt (new BufferInt (-42)); // must be >= 0
* One2OneChannelInt c = Channel.one2oneInt (new OverFlowingBufferInt (-42)); // must be > 0
* One2OneChannelInt c = Channel.one2oneInt (new OverWriteOldestBufferInt (-42)); // must be > 0
* One2OneChannelInt c = Channel.one2oneInt (new OverWritingBufferInt (-42)); // must be > 0
* One2OneChannelInt c = Channel.one2oneInt (new InfiniteBufferInt (-42)); // must be > 0
*
* Zero-buffered non-overwriting channels are, of course, the default channel semantics.
* The following constructions are all legal and equivalent:
*
* One2OneChannelInt c = Channel.one2oneInt ();
* One2OneChannelInt c = Channel.one2oneInt (new ZeroBufferInt ()); // less efficient
* One2OneChannelInt c = Channel.one2oneInt (new BufferInt (0)); // less efficient
*
* No action should be taken to catch BufferSizeError.
* Application code generating it is in error and needs correcting.
*
* @author P.H. Welch
*/
public class BufferIntSizeError extends Error
{
/**
* Constructs a new BufferIntSizeError with the specified detail message.
*
* @param s the detail message.
*/
public BufferIntSizeError(String s)
{
super(s);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/util/ints/InfiniteBufferInt.java 0000644 0000000 0000000 00000017111 11105701167 021311 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.util.ints;
import java.io.Serializable;
/**
* This is used to create a buffered integer channel that always accepts and
* never loses any input.
* Description
* InfiniteBufferInt is an implementation of ChannelDataStoreInt that yields
* a FIFO buffered semantics for a channel. When empty, the channel blocks readers.
* However, its capacity is infinite (expanding to whatever is needed so far as
* the underlying memory system will permit). So, it never gets full and blocks
* a writer.
* See the static construction methods of {@link org.jcsp.lang.Channel}
* ({@link org.jcsp.lang.Channel#one2oneInt(org.jcsp.util.ints.ChannelDataStoreInt)} etc.).
* Description
* ZeroBufferInt is an implementation of ChannelDataStoreInt that yields
* the standard CSP semantics for a channel -- that is zero buffered with
* direct synchronisation between reader and writer. Unless specified otherwise,
* this is the default behaviour for channels.
* See the static construction methods of {@link org.jcsp.lang.Channel}
* ({@link org.jcsp.lang.Channel#one2oneInt(org.jcsp.util.ints.ChannelDataStoreInt)} etc.).
* Description
* OverFlowingBufferInt is an implementation of ChannelDataStoreInt that yields
* a FIFO buffered semantics for a channel. When empty, the channel blocks readers.
* When full, a writer will be accepted but the written value overflows the buffer
* and is lost to the channel.
* See the static construction methods of {@link org.jcsp.lang.Channel}
* ({@link org.jcsp.lang.Channel#one2oneInt(org.jcsp.util.ints.ChannelDataStoreInt)} etc.).
* Description
* OverWritingBufferInt is an implementation of ChannelDataStoreInt that yields
* a FIFO buffered semantics for a channel. When empty, the channel blocks readers.
* When full, a writer will overwrite the latest item written to the channel.
* See the static construction methods of {@link org.jcsp.lang.Channel}
* ({@link org.jcsp.lang.Channel#one2oneInt(org.jcsp.util.ints.ChannelDataStoreInt)} etc.).
* Description
* ChannelDataStoreInt defines the interface to the logic used by
* the integer channels defined in the org.jcsp.lang package to manage
* the data being communicated.
* Description
* InfiniteBuffer is an implementation of ChannelDataStore that yields
* a FIFO buffered semantics for a channel. When empty, the channel blocks readers.
* However, its capacity is infinite (expanding to whatever is needed so far as
* the underlying memory system will permit). So, it never gets full and blocks
* a writer.
* See the static construction methods of {@link org.jcsp.lang.Channel}
* ({@link org.jcsp.lang.Channel#one2one(org.jcsp.util.ChannelDataStore)} etc.).
* Description
* ZeroBuffer is an implementation of ChannelDataStore that yields
* the standard CSP semantics for a channel -- that is zero buffered with
* direct synchronisation between reader and writer. Unless specified otherwise,
* this is the default behaviour for channels.
* See the static construction methods of {@link org.jcsp.lang.Channel}
* ({@link org.jcsp.lang.Channel#one2one(org.jcsp.util.ChannelDataStore)} etc.).
* Description
* It is an implementation of ChannelDataStore that yields
* a FIFO buffered semantics for a channel. When empty, the channel blocks readers.
* When full, a writer will overwrite the latest item written to the channel.
* See the static construction methods of {@link org.jcsp.lang.Channel}
* ({@link org.jcsp.lang.Channel#one2one(org.jcsp.util.ChannelDataStore)} etc.).
* Description
* It is an implementation of ChannelDataStore that yields
* a FIFO buffered semantics for a channel. When empty, the channel blocks readers.
* When full, a writer will be accepted but the written value overflows the buffer
* and is lost to the channel.
* See the static construction methods of {@link org.jcsp.lang.Channel}
* ({@link org.jcsp.lang.Channel#one2one(org.jcsp.util.ChannelDataStore)} etc.).
* n One2One channels with the
* specified buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @param n the size of the array.
* @return the created array of channels.
*/
public One2OneChannel[] createOne2One(ChannelDataStore buffer, int n);
/**
* Creates a populated array of n Any2One channels with the specified
* buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @param n the size of the array.
* @return the created array of channels.
*/
public Any2OneChannel[] createAny2One(ChannelDataStore buffer, int n);
/**
* Creates a populated array of n One2Any channels with the specified
* buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @param n the size of the array.
* @return the created array of channels.
*/
public One2AnyChannel[] createOne2Any(ChannelDataStore buffer, int n);
/**
* Creates a populated array of n Any2Any channels with the specified
* buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @param n the size of the array.
* @return the created array of channels.
*/
public Any2AnyChannel[] createAny2Any(ChannelDataStore buffer, int n);
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Skip.java 0000644 0000000 0000000 00000006712 11113406002 015626 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This is a process that immediately terminates and
* a {@link Guard} that is always ready.
* Description
* Skip is a process that starts, engages in no events, performs no
* computation and terminates.
* Object to send to the server.
*/
public void request(Object data) throws IllegalStateException
{
if (currentClientState == CLIENT_STATE_MADE_REQ)
throw new IllegalStateException
("Cannot call request(Object) twice without calling reply().");
//this will claim the use of the client
if (currentClientState == CLIENT_STATE_CLOSED)
{
claim();
msgOpen.data = data;
msgOpen.replyChannel = backToClient;
openToServer.write(msgOpen);
}
else
{
msg.data = data;
reqToServer.write(msg);
}
currentClientState = CLIENT_STATE_MADE_REQ;
}
/**
* Receives some data back from the server after
* request(Object) has been called.
*
* @return the Object sent from the server.
*/
public Object reply() throws IllegalStateException
{
if (currentClientState != CLIENT_STATE_MADE_REQ)
throw new IllegalStateException
("Cannot call reply() on a ConnectionClient that is not waiting for a reply.");
ConnectionServerMessage serverReply = (ConnectionServerMessage)fromServer.read();
//check whether the server closed the connection
currentClientState = serverReply.open ? CLIENT_STATE_OPEN : CLIENT_STATE_CLOSED;
if (serverReply.open)
currentClientState = CLIENT_STATE_OPEN;
else
{
currentClientState = CLIENT_STATE_CLOSED;
release();
}
return serverReply.data;
}
/**
* Returns whether the server has kept its end of the Connection open.
* This should only be called after a call to reply() and
* before any other Connection method is called.
*
* @return true iff the server has kept the connection
* open.
*/
public boolean isOpen() throws IllegalStateException
{
if (currentClientState == CLIENT_STATE_MADE_REQ)
throw new IllegalStateException
("Can only call isOpen() just after a reply has been received from the server.");
return currentClientState == CLIENT_STATE_OPEN;
}
/**
* This claims a lock on the client.
* This implementation does nothing as instances of this
* class are only meant to be used with One2?Connection objects.
*
*/
protected void claim()
{
}
/**
* This releases a lock on the client.
* This implementation does nothing as instances of this
* class are only meant to be used with One2?Connection objects.
*
*/
protected void release()
{
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/ConnectionServerMessage.java 0000644 0000000 0000000 00000004323 11105701167 021522 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import java.io.Serializable;
/**
* @author Quickstone Technologies Limited
*/
class ConnectionServerMessage implements Serializable
{
boolean open;
Object data;
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/RejectableBufferedOne2AnyChannel.java 0000644 0000000 0000000 00000006744 11105701167 023130 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.ChannelDataStore;
/**
* reject operation. One of the readers may call
* the reject method to force any current writer to abort with a
* ChannelDataRejectedException (unless there is already a read which will cause
* completion of the write). Subsequent read and write attempts will immediately cause a
* ChannelDataRejectedException.RejectableBufferedOne2AnyChannel
*
* @param data the buffer implementation to use.
*/
public RejectableBufferedOne2AnyChannel(ChannelDataStore data)
{
innerChannel = (BufferedOne2AnyChannel)Channel.one2any(data);
}
public RejectableChannelInput in() {
return new RejectableChannelInputImpl(innerChannel,0);
}
public RejectableChannelOutput out() {
return new RejectableChannelOutputImpl(innerChannel,0);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Any2AnyImpl.java 0000644 0000000 0000000 00000010646 11113671251 017036 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
class Any2AnyImpl implements Any2AnyChannel, ChannelInternals {
private ChannelInternals channel;
/** The mutex on which readers must synchronize */
private final Mutex readMutex = new Mutex();
private final Object writeMonitor = new Object();
Any2AnyImpl(ChannelInternals _channel) {
channel = _channel;
}
public SharedChannelInput in() {
return new SharedChannelInputImpl(this,0);
}
public SharedChannelOutput out() {
return new SharedChannelOutputImpl(this,0);
}
public void endRead() {
channel.endRead();
readMutex.release();
}
public Object read() {
readMutex.claim();
// A poison exception might be thrown, hence the try/finally:
try
{
return channel.read();
}
finally
{
readMutex.release();
}
}
//begin never used:
public boolean readerDisable() {
return false;
}
public boolean readerEnable(Alternative alt) {
return false;
}
public boolean readerPending() {
return false;
}
//end never used
public void readerPoison(int strength) {
readMutex.claim();
channel.readerPoison(strength);
readMutex.release();
}
public Object startRead() {
readMutex.claim();
try
{
return channel.startRead();
}
catch (RuntimeException e)
{
channel.endRead();
readMutex.release();
throw e;
}
}
public void write(Object obj) {
synchronized (writeMonitor) {
channel.write(obj);
}
}
public void writerPoison(int strength) {
synchronized (writeMonitor) {
channel.writerPoison(strength);
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/BufferedChannelIntArrayFactory.java 0000644 0000000 0000000 00000007655 11105701167 022757 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.ints.*;
/**
* Defines an interface for a factory that can create arrays of integer carrying channels with
* user-definable buffering semantics.
*
* @author Quickstone Technologies Limited
*
* @deprecated These channel factories are deprecated in favour of the new one2one() methods in the Channel class.
*/
public interface BufferedChannelIntArrayFactory
{
/**
* Creates a populated array of n One2One channels with the
* specified buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @param n the size of the array.
* @return the created array of channels.
*/
public One2OneChannelInt[] createOne2One(ChannelDataStoreInt buffer, int n);
/**
* Creates a populated array of n Any2One channels with the
* specified buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @param n the size of the array.
* @return the created array of channels.
*/
public Any2OneChannelInt[] createAny2One(ChannelDataStoreInt buffer, int n);
/**
* Creates a populated array of n One2Any channels with the
* specified buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @param n the size of the array.
* @return the created array of channels.
*/
public One2AnyChannelInt[] createOne2Any(ChannelDataStoreInt buffer, int n);
/**
* Creates a populated array of n Any2Any channels with the
* specified buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @param n the size of the array.
* @return the created array of channels.
*/
public Any2AnyChannelInt[] createAny2Any(ChannelDataStoreInt buffer, int n);
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/SharedChannelOutput.java 0000644 0000000 0000000 00000004731 11113671251 020651 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This is the same as {@link ChannelOutput} except that it is guaranteed
* safe to pass on to more than one internal process for parallel writing.
* ConnectionClient objects which can
* have their receive() method alted over.
* AltingConnectionClient
* objects can be constructed using one of the Connection factory
* mechanisms. See {@link Connection} and
* {@link StandardConnectionFactory}.
* ConnectionServer implementations are likely to be
* implemented over channels. Multiple channels from the client
* to server may be used; one could be used for the initial
* connection while another one could be used for data requests.
* Description
* Currently, there is only one cause: we cannot invoke 'priSelect' when there is
* an AltingBarrier in the Guard array.
*
* @author P.H. Welch
*/
//}}}
public class AlternativeError extends Error {
public AlternativeError (String s) {
super (s);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Stop.java 0000644 0000000 0000000 00000007003 11113406002 015637 0 ustar
/*************************************************************************
* *
* JCSP ("CSP for Java") libraries *
* Copyright (C) 1996-2001 Peter Welch and Paul Austin. *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Lesser General Public *
* License as published by the Free Software Foundation; either *
* version 2.1 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the Free Software *
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, *
* USA. *
* *
* Author contact: P.H.Welch@kent.ac.uk *
* *
*************************************************************************/
package org.jcsp.lang;
//{{{ javadoc
/**
* This is a process that starts, engages in no events, performs no
* computation but refuses to terminate.
* Description
* Stop is a process that starts, engages in no events, performs no
* computation but refuses to terminate.
* ChannelInput object cannot be cast into the
* ChannelOutput object and vice-versa.RiskyChannelIntFactory to construct the underlying
* raw channels.One2OneChannelInt object.
*
* @return the channel object.
*
* @see org.jcsp.lang.ChannelIntFactory#createOne2One()
*/
public One2OneChannelInt createOne2One()
{
return new One2OneChannelIntImpl();
}
/**
* Constructs and returns an Any2OneChannelInt object.
*
* @return the channel object.
*
* @see org.jcsp.lang.ChannelIntFactory#createAny2One()
*/
public Any2OneChannelInt createAny2One()
{
return new Any2OneChannelIntImpl();
}
/**
* Constructs and returns a One2AnyChannelInt object.
*
* @return the channel object.
*
* @see org.jcsp.lang.ChannelIntFactory#createOne2Any()
*/
public One2AnyChannelInt createOne2Any()
{
return new One2AnyChannelIntImpl();
}
/**
* Constructs and returns an Any2AnyChannelInt object.
*
* @return the channel object.
*
* @see org.jcsp.lang.ChannelIntFactory#createAny2Any()
*/
public Any2AnyChannelInt createAny2Any()
{
return new Any2AnyChannelIntImpl();
}
/**
* Constructs and returns an array of One2OneChannelInt
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelIntArrayFactory#createOne2One(int)
*/
public One2OneChannelInt[] createOne2One(int n)
{
One2OneChannelInt[] toReturn = new One2OneChannelInt[n];
for (int i = 0; i < n; i++)
toReturn[i] = createOne2One();
return toReturn;
}
/**
* Constructs and returns an array of Any2OneChannelInt
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelIntArrayFactory#createAny2One(int)
*/
public Any2OneChannelInt[] createAny2One(int n)
{
Any2OneChannelInt[] toReturn = new Any2OneChannelInt[n];
for (int i = 0; i < n; i++)
toReturn[i] = createAny2One();
return toReturn;
}
/**
* Constructs and returns an array of One2AnyChannelInt
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelIntArrayFactory#createOne2Any(int)
*/
public One2AnyChannelInt[] createOne2Any(int n)
{
One2AnyChannelInt[] toReturn = new One2AnyChannelInt[n];
for (int i = 0; i < n; i++)
toReturn[i] = createOne2Any();
return toReturn;
}
/**
* Constructs and returns an array of Any2AnyChannelInt
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelIntArrayFactory#createAny2Any(int)
*/
public Any2AnyChannelInt[] createAny2Any(int n)
{
Any2AnyChannelInt[] toReturn = new Any2AnyChannelInt[n];
for (int i = 0; i < n; i++)
toReturn[i] = createAny2Any();
return toReturn;
}
/**
* One2OneChannelInt object which
* uses the specified ChannelDataStoreInt object as a buffer.
* ChannelDataStoreInt to use.
* @return the buffered channel.
*
* @see org.jcsp.lang.BufferedChannelIntFactory#createOne2One(org.jcsp.util.ints.ChannelDataStoreInt)
* @see org.jcsp.util.ints.ChannelDataStoreInt
*/
public One2OneChannelInt createOne2One(ChannelDataStoreInt buffer)
{
return new BufferedOne2OneChannelIntImpl(buffer);
}
/**
* Any2OneChannelInt object which
* uses the specified ChannelDataStoreInt object as a buffer.
* ChannelDataStoreInt to use.
* @return the buffered channel.
*
* @see org.jcsp.lang.BufferedChannelIntFactory#createAny2One(org.jcsp.util.ints.ChannelDataStoreInt)
* @see org.jcsp.util.ints.ChannelDataStoreInt
*/
public Any2OneChannelInt createAny2One(ChannelDataStoreInt buffer)
{
return new BufferedAny2OneChannelIntImpl(buffer);
}
/**
* One2AnyChannelInt object which
* uses the specified ChannelDataStoreInt object as a buffer.
* ChannelDataStoreInt to use.
* @return the buffered channel.
*
* @see org.jcsp.lang.BufferedChannelIntFactory#createOne2Any(org.jcsp.util.ints.ChannelDataStoreInt)
* @see org.jcsp.util.ints.ChannelDataStoreInt
*/
public One2AnyChannelInt createOne2Any(ChannelDataStoreInt buffer)
{
return new BufferedOne2AnyChannelIntImpl(buffer);
}
/**
* Any2AnyChannelInt object which
* uses the specified ChannelDataStoreInt object as a buffer.
* ChannelDataStoreInt to use.
* @return the buffered channel.
*
* @see org.jcsp.lang.BufferedChannelIntFactory#createAny2Any(org.jcsp.util.ints.ChannelDataStoreInt)
* @see org.jcsp.util.ints.ChannelDataStoreInt
*/
public Any2AnyChannelInt createAny2Any(ChannelDataStoreInt buffer)
{
return new BufferedAny2AnyChannelIntImpl(buffer);
}
/**
* One2OneChannelInt objects
* which use the specified ChannelDataStoreInt object as a
* buffer.
* ChannelDataStoreInt to use.
* @param n the size of the array of channels.
* @return the array of buffered channels.
*
* @see org.jcsp.lang.BufferedChannelIntArrayFactory#createOne2One(org.jcsp.util.ints.ChannelDataStoreInt,int)
* @see org.jcsp.util.ints.ChannelDataStoreInt
*/
public One2OneChannelInt[] createOne2One(ChannelDataStoreInt buffer, int n)
{
One2OneChannelInt[] toReturn = new One2OneChannelInt[n];
for (int i = 0; i < n; i++)
toReturn[i] = createOne2One(buffer);
return toReturn;
}
/**
* Any2OneChannelInt objects
* which use the specified ChannelDataStoreInt object as a
* buffer.
* ChannelDataStoreInt to use.
* @param n the size of the array of channels.
* @return the array of buffered channels.
*
* @see org.jcsp.lang.BufferedChannelIntArrayFactory#createAny2One(org.jcsp.util.ints.ChannelDataStoreInt,int)
* @see org.jcsp.util.ints.ChannelDataStoreInt
*/
public Any2OneChannelInt[] createAny2One(ChannelDataStoreInt buffer, int n)
{
Any2OneChannelInt[] toReturn = new Any2OneChannelInt[n];
for (int i = 0; i < n; i++)
toReturn[i] = createAny2One(buffer);
return toReturn;
}
/**
* One2AnyChannelInt objects
* which use the specified ChannelDataStoreInt object as a
* buffer.
* ChannelDataStoreInt to use.
* @param n the size of the array of channels.
* @return the array of buffered channels.
*
* @see org.jcsp.lang.BufferedChannelIntArrayFactory#createOne2Any(org.jcsp.util.ints.ChannelDataStoreInt,int)
* @see org.jcsp.util.ints.ChannelDataStoreInt
*/
public One2AnyChannelInt[] createOne2Any(ChannelDataStoreInt buffer, int n)
{
One2AnyChannelInt[] toReturn = new One2AnyChannelInt[n];
for (int i = 0; i < n; i++)
toReturn[i] = createOne2Any(buffer);
return toReturn;
}
/**
* Any2AnyChannelInt objects
* which use the specified ChannelDataStoreInt object as a
* buffer.
* ChannelDataStoreInt to use.
* @param n the size of the array of channels.
* @return the array of buffered channels.
*
* @see org.jcsp.lang.BufferedChannelIntArrayFactory#createAny2Any(org.jcsp.util.ints.ChannelDataStoreInt,int)
* @see org.jcsp.util.ints.ChannelDataStoreInt
*/
public Any2AnyChannelInt[] createAny2Any(ChannelDataStoreInt buffer, int n)
{
Any2AnyChannelInt[] toReturn = new Any2AnyChannelInt[n];
for (int i = 0; i < n; i++)
toReturn[i] = createAny2Any(buffer);
return toReturn;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/PoisonableAny2AnyChannelImpl.java 0000644 0000000 0000000 00000004176 11113671251 022344 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
class PoisonableAny2AnyChannelImpl extends Any2AnyImpl
{
PoisonableAny2AnyChannelImpl(int _immunity) {
super(new PoisonableOne2OneChannelImpl(_immunity));
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/ConnectionWithSharedAltingServer.java 0000644 0000000 0000000 00000004266 11105701167 023345 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* @author Quickstone Technologies Limited
*/
interface ConnectionWithSharedAltingServer
{
public SharedConnectionServer server();
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/RejectableOne2AnyChannel.java 0000644 0000000 0000000 00000006533 11105701167 021461 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* reject operation. One of the readers may call
* the reject method to force any current writer to abort with a
* ChannelDataRejectedException (unless there is already a read which will cause
* completion of the write). Subsequent read and write attempts will immediately cause a
* ChannelDataRejectedException.ConnectionServer.request(Object) to initiate a conversation and to send some
* data to the server. Implementations may decide to return immediately or
* to wait until the server accepts the connection and then return. The
* Connection is not guaranteed to be open until a call to reply()
* has returned. The reply() method should be called soon
* after the call to reqeust(Object). Some computation may be
* done between the calls but any external process synchronization is
* potentially hazardous.reply(), clients can check whether
* the server closed the connection by calling isOpen().
* If it returns true, then the connection has been kept
* open. If the connection has been kept open then the client may assume
* that a call to request(Object) will not block and that
* the connection will soon be dealt with by the server.
* //have a variable client of type ConnectionClient
* do {
* client.request(some_data);
* some_variable = client.receive();
* } while (client.isOpen())
*
*
* @author Quickstone Technologies Limited
*/
public interface ConnectionClient
{
/**
* ConnectionServer in
* a client/server conversation. If a connection has not yet been established,
* then this method will open the connection as necessary.reply(). This will obtain a
* server's response to the request. In between calling this method and
* reply(), doing pure computation is safe. Performing
* synchronization with other process is potentially hazardous.Connections need to adopt a protocol so that the server
* knows when a conversation with a client has finished and will then drop
* the connection.Object to send to the server.
* @throws IllegalStateException if the method is called when it is
* not meant to be.
*/
public void request(Object data) throws IllegalStateException;
/**
* request(Object) has been called.isOpen() may be called
* to establish whether the server dropped the connection after replying.Object sent from the server.
* @throws IllegalStateException if the method is called when it is
* not meant to be.
*/
public Object reply() throws IllegalStateException;
/**
* reply() and
* before any other Connection method is called.true iff the server has kept the connection
* open.
*/
public boolean isOpen() throws IllegalStateException;
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/One2AnyCallChannel.java 0000644 0000000 0000000 00000024410 11105701167 020266 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import java.io.Serializable;
/**
* This is the super-class for one-to-any interface-specific CALL channels,
* safe for use by one client and many servers.
* Description
* Please see {@link One2OneCallChannel} for general information about CALL channels.
* Documented here is information specific to this 1-any version.
*
* Converting a Method Interface into a Variant CALL Channel
* Constructing a 1-any CALL channel for a specific interface
* follows exactly the same pattern as in the 1-1 case. Of course, it must
* extend One2AnyCallChannel rather than One2OneCallChannel.
*
* import org.jcsp.lang.*;
*
* public class One2AnyFooChannel extends One2AnyCallChannel implements Foo {
*
* ... same body as One2OneFooChannel
*
* }
*
*
* Calling a CALL Channel
* All the client needs to see is the method interface
* implemented by the CALL channel. So far as the client is concerned, therefore,
* there is no difference between any of the varieties of CALL channel
* - it just makes the call.
*
* Accepting a CALL Channel
* The mechanics of accepting a CALL channel are the same for all varieties.
* However, the server should declare which kind (or kinds) it allows
* to be attached:
*
* import org.jcsp.lang.*;
*
* class B implements CSProcess, Foo {
*
* private final ChannelAccept in;
*
* public B (final One2OneFooChannel in) { // original constructor
* this.in = in;
* }
*
* public B (final One2AnyFooChannel in) { // additional constructor
* this.in = in;
* }
*
* ... rest as before
*
* }
*
* When wrapping the above to hide its raw method interface, don't forget to include
* the extra constructor(s):
*
* import org.jcsp.lang.*;
*
* public class B2 implements CSProcess { // no Foo interface
*
* private final B b;
*
* public B2 (final One2OneFooChannel in) { // original constructor
* b = new B (in);
* }
*
* public B2 (final One2AnyFooChannel in) { // additional constructor
* b = new B (in);
* }
*
* public void run () {
* b.run ();
* }
*
* }
*
*
* ALTing on a CALL Channel
* As for ordinary channels, ALTing over 1-Any or Any-Any versions
* is not supported. Hence, a server can only choose to {@link #accept accept}
* or not to accept a One2AnyFooChannel - it cannot back off because
* of some other event.
*
* Building a CALL Channel Network
* Network building with CALL channels is the same as building with ordinary
* channels. First construct the channels and, then, construct the processes
* - plugging in the channels as required and running them in {@link Parallel}.
* 
* One2AnyFooChannel c = new One2AnyFooChannel ();
*
* final B2[] bServers = new B2[n_bClients];
* for (int i = 0; i < bServers.length; i++) {
* bServers[i] = new B2 (c);
* }
*
* new Parallel (
* new CSProcess[] {
* new A (c),
* new Parallel (bServers)
* }
* ).run ();
*
* [Reminder: XXX-any channels are not broadcasters of information.
* In the above, when A makes a CALL on c, it must not care
* which of the B2 servers picks it up. The servers compete
* with each other to service the client.]
*
* Example
* Please see Any2AnyCallChannel
* for an example that includes many clients and many servers competing for
* each other's attention.
*
* @see org.jcsp.lang.One2OneCallChannel
* @see org.jcsp.lang.Any2OneCallChannel
* @see org.jcsp.lang.Any2AnyCallChannel
* @see org.jcsp.lang.Alternative
*
* @author P.H. Welch
*/
public abstract class One2AnyCallChannel implements ChannelAccept, Serializable
{
/**
* This is used to synchronise the calling and accepting process.
*/
final private One2OneChannelImpl c = new One2OneChannelImpl();
/**
* This holds a reference to a server process so that a client may
* make the call. The reference is only valid between the {@link #join join}
* and {@link #fork fork} elements of the standard
* calling sequence.
* As shown in that sequence, it will need casting up to the relevant interface
* supported by the specific CALL channel derived from this class.
*/
protected CSProcess server;
/**
* This may be set during the standard calling sequence to record
* which method was invoked by a client. It is only safe to do this between
* the {@link #join join} and {@link #fork fork} elements of
* that sequence. Either all the CALL
* channel methods should do this or none - in the latter case, its default
* value remains as zero. Its value is returned to a server as the result
* the server's invocation of {@link #accept accept}.
*/
protected int selected = 0;
/**
* This is invoked by a server when it commits to accepting a CALL
* from a client. The parameter supplied must be a reference to this server
* - see the example from {@link One2OneCallChannel}.
* It will not complete until a CALL has been made. If the derived CALL channel has set
* the {@link #selected} field in the way defined by the standard
* calling sequence,
* the value returned by this method will indicate which method was called.
*
* @param server the server process receiving the CALL.
*/
public synchronized int accept(CSProcess server)
{
this.server = server;
c.read(); // ready to ACCEPT the CALL
c.read(); // wait until the CALL is complete
return selected;
}
/**
* This is invoked by a client during the standard calling
* sequence. It will not complete until a server invokes
* an {@link #accept accept} on this channel. In turn, that accept
* will not complete until the client invokes a {@link #fork fork},
* after having made its CALL on the server.
*/
protected void join()
{
c.write(null);
}
/**
* This is invoked by a client during the standard calling
* sequence. A server must have invoked an {@link #accept accept}
* for the client to have got this far in the sequence - see
* the {@link #join join}. This call unblocks that accept,
* releasing the server and client to resume separate lives.
*/
protected void fork()
{
c.write(null);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/AltingChannelInput.java 0000644 0000000 0000000 00000010053 11113671251 020452 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This extends {@link Guard} and {@link ChannelInput}
* to enable a process to choose between many object input (and other) events.
* Description
* AltingChannelInput extends {@link Guard} and {@link ChannelInput}
* to enable a process
* to choose between many object input (and other) events. The methods inherited from
* Guard are of no concern to users of this package.
*
Example
*
* import org.jcsp.lang.*;
*
* public class AltingExample implements CSProcess {
*
* private final AltingChannelInput in0, in1;
*
* public AltingExample (final AltingChannelInput in0,
* final AltingChannelInput in1) {
* this.in0 = in0;
* this.in1 = in1;
* }
*
* public void run () {
*
* final Guard[] altChans = {in0, in1};
* final Alternative alt = new Alternative (altChans);
*
* while (true) {
* switch (alt.select ()) {
* case 0:
* System.out.println ("in0 read " + in0.read ());
* break;
* case 1:
* System.out.println ("in1 read " + in1.read ());
* break;
* }
* }
*
* }
*
* }
*
*
* @see org.jcsp.lang.Guard
* @see org.jcsp.lang.Alternative
* @author P.D. Austin and P.H. Welch
*/
public abstract class AltingChannelInput extends Guard implements ChannelInput
{
// nothing alse to add ... except ...
/**
* Returns whether there is data pending on this channel.
* * Note: if there is, it won't go away until you read it. But if there * isn't, there may be some by the time you check the result of this method. * * @return state of the channel. */ public abstract boolean pending(); } jcsp-1.1-rc4.orig/src/org/jcsp/lang/AltingBarrier.java 0000644 0000000 0000000 00000151331 11105701167 017456 0 ustar /************************************************************************* * * * JCSP ("CSP for Java") libraries * * Copyright (C) 1996-2008 Peter Welch and Paul Austin. * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This library is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, * * USA. * * * * Author contact: P.H.Welch@kent.ac.uk * * * *************************************************************************/ package org.jcsp.lang; //{{{ javadoc /** * This is the front-end for a barrier that can be used as * a {@link Guard} in an {@link Alternative}. *
*
Description
* An alting barrier is represented by a family ofAltingBarrier
* front-ends. Each process using the barrier must do so via its
* own front-end. A new alting barrier is created by the static
* {@link #create create} method, which returns an array of front-ends.
* If new processes need to be enrolled, further front-ends may be made
* from an existing one (see {@link #expand(int) expand} and
* {@link #contract(AltingBarrier[]) contract}).
* A process may temporarilly {@link #resign resign} from a barrier and, later,
* re-{@link #enroll enroll}.
*
* To use this barrier, a process simply includes its given AltingBarrier
* front-end in a {@link Guard} array associated with an {@link Alternative}.
* Its index will be selected if and only if all parties (processes) to the barrier
* similarly select it (using their own front-ends).
*
* If a process wishes to commit to this barrier (i.e. not offer it as a choice * in an {@link Alternative}), it may {@link #sync sync} on it. * However, if all parties only do this, a non-alting {@link Barrier} * would be more efficient. * A further shortcut (over using an {@link Alternative}) is provided * to {@link #poll(long) poll} this barrier for completion. *
*
* An AltingBarrier front-end may only be used by one process
* at a time (and this is checked at run-time).
* A process may communicate a non-resigned front-end to another process;
* but the receiving process must {@link #mark mark} it before using it and,
* of course, the sending process must not continue to use it.
* If a process terminates holding a front-end, it may be recycled
* for use by another process via {@link #reset reset}.
*
Priorities
* These do not -- and cannot -- apply to selection between barriers. * The {@link Alternative#priSelect priSelect()} method works locally for * the process making the offer. * If this were allowed, one process might offer barrierx with higher
* priority than barrier y ... and another process might offer them
* with its priorities the other way around.
* In which case, it would be impossible to resolve a choice in favour of
* x or y in any way that satisfied the conflicting
* priorities of both processes.
*
* * However, the {@link Alternative#priSelect priSelect()} method is * allowed for choices including barrier guards. It honours the respective * priorities defined between non-barrier guards ... and those * between a barrier guard and non-barrier guards (which * guarantees, for example, immediate response to a timeout from ever-active * barriers). Relative priorities between barrier guards are inoperative. *
*Misuse
* The implementation defends against misuse, throwing an {@link AltingBarrierError} * error when riled. See the documentation for {@link AltingBarrierError} for * circumstances. * *Example 0 (a single alting barrier)
* Here is a simple gadget with two modes of operation, switched by a click * event (operated externally by a button in the application below). * Initially, it is in individual mode -- represented here by incrementing * a number and outputting it (as aString to change the label on
* its controlling button) as often as it can.
* Its other mode is group, in which it can only work if all associated
* gadgets are also in this mode. Group work consists of a single decrement
* and output of the number (to its button's label).
* It performs group work as often as the group will allow (i.e. until it, or
* one of its partner gadgets, is clicked back to individual mode).
*
* import org.jcsp.lang.*;
*
* public class AltingBarrierGadget0 implements CSProcess {
*
* private final AltingChannelInput click;
* private final AltingBarrier group;
* private final ChannelOutput configure;
*
* public AltingBarrierGadget0 (
* AltingChannelInput click, AltingBarrier group, ChannelOutput configure
* ) {
* this.click = click;
* this.group = group;
* this.configure = configure;
* }
*
* public void run () {
*
* final Alternative clickGroup =
* new Alternative (new Guard[] {click, group});
*
* final int CLICK = 0, GROUP = 1;
*
* int n = 0;
* configure.write (String.valueOf (n));
*
* while (true) {
*
* configure.write (Color.green) // pretty
*
* while (!click.pending ()) { // individual work mode
* n++; // work on our own
* configure.write (String.valueOf (n)); // work on our own
* }
* click.read (); // must consume the click
*
* configure.write (Color.red); // pretty
*
* boolean group = true; // group work mode
* while (group) {
* switch (clickGroup.priSelect ()) { // offer to work with the group
* case CLICK:
* click.read (); // must consume the click
* group = false; // back to individual work mode
* break;
* case GROUP:
* n--; // work with the group
* configure.write (String.valueOf (n)); // work with the group
* break;
* }
* }
*
* }
*
* }
*
* }
*
* Here is code for a system of buttons and gadgets, synchronised by
* an alting barrier. Note that this single event needs
* an array of AltingBarrier front-ends to operate --
* one for each gadget:
*
* import org.jcsp.lang.*;
* import org.jcsp.plugNplay.*;
*
* public class AltingBarrierGadget0Demo0 {
*
* public static void main (String[] argv) {
*
* final int nUnits = 8;
*
* // make the buttons
*
* final One2OneChannel[] event = Channel.one2oneArray (nUnits);
*
* final One2OneChannel[] configure = Channel.one2oneArray (nUnits);
*
* final boolean horizontal = true;
*
* final FramedButtonArray buttons =
* new FramedButtonArray (
* "AltingBarrier: Gadget 0, Demo 0", nUnits, 120, nUnits*100,
* horizontal, configure, event
* );
*
* // construct an array of front-ends to a single alting barrier
*
* final AltingBarrier[] group = AltingBarrier.create (nUnits);
*
* // make the gadgets
*
* final AltingBarrierGadget0[] gadgets = new AltingBarrierGadget0[nUnits];
* for (int i = 0; i < gadgets.length; i++) {
* gadgets[i] = new AltingBarrierGadget0 (event[i], group[i], configure[i]);
* }
*
* // run everything
*
* new Parallel (
* new CSProcess[] {
* buttons, new Parallel (gadgets)
* }
* ).run ();
*
* }
*
* }
*
* The very simple "group" work in the above example consists of actions
* performed independently by each gadget (decrementing the number on its
* button's label). The (alting) barrier synchronisation ensures that
* these decrements keep in step with each other.
* * A more interesting gadget would work with other gadgets for group work * that really did require them all to be engaged. * For example, they resume operation of a machine that would be dangerous if * some gadgets (perhaps those responsible for safety aspects) were doing * their individual work. *
*Example 1 (lots of alting barriers)
* This example derives from a pathological challenge to the management of choice * between multiway synchronisations raised by Michael Goldsmith (Formal * Systems Europe). * There are three processes (P, Q and R)
* and theee events (a, b and c).
* P offers events a and b;
* Q offers events b and c;
* and R offers events c and a.
* If P and Q synchronise on b,
* they do something (possibly together) then start again.
* Similarly if Q and R synchronise on c
* or if R and P synchronise on a.
* In CSP, the expression is trivial:
*
* P = ((a -> P0); P) [] ((b -> P1); P), and where c is not in the alphabet of P
* Q = ((b -> Q0); Q) [] ((c -> Q1); Q), and where a is not in the alphabet of Q
* R = ((c -> R0); R) [] ((a -> R1); R), and where b is not in the alphabet of R
*
* SYSTEM = (P || Q || R) \ {a, b, c}
*
* To impact their environment (and avoid divergence), the sub-processes
* P0, P1, Q0, Q1,
* R0 and R1 will engage in external events
* (i.e. not just a, b or c).
* Additionally, P1 and Q0
* (triggered by b) may engage in other hidden events,
* not given in the above.
* The same for Q1 and R0
* (triggered by c) and for R1 and P0
* (triggered by a).
*
*
* In our version, there are N processes and events arranged (logically)
* around a circle.
* Each process is either off or on standby, switching between
* these states on random timeouts.
* Each process is also attached to a personal button that it uses
* to indicate its state.
* When off, it colours its button black; when on standby,
* light gray.
*
* When on standby, each process offers (span+1) events:
* a timeout, the event with it on the circle and the next (span-1)
* events going (say) clockwise.
* It the timeout occurs, it switches to its off state.
* If one of the events (AltingBarrier) occurs, it must have
* occured for a consecutive block of span processes (including
* this one ... somewhere) around the circle.
* This group now go into a playing state.
*
* Not mentioned before is a rail track, made of channels, running round
* the circle.
* When playing, the process furthest uptrack choses a colour and sends this to
* its partners down the track (to which the mulitway synchronisation ensures
* this group has exclusive access).
* Each process in the playing group then flashes its button with that colour
* a fixed (parametrised) number of times.
* The rate of flashing is coordinated by the AltingBarrier
* multiway synchronisation event common to the group --
* the furthest uptrack process only keeping time for this.
* After playing, the process switches to its off state.
*
* [Note: the above SYSTEM has N equal to
* 3, span equal to 2, no off
* state and no timeout on standby.
* The channels used to flash the buttons are the external events mentioned
* and the rail track channels are the hidden extras.]
*
* Here is the code for these processes. * As usual, the constructor just saves all parameters: *
* import org.jcsp.lang.*;
* import org.jcsp.awt.*;
*
* import java.awt.Color;
* import java.util.Random;
*
* public class AltingBarrierGadget1 implements CSProcess {
*
* private final AltingBarrier[] barrier;
* private final AltingChannelInput in, click;
* private final ChannelOutput out, configure;
* private final Color offColour, standbyColour;
* private final int offInterval, standbyInterval;
* private final int playInterval, flashInterval;
*
* public AltingBarrierGadget1 (
* AltingBarrier[] barrier,
* AltingChannelInput in, ChannelOutput out,
* AltingChannelInput click, ChannelOutput configure,
* Color offColour, Color standbyColour,
* int offInterval, int standbyInterval,
* int playInterval, int flashInterval
* ) {
* this.barrier = barrier;
* this.in = in; this.out = out;
* this.click = click; this.configure = configure;
* this.offColour = offColour; this.standbyColour = standbyColour;
* this.offInterval = offInterval; this.standbyInterval = standbyInterval;
* this.playInterval = playInterval; this.flashInterval = flashInterval;
* }
*
* The barrier array gives this gadget access to
* the multiway events shared with adjacent siblings.
* The in and out channel ends are part of the
* rail track this gadget uses later (when playing).
* The click and configure channels
* attach this gadget to its button.
* The click channel is never used by this gadget -- it's included
* for completeness should anyone wish to enhance its behaviour.
* The other parameters are just data.
*
*
* The run() method controls switching between off,
* standby and playing states.
* The latter is the choice between all the multiway syncs (and the timeout).
* It is handled by a fair select on the {@link Alternative},
* constructed just once (before loop entry):
*
* public void run () {
*
* CSTimer tim = new CSTimer ();
*
* final Random random = new Random ();
*
* final Guard[] standbyGuard = new Guard[barrier.length + 1];
* for (int i = 0; i < barrier.length; i++) {
* standbyGuard[i] = barrier[i];
* }
* standbyGuard[barrier.length] = tim;
* final int TIMEOUT = barrier.length;
* Alternative standbyAlt = new Alternative (standbyGuard);
*
* configure.write (Boolean.FALSE); // disable mouse clicks
* // (not used by this gadget)
* while (true) {
*
* configure.write (offColour);
* tim.sleep (random.nextInt (offInterval));
*
* configure.write (standbyColour);
* tim.setAlarm (tim.read () + random.nextInt (standbyInterval));
*
* int choice = standbyAlt.fairSelect (); // magic synchronisation
*
* if (choice != TIMEOUT) {
* play (choice, random, tim);
* }
*
* }
*
* }
*
* Here is the playing code.
* Initially, a colour is chosen and passed down the playing group's section
* of rail track, to which it has exclusive access.
* The flashing group is coordinated through the group's common event,
* with just one of them keeping time.
*
* private void play (int choice, Random random, CSTimer tim) {
*
* final boolean RIGHTMOST = (choice == 0);
* final boolean LEFTMOST = (choice == (barrier.length - 1));
*
* Color colour = null;
* if (RIGHTMOST) {
* colour = new Color (random.nextInt ());
* } else {
* colour = (Color) in.read ();
* }
* Color bright = colour.brighter ();
*
* if (!LEFTMOST) out.write (colour); // pass it on
*
* final AltingBarrier focus = barrier[choice];
*
* final int count = playInterval/flashInterval;
*
* long timeout = tim.read () + flashInterval;
*
* boolean bright = true;
*
* for (int i = 0; i < count; i++) {
* configure.write (bright ? brighter : colour);
* bright = !bright;
* if (RIGHTMOST) {
* tim.after (timeout);
* timeout += flashInterval;
* }
* focus.sync ();
* }
*
* }
*
* }
*
* Here is code setting up a "circle" of these gadgets, buttons and
* alting barriers.
* The buttons are laid out in a row, so that the rightmost button is actually
* on the "left" of the leftmost button.
* Care needs to be taken to distribute the span front-ends
* for each AltingBarrier to the correct gadgets --
* see the re-arrangement below:
*
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.plugNplay.*;
*
* import java.awt.Color;
* import java.util.Random;
*
* public class AltingBarrierGadget1Demo0 {
*
* public static void main (String[] argv) {
*
* final int nUnits = 30, span = 6;
*
* final int offInterval = 800, standbyInterval = 1000; // milliseconds
*
* final int playInterval = 10000, flashInterval = 500; // milliseconds
*
* final Color offColour = Color.black, standbyColour = Color.lightGray;
*
* // make the buttons
*
* final One2OneChannel[] click =
* Channel.one2oneArray (nUnits, new OverWriteOldestBuffer (1));
*
* final One2OneChannel[] configure = Channel.one2oneArray (nUnits);
*
* final boolean horizontal = true;
*
* final FramedButtonArray buttons =
* new FramedButtonArray (
* "AltingBarrier: Gadget 1, Demo 0", nUnits, 100, nUnits*50,
* horizontal, configure, click
* );
*
* // construct nUnits barriers, each with span front-ends ...
*
* AltingBarrier[][] ab = new AltingBarrier[nUnits][];
* for (int i = 0; i < nUnits; i++) {
* ab[i] = AltingBarrier.create (span);
* }
*
* // re-arrange front-ends, ready for distribution to processes ...
*
* AltingBarrier[][]barrier = new AltingBarrier[nUnits][span];
* for (int i = 0; i < nUnits; i++) {
* for (int j = 0; j < span; j++) {
* barrier[i][j] = ab[(i + j) % nUnits][j];
* }
* }
*
* // make the track and the gadgets
*
* One2OneChannel[] track = Channel.one2oneArray (nUnits);
*
* AltingBarrierGadget1[] gadgets = new AltingBarrierGadget1[nUnits];
* for (int i = 0; i < nUnits; i++) {
* gadgets[i] =
* new AltingBarrierGadget1 (
* barrier[i],
* track[(i + 1)%nUnits], track[i],
* click[i], configure[i],
* offColour, standbyColour,
* offInterval, standbyInterval,
* playInterval, flashInterval
* );
* }
*
* // run everything
*
* new Parallel (
* new CSProcess[] {
* buttons, new Parallel (gadgets)
* }
* ).run ();
*
* }
*
* }
*
* For fun, here is another application program for the same gadget.
* It allows a much larger system to be built, laying out the circle
* of buttons in a grid, row by row.
* The rightmost button on each row is to the left of the leftmost
* button on the next row down.
* The next row down from the bottom row is the top row.
* The buttons and its click and configure channels
* are now two dimensional structures.
* The barriers, gadgets and rail track are still one dimensional.
* Only code differences from the above are shown:
*
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.plugNplay.*;
*
* import java.awt.Color;
* import java.util.Random;
*
* public class AltingBarrierGadget1Demo1 {
*
* public static void main (String[] argv) {
*
* final int width = 30, depth = 20;
* final int nUnits = width*depth;
*
* ... the other system parameters (final ints and Colors)
*
* final One2OneChannel[][] click = new One2OneChannel[depth][];
* for (int i = 0; i < depth; i++) {
* click[i] = Channel.one2oneArray (width, new OverWriteOldestBuffer (1));
* }
*
* final One2OneChannel[][] configure = new One2OneChannel[depth][];
* for (int i = 0; i < depth; i++) {
* configure[i] = Channel.one2oneArray (width);
* }
*
* final FramedButtonGrid buttons =
* new FramedButtonGrid (
* "AltingBarrier: Gadget 1, Demo 1", depth, width,
* 20 + (depth*50), width*50, configure, click
* );
*
* ... construct nUnits barriers and the track exactly as before
*
* AltingBarrierGadget1[] gadgets = new AltingBarrierGadget1[nUnits];
* for (int i = 0; i < nUnits; i++) {
* gadgets[i] =
* new AltingBarrierGadget1 (
* barrier[i],
* track[(i + 1)%nUnits], track[i],
* click[i/width][i%width],
* configure[i/width][i%width],
* offColour, standbyColour,
* offInterval, standbyInterval,
* playInterval, flashInterval
* );
* }
*
* ... build and run the buttons and gadgets in parallel
*
* }
*
* }
*
*
* Other Examples
* Thealting-barriers directory in jcsp-demos
* contains other gadgets in a similar vein.
*
* AltingBarrierGadget2
* These are similar to AltingBarrierGadget1, but sit on
* a 2-way circular railtrack offering to synchronise in the same
* span-groups.
* Their difference is the game they play when synchronised:
* pass-the-parcel up and down their section of track, with
* the parcel's (rapid) progress indicated by writing on the button labels.
* These gadgets also enable their buttons when playing and finish their game
* when any one, or more, of their buttons is clicked -- or they get bored and
* timeout.
*
* AltingBarrierGadget3
* Along with their attached buttons, these form a two dimensional structure
* covering the surface of a torus.
* The gadgets on the top row are adjacent to the gadgets on
* the bottom row.
* The gadgets on the left column are adjacent to the gadgets on
* the right column.
* The demonstration program, AltingBarrierGadget3Demo0,
* asks the user to choose between various shapes and sizes for
* the synchronisation groups (pluses, crosses and
* circles) -- but all groups have the same shape and size.
*
*
* Creation and distribution of the barriers is not done by the demonstration
* program but, more simply, by the gadgets themselves.
* Each AltingBarrierGadget3 belongs to many synchronisation
* groups, but has lead responsibility for one.
* It services the input end of a single channel and is given the (shared)
* output ends of the service channels to the other gadgets in the group
* it is leading.
* [Note: the giver of those output ends is the demonstration program.]
* It creates the alting barrier (and some other things -- see below) for
* its lead group.
* Distribution is by I/O-PAR exchange over their service channels as
* the gadgets initialise.
* Each gadget sends the things it made to the gadgets in the group it is
* leading and receives the same from the leaders of its other synchronisation
* groups.
* This is the only use they make of these channels.
*
* A synchronised group plays a simple counting game until one of its buttons * is clicked or the countdown reaches zero. * Termination of the game is, and has to be, simultaneous. * This is managed by a shared termination flag, safely operated * through phased barrier synchronisation (which lets any process * in the group set it in an even phase, with all processes acting * on it in the odd phases). * Shared label and colour variables (for the group's buttons) are operated * similarly. * The shared variables are distributed (as fields of a shared object) by * the leader gadget, along with the group's alting barrier front-ends, * during initialisation. *
*
* The group's AltingBarrier is used to separate the phases.
* Alting capability on this barrier enables rapid response to
* any button click on the group to end the game.
* The lead gadget controls timing: it alts between a countdown timeout,
* its button click and a cancel message from the rest of the group (should
* any of their buttons be clicked) -- following any of these with the barrier
* sync, scheduling the next phase.
* The other gadgets alt between their button click and the barrier:
* response to a click being the (timeout) cancel message to the leader then
* wait for the barrier; response to the barrier being the next phase.
*
* The Any2One cancel channel is a mulitplexing relay from
* the non-lead buttons to the leader gadget.
* It is constructed by the lead gadget and distributed to its team alongside
* the shared variables.
* The cancel channel must be overwriting buffered
* to avoid deadlock -- the same as the click channels from buttons.
* The cancel channel must be cleared at the start of each game -- same as
* the click channels.
*
* * USER GAME: run the demo program on a 30x20 grid (expand to * full screen), with circle shapes (say), a radius of 3, off and standBy * intervals of 1000 (millisecs), play interval of 10000 (millisecs) and * a count interfavl of 200 (millisecs). * Your challenge is to zap all the coloured shapes away before any of their * counts reach zero and the end of the world happens, :). * How long can you survive?!! *
* *AltingBarrierGadget4
* These are the same as the previous (AltingBarrierGadget3)
* gadgets, except that they do not assume that all the synchronisation groups
* to which they belong have the same shape or size.
* While they do know the size of the group they lead (from the length of
* the channel of output ends they are given), that is all they know.
* In particular, they do not know how many items (barriers etc.) to expect
* from the leaders of their other groups in the opening exchange.
*
* * This is solved by giving each gadget a global barrier on which their * parallel outputting processes synchronise when they finish their * distribution. * After this synchronisation, all exchanges must have finished and * they can tell their gadgets to proceed. *
** The demonstration program for these gadgets just asks for a size for * synchronisation groups and allocates (lead) shapes randomly. * It could randomise the sizes as well, but the smaller patterns would * always emerge dominant in the synchronisations achieved (simply because * they require fewer gadgets to be simultaneously on standby -- * i.e. offering mode) and the consequent games. *
** USER GAME: same as before, * except with a span (rather than radius) of 3. *
* *AltingBarrierGadget5
* These are the same as AltingBarrierGadget4, except for
* the technique used to signal the end of the initial exchange of information
* amongst the synchronisation groups.
* They use a global alting barrier on which both the outputting
* and inputting partners in the exchange offer to synchronise -- the former
* when finished outputting and the latter as an alternative to inputting.
* This is, perhaps, more elegant than the conventional barrier and channel
* used by the AltingBarrierGadget4 gadgets and exercises
* the {@link #expand()} and {@link #contract()} methods.
*
* * USER GAME: same as before, * except with a span (rather than radius) of 3. *
* *AltingBarrierGadget6
* The unbuffered service channels used by AltingBarrierGadget3,
* AltingBarrierGadget4 and AltingBarrierGadget5
* (in the opening I/O-PAR exchange of information amongst each
* playing group) force the leaders to synchronise with each of their
* team members.
* This is no problem for AltingBarrierGadget3, since all groups
* have the same size and it receives as many messages as it sends; knowing
* how many messages it is sending, it knows how large its reception arrays
* should be.
* This is not the case for AltingBarrierGadget4 and
* AltingBarrierGadget5, which must first receive into
* collection objects that can expand to any size.
*
*
* AltingBarrierGadget6 performs an asynchronous opening
* exchange of information, using the collection objects directly to buffer
* the communication messages and no channels.
* Further, no internal parallelism is needed for this exchange: the gadgets
* first add all their messages to the collections held by the rest of their
* team; then, they synchronise on the global barrier (a non-alting
* one, the same as used by AltingBarrierGadget4s); finally,
* they extract the information sent by the leaders of the other teams to
* which they belong.
* As before, the barrier synchronisation is crucial for the correctness of
* this exchange, ensuring that all messages are in place before they are
* gathered.
*
* USER GAME: same as before, * except with a span (rather than radius) of 3. *
** * * @see org.jcsp.lang.Barrier * @see org.jcsp.lang.Alternative *
*
* @author P.H. Welch
*/
//}}}
public class AltingBarrier extends Guard implements MultiwaySynchronisation {
/** This references the barrier on which this is enrolled.
* Also package visible (nulled by the base.contract methods).
*/
AltingBarrierBase base;
/** Link to the next front-end (used by {@link AltingBarrierBase}). */
AltingBarrier next = null;
/** The process offering this barrier (protected by the base monitor). */
private Alternative alt = null;
/** Safety check (protected by the base monitor). */
private Thread myThread = null;
/** Safety check (protected by the base monitor).
* Also package visible (needed by the base.contract(...) method).
*/
boolean enrolled = true;
/** Used to support the {@link #sync() sync} method. */
private Alternative singleAlt = null;
/** Used to support the {@link #poll() sync} method. */
private Alternative pollAlt = null;
/** Used to support the {@link #poll() sync} method. */
private CSTimer pollTime = null;
/** Package-only constructor (used by {@link AltingBarrierBase}). */
AltingBarrier (AltingBarrierBase base, AltingBarrier next) {
this.base = base;
this.next = next;
}
/**
* This creates a new alting barrier with an (initial) enrollment
* count of n.
* It provides an array of n front-ends to this barrier.
* It is the invoker's responsibility to install one of these (by constructor
* or set method) in each process that will be synchronising on
* the barrier, before firing up those processes.
*
* Note: each process must use a different front-end to
* the barrier. Usually, a process retains an AltingBarrier
* front-end throughout its lifetime -- however, see {@link #mark mark}.
*
* * @param n the number of processes enrolled (initially) on this barrier. *
*
* @return an array of n front-ends to this barrier.
*
*
* @throws IllegalArgumentException if n <= 0.
*/
public static AltingBarrier[] create (int n) {
if (n <= 0) {
throw new IllegalArgumentException (
"\n*** An AltingBarrier must have at least one process enrolled, not " + n
);
}
return new AltingBarrierBase ().expand (n);
}
/**
* This creates a new alting barrier with an (initial) enrollment
* count of 1.
* It provides a single front-end to the barrier, from which others may
* be generated (see {@link #expand() expand()}) -- usually one-at-a-time
* to feed processes individually forked (by a {@link ProcessManager}).
* It is the invoker's responsibility to install each one (by constructor
* or set method) in the process that will be synchronising on
* the barrier, before firing up that process.
* Usually, a process retains an AltingBarrier front-end
* throughout its lifetime -- however, see {@link #mark mark}.
*
* Note: if a known number of processes needing the barrier are to be run * (e.g. by a {@link Parallel}), creating the barrier with an array of * front-ends using {@link #create(int) create(n)} would be more convenient. *
* * @return a single front-end for this barrier. */ public static AltingBarrier create () { return new AltingBarrierBase ().expand (); } /** * This expands the number of processes enrolled in this alting barrier. *
* Use it when an enrolled process is about to go {@link Parallel} itself and * some/all of those sub-processes also need to be enrolled. * It returns an array new front-ends for this barrier. * It is the invoker's responsibility to pass these on to those sub-processes. *
*
* Note that if there are x sub-processes to be enrolled, this method
* must be invoked with an argument of (x - 1).
* Pass the returned AltingBarriers to any (x - 1)
* of those sub-processes.
* Pass this AltingBarrier to the last one.
*
* Before using its given front-end to this barrier, each sub-process * must {@link #mark mark} it to take ownership. * [Actually, only the sub-process given the original front-end (which * may be running in a different thread) really has to do this.] *
*
* Following termination of the {@link Parallel}, the original process must
* take back ownership of its original AltingBarrier (loaned to one
* of the sub-processes, which may have been running on a different thread)
* by {@link #mark mark}ing it again.
*
* Also following termination of the {@link Parallel}, the original process * must contract the number of processes enrolled on the barrier. * To do this, it must have retained the front-end array returned by * this method and pass it to {@link #contract(AltingBarrier[]) contract}. *
** * @param n the number of processes to be added to this barrier. *
* * @return an array of new front-ends for this barrier. *
*
* @throws IllegalArgumentException if n <= 0.
*
* * @throws AltingBarrierError if currently resigned or not owner of this * front-end. */ public AltingBarrier[] expand (int n) { if (n <= 0) { throw new IllegalArgumentException ( "\n*** Expanding an AltingBarrier must be by at least one, not " + n ); } synchronized (base) { if (myThread == null) { myThread = Thread.currentThread (); } else if (myThread != Thread.currentThread ()) { throw new AltingBarrierError ( "\n*** AltingBarrier expand attempted by non-owner." ); } if (!enrolled) { throw new AltingBarrierError ( "\n*** AltingBarrier expand attempted whilst resigned." ); } return base.expand (n); } } /** * This expands by one the number of processes enrolled in this alting * barrier. *
* Use it when an enrolled process is about to fork a new process * (using {@link ProcessManager}) that also needs to be enrolled. * It returns an new front-end for this barrier. * It is the invoker's responsibility to pass it to the new process. *
** Before terminating, the forked process should * {@link #contract() contract} (by one) the number of processes * enrolled in this barrier. * Otherwise, no further synchronisations on this barrier would be able * to complete. *
** * @return a new front-end for this barrier. *
* * @throws AltingBarrierError if currently resigned or not owner of this * front-end. */ public AltingBarrier expand () { synchronized (base) { if (myThread == null) { myThread = Thread.currentThread (); } else if (myThread != Thread.currentThread ()) { throw new AltingBarrierError ( "\n*** AltingBarrier expand attempted by non-owner." ); } if (!enrolled) { throw new AltingBarrierError ( "\n*** AltingBarrier expand attempted whilst resigned." ); } return base.expand (); } } /** * This contracts the number of processes enrolled in this alting barrier. * The given front-ends are discarded. *
* Use it following termination of a {@link Parallel}, some/all of whose * sub-processes were enrolled by being given front-ends * returned by {@link #expand(int) expand}. * See the documentation for {@link #expand(int) expand}. *
** Warning: only the process that went {@link Parallel} should invoke * this method -- never one of the sub-processes. *
** Warning: never invoke this method whilst processes using * its argument's front-ends are running. *
** Warning: do not attempt to reuse any of the argument elements afterwards * -- they front-end nothing. *
** * @param ab the front-ends being discarded from this barrier. * This array must be unaltered from one previously delivered by * an {@link #expand(int) expand}. *
*
* @throws IllegalArgumentException if ab is null or zero length.
*
* * @throws AltingBarrierError if the given array is not one previously * delivered by an {@link #expand(int) expand(n)}, or the invoking process is * currently resigned or not the owner of this front-end. */ public void contract (AltingBarrier[] ab) { if (ab == null) { throw new IllegalArgumentException ( "\n*** AltingBarrier contract given a null array." ); } if (ab.length == 0) { throw new IllegalArgumentException ( "\n*** AltingBarrier contract given an empty array." ); } synchronized (base) { // if (myThread == null) { // contract on // myThread = Thread.currentThread (); // a virgin AltingBarrier // } // is an error ??? // else // (PHW) if (myThread != Thread.currentThread ()) { throw new AltingBarrierError ( "\n*** AltingBarrier contract attempted by non-owner." ); } if (!enrolled) { throw new AltingBarrierError ( "\n*** AltingBarrier contract attempted whilst resigned." ); } base.contract (ab); } } /** * This contracts by one the number of processes enrolled in this alting * barrier. * This front-end cannot not be used subsequently. *
* This method should be used on individually created front-ends * (see {@link #expand() expand()}) when, and only when, the process holding * it is about to terminate. * Normally, that process would have been forked by the process * creating this barrier. *
** Warning: do not try to use this front-end following invocation * of this method -- it no longer fronts anything. *
** * @throws AltingBarrierError if currently resigned or not the owner of * this front-end. */ public void contract () { synchronized (base) { // if (myThread == null) { // contract on // myThread = Thread.currentThread (); // a virgin AltingBarrier // } // is an error ??? // else // (PHW) if (myThread != Thread.currentThread ()) { throw new AltingBarrierError ( "\n*** AltingBarrier contract attempted by non-owner." ); } if (!enrolled) { throw new AltingBarrierError ( "\n*** AltingBarrier contract attempted whilst resigned." ); } base.contract (this); } } boolean enable (Alternative a) { // package-only visible synchronized (base) { if (myThread == null) { myThread = Thread.currentThread (); } else if (myThread != Thread.currentThread ()) { throw new AltingBarrierError ( "\n*** AltingBarrier front-end enable by more than one Thread." ); } if (!enrolled) { throw new AltingBarrierError ( "\n*** AltingBarrier front-end enable whilst resigned." ); } if (alt != null) { // in case the same barrier return false; // occurs more than once in } // the same Alternative. if (base.enable ()) { a.setBarrierTrigger (); // let Alternative know we did it return true; } else { alt = a; return false; } } } boolean disable () { // package-only visible synchronized (base) { if (alt == null) { // in case the same barrier return false; // occurs more than once in } // the same Alternative. if (base.disable ()) { alt.setBarrierTrigger (); // let Alternative know we did it alt = null; return true; } else { alt = null; return false; } } } /** * This is the call-back from a successful 'base.enable'. If it was us * that invoked 'base.enable', our 'alt' is null and we don't need to be * scheduled! If we are resigned, ditto. Whoever is calling this 'schedule' * has the 'base' monitor. */ void schedule () { // package-only visible if (alt != null) { alt.schedule (); } } /** * A process may resign only if it is enrolled. * A resigned process may not offer to synchronise on this barrier * (until a subsequent {@link #enroll enroll}). * Other processes can complete the barrier (represented by this front-end) * without participation by the resigned process. *
* Unless all processes synchronising on this barrier terminate in * the same phase, it is usually appropriate for a terminating process * to resign first. Otherwise, its sibling processes will never be * able to complete another synchronisation. *
** Note: a process must not transfer its front-end to another * process whilst resigned from the barrier -- see {@link #mark mark}. *
** * @throws AltingBarrierError if currently resigned. */ public void resign () { synchronized (base) { if (!enrolled) { throw new AltingBarrierError ( "\n*** AltingBarrier.resign() whilst not enrolled." ); } enrolled = false; base.resign (); } } /** * A process may enroll only if it is resigned. * A re-enrolled process may resume offering to synchronise on this barrier * (until a subsequent {@link #resign resign}). * Other processes cannot complete the barrier (represented by this front-end) * without participation by the re-enrolled process. *
* Note: timing re-enrollment on a barrier usually needs some care. * If the barrier is being used for synchronising phases of execution between * a set of processes, it is crucial that re-enrollment occurs in * an appropriate (not arbitrary) phase. * If the trigger for re-enrollment comes from another enrolled process, * that process should be in such an appropriate phase. * The resigned process should re-enroll and, then, acknowledge the trigger. * The triggering process should wait for that acknowledgement. * If the decision to re-enroll is internal (e.g. following a timeout), * a buddy process, enrolled on the barrier, should be asked to provide * that trigger when in an appropriate phase. * The buddy process, perhaps specially built just for this purpose, polls * a service channel for that question when in that phase. * * @throws AltingBarrierError if currently enrolled. */ public void enroll () { synchronized (base) { if (enrolled) { throw new AltingBarrierError ( "\n*** AltingBarrier.enroll() whilst not resigned." ); } enrolled = true; base.enroll (); } } /** * A process may hand its barrier front-end over to another process, * but the receiving process must invoke this method before using it. * Beware that the process that handed it over must no longer use it. *
** Note: a process must not transfer its front-end to another * process whilst resigned from the barrier -- see {@link #resign resign}. * The receiving process assumes this is the case. * This mark will fail if it is not so. *
** See {@link #expand(int) expand(n)} for an example pattern of use. *
* * @throws AltingBarrierError if the front-end is resigned. */ public void mark () { synchronized (base) { if (!enrolled) { throw new AltingBarrierError ( "\n*** Attempt to AltingBarrier.mark() a resigned front-end." ); } myThread = Thread.currentThread (); } } /** * This resets a front-end for reuse. * It still fronts the same barrier. * Following this method, this front-end is enrolled on the barrier * and not owned by any process. *
** Warning: this should only be used to recycle a front-end * whose process has terminated. * It should not be used to transfer a front-end between running * processes (for which {@link #mark mark} should be used). *
** Example: *
* AltingBarrier[] action = AltingBarrier.create (n);
*
* Parallel[] system = new Parallel[n];
* for (int i = 0; i < system.length; i++) {
* system[i] = new Something (action[i], ...);
* }
*
* while (true) {
* // invariant: all 'action' front-ends are enrolled on the barrier.
* // invariant: all 'action' front-ends are not yet owned by any process.
* system.run ();
* // assume: no 'system' process discards (contracts) its 'action' front-end.
* // note: some 'system' processes may have resigned their 'action' front-ends.
* // note: in the next run of 'system', its processes may be different
* // from the point of view of the 'action' front-ends.
* for (int i = 0; i < action.length; i++) {
* action[i].reset ();
* }
* // deduce: loop invariant re-established.
* }
*
*/
public void reset () {
synchronized (base) {
if (!enrolled) {
enrolled = true;
base.enroll ();
}
myThread = null;
}
}
/**
* This is a simple way to perform a committed synchonisation on an
* {@link AltingBarrier} without having to set up an {@link Alternative}.
* For example, if group is an AltingBarrier, then:
* * group.sync (); ** saves first having to construct the single guarded: *
* Alternative groupCommit = new Alternative (new Guard[] {group});
*
* and then:
* * groupCommit.select (); ** If this is the only method of synchronisation performed by all parties * to this barrier, a non-alting {@link Barrier} would be more efficient. * *
* Important note: following a select, priSelect or
* fairSelect on an {@link Alternative} that returns the index of
* an AltingBarrier, that barrier synchronisation has happened.
* Do not proceed to invoke this sync method -- unless, of course,
* you want to wait for a second synchronisation.
*/
public void sync () {
if (singleAlt == null) {
singleAlt = new Alternative (new Guard[] {this});
}
singleAlt.priSelect ();
}
/**
* This is a simple way to poll for synchonisation on an
* {@link AltingBarrier} without having to set up an {@link Alternative}.
* The parameter specifies how long this poll should leave its offer
* to synchronise on the table.
* If true is returned, the barrier has completed.
* If false, the barrier was unable to complete within
* the time specified (i.e. at no time were all parties making
* an offer).
*
* For example, if group is an AltingBarrier, then:
*
* if (group.poll (offerTime)) {
* ... group synchronisation achieved
* } else {
* ... group synchronisation failed (within offerTime millisecs)
* }
*
* is equivalent to:
*
* groupTimer.setAlarm (groupTimer.read () + offerTime);
* if (groupPoll.priSelect () == 0) {
* ... group synchronisation achieved
* } else {
* ... group synchronisation failed (within offerTime millisecs)
* }
*
* where first would have to have been constructed:
*
* CSTimer groupTimer = new CSTimer ();
* Alternative groupPoll =
* new Alternative (new Guard[] {group, groupTimer});
*
* Note: polling algorithms should generally be a last resort!
* If all parties to this barrier only use this method, synchronisation
* depends on all their poll periods coinciding.
* An offerTime of zero is allowed: if all other parties
* are offering, the barrier will complete -- otherwise, the poll returns
* immediately.
* However, if more than one party only ever polls like this,
* no synchronisation will ever take place.
*
* * * @param offerTime the time (in milliseconds) that this offer to synchronise * should be left on the table. *
*
* @return true if and only if the barrier completes within
* time specifed.
*/
public boolean poll (long offerTime) {
if (pollAlt == null) {
pollTime = new CSTimer ();
pollAlt = new Alternative (new Guard[] {this, pollTime});
}
pollTime.setAlarm (pollTime.read () + offerTime);
return (pollAlt.priSelect () == 0);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/BufferedAny2AnyChannel.java 0000644 0000000 0000000 00000012046 11105701167 021145 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.*;
/**
* This implements an any-to-any object channel with user-definable buffering,
* safe for use by many writers and many readers.
*
Description
* BufferedAny2AnyChannel implements an any-to-any object channel with * user-definable buffering. It is safe for use by any number of reading or * writing processes. Reading processes compete with each other to use * the channel. Writing processes compete with each other to use the channel. * Only the reader and one writer will * actually be using the channel at any one time. This is taken care of by * BufferedAny2AnyChannel -- user processes just read from or write to it. ** Please note that this is a safely shared channel and not * a multicaster. Currently, multicasting has to be managed by * writing active processes (see {@link org.jcsp.plugNplay.DynamicDelta} * for an example of broadcasting). *
* All reading processes and writing processes commit to the channel * (i.e. may not back off). This means that the reading processes * may not {@link Alternative ALT} on this channel. *
* The constructor requires the user to provide * the channel with a plug-in driver conforming to the * {@link org.jcsp.util.ChannelDataStore ChannelDataStore} * interface. This allows a variety of different channel semantics to be * introduced -- including buffered channels of user-defined capacity * (including infinite), overwriting channels (with various overwriting * policies) etc.. * Standard examples are given in the org.jcsp.util package, but * careful users may write their own. * *
Implementation Note and Caution
* Fair servicing of readers and writers to this channel depends on the fair * servicing of requests to enter a synchronized block (or method) by * the underlying Java Virtual Machine (JVM). Java does not specify how threads * waiting to synchronize should be handled. Currently, Sun's standard JDKs queue * these requests - which is fair. However, there is at least one JVM * that puts such competing requests on a stack - which is legal but unfair * and can lead to infinite starvation. This is a problem for any Java system * relying on good behaviour from synchronized, not just for these * any-any channels. * * @see org.jcsp.lang.BufferedOne2OneChannel * @see org.jcsp.lang.BufferedOne2AnyChannel * @see org.jcsp.lang.BufferedAny2AnyChannel * @see org.jcsp.util.ChannelDataStore * * @author P.D. Austin and P.H. Welch */ class BufferedAny2AnyChannel extends Any2AnyImpl { /** * Constructs a new BufferedAny2AnyChannel with the specified ChannelDataStore. * * @param data The ChannelDataStore used to store the data for the channel */ public BufferedAny2AnyChannel(ChannelDataStore data) { super(new BufferedOne2OneChannel(data)); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/Channel.java 0000644 0000000 0000000 00000166074 11113402355 016307 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; import org.jcsp.util.ChannelDataStore; import org.jcsp.util.ints.ChannelDataStoreInt; /** *This class provides static factory methods for constructing * all the different types of channel. *
** Channels carry either Objects or integers. *
** Basic channels are zero-buffered: the writer and reader processes must synchronise. * Buffered channels can be made with various buffering policies: * e.g. fixed size blocking FIFO ({@link org.jcsp.util.Buffer here}), * fixed size overwrite-oldest-when-full ({@link org.jcsp.util.OverWriteOldestBuffer here}), * fixed size discard-when-full ({@link org.jcsp.util.OverFlowingBuffer here}), * infinite sized FIFO ({@link org.jcsp.util.InfiniteBuffer here}). *
** Channels can be made {@link Poisonable} with user-chosen immunity * (for the simple and safe shutdown of networks or sub-networks). *
** Channels are either one-one (connecting a single writer process * with a single reader), one-any (connecting a single writer process * with any number of readers), any-one (connecting any number of writer processes * with a single reader) or any-any (connecting any number of writer processes * with any number of readers). * Do not misuse them (e.g. use a one-one to connect more than one writer process * to more than one reader). *
** Channels are used to construct process networks. * Channel ends, obtained from a channel via its in() * and out() methods, should be plugged into the processes * that need them. * An input-end is used for reading from the channel; * an output-end is used for writing to the channel. * A process should not be given a whole channel – only the end * that it needs. *
** Channel input-ends of one-one and any-one channels * may be used as {@link Guard guards} in a {@link Alternative choice}. * Channel input-ends of one-any or any-any channels * may not be so used. *
** Channel output-ends of one-one {@link One2OneChannelSymmetric symmetric} channels * may also be used as {@link Guard guards} in a {@link Alternative choice}. * Channel output-ends of all other kinds of channel may not. * Symmetric channels are currently an experiment: buffering and poisoning are not yet supported. *
** For convenience, there are also methods for constructing arrays of channels * (and for extracting arrays of channel-ends from arrays of channels). *
* * * @author P.H. Welch */ public class Channel { /** * Private constructor to stop users from instantiating this class. */ private Channel() { //this class should not be instantiated } /** * The factory to be used by this class. The class should implement * ChannelFactory, ChannelArrayFactory, BufferedChannelFactory and BufferedChannelArrayFactory. */ private static final StandardChannelFactory factory = new StandardChannelFactory(); /* New channel construction methods ... */ /** * This constructs an Object carrying channel that * may only be connected to one writer and one reader process at a time. * The channel is zero-buffered – the writer and reader processes must synchronise. * * @return the channel. */ public static One2OneChannel one2one() { return new One2OneChannelImpl(); } /** * This constructs an Object carrying channel that * may only be connected to one writer at a time, * but any number of reader processes. * The readers contend safely with each other to take the next message. * Each message flows from the writer to just one of the readers – * this is not a broadcasting channel. * The channel is zero-buffered – the writer and reader processes must synchronise. * * @return the channel. */ public static One2AnyChannel one2any() { return new One2AnyChannelImpl(); } /** * This constructs an Object carrying channel that * may be connected to any number of writer processes, * but only one reader at a time. * The writers contend safely with each other to send the next message. * Each message flows from just one of the writers to the reader – * this is not a combining channel. * The channel is zero-buffered – the writer and reader processes must synchronise. * * @return the channel. */ public static Any2OneChannel any2one() { return new Any2OneChannelImpl(); } /** * This constructs an Object carrying channel that * may be connected to any number of writer processes * and any number of reader processes. * The writers contend safely with each other to send the next message. * The readers contend safely with each other to take the next message. * Each message flows from just one of the writers to just one of the readers – * this is not a broadcasting-and-combining channel. * The channel is zero-buffered – the writer and reader processes must synchronise. * * @return the channel. */ public static Any2AnyChannel any2any() { return new Any2AnyChannelImpl(); } /** * This constructs a one-one Object channel with user chosen buffering size and policy. * * @param buffer defines size and policy (the channel will clone its own). * @return the channel. */ public static One2OneChannel one2one(ChannelDataStore buffer) { return new BufferedOne2OneChannel(buffer); } /** * This constructs a one-any Object channel with user chosen buffering size and policy. * * @param buffer defines size and policy (the channel will clone its own). * @return the channel. */ public static One2AnyChannel one2any(ChannelDataStore buffer) { return new BufferedOne2AnyChannel(buffer); } /** * This constructs an any-one Object channel with user chosen buffering size and policy. * * @param buffer defines size and policy (the channel will clone its own). * @return the channel. */ public static Any2OneChannel any2one(ChannelDataStore buffer) { return new BufferedAny2OneChannel(buffer); } /** * This constructs an any-any Object channel with user chosen buffering size and policy. * * @param buffer defines size and policy (the channel will clone its own). * @return the channel. */ public static Any2AnyChannel any2any(ChannelDataStore buffer) { return new BufferedAny2AnyChannel(buffer); } /** * This constructs a poisonable one-one Object channel. * * @param immunity the channel is immune to poison strengths up to and including this level. * @return the channel. */ public static One2OneChannel one2one(int immunity) { return new PoisonableOne2OneChannelImpl(immunity); } /** * This constructs a poisonable one-any Object channel. * * @param immunity the channel is immune to poison strengths up to and including this level. * @return the channel. */ public static One2AnyChannel one2any(int immunity) { return new PoisonableOne2AnyChannelImpl(immunity); } /** * This constructs a poisonable any-one Object channel. * * @param immunity the channel is immune to poison strengths up to and including this level. * @return the channel. */ public static Any2OneChannel any2one(int immunity) { return new PoisonableAny2OneChannelImpl(immunity); } /** * This constructs a poisonable any-any Object channel. * * @param immunity the channel is immune to poison strengths up to and including this level. * @return the channel. */ public static Any2AnyChannel any2any(int immunity) { return new PoisonableAny2AnyChannelImpl(immunity); } /** * This constructs a buffered poisonable one-one Object channel. * * @param buffer defines size and policy (the channel will clone its own). * @param immunity the channel is immune to poison strengths up to and including this level. * @return the channel. */ public static One2OneChannel one2one(ChannelDataStore buffer, int immunity) { return new PoisonableBufferedOne2OneChannel(buffer, immunity); } /** * This constructs a buffered poisonable one-any Object channel. * * @param buffer defines size and policy (the channel will clone its own). * @param immunity the channel is immune to poison strengths up to and including this level. * @return the channel. */ public static One2AnyChannel one2any(ChannelDataStore buffer, int immunity) { return new PoisonableBufferedOne2AnyChannel(buffer, immunity); } /** * This constructs a buffered poisonable any-one Object channel. * * @param buffer defines size and policy (the channel will clone its own). * @param immunity the channel is immune to poison strengths up to and including this level. * @return the channel. */ public static Any2OneChannel any2one(ChannelDataStore buffer, int immunity) { return new PoisonableBufferedAny2OneChannel(buffer, immunity); } /** * This constructs a buffered poisonable any-any Object channel. * * @param buffer defines size and policy (the channel will clone its own). * @param immunity the channel is immune to poison strengths up to and including this level. * @return the channel. */ public static Any2AnyChannel any2any(ChannelDataStore buffer, int immunity) { return new PoisonableBufferedAny2AnyChannel(buffer, immunity); } /** * This constructs an array of one-one Object channels. * * @param size defines size of the array (must be positive). * @return the channel array. */ public static One2OneChannel[] one2oneArray(int size) { One2OneChannel[] r = new One2OneChannel[size]; for (int i = 0;i < size;i++) { r[i] = one2one(); } return r; } /** * This constructs an array of one-any Object channels. * * @param size defines size of the array (must be positive). * @return the channel array. */ public static One2AnyChannel[] one2anyArray(int size) { One2AnyChannel[] r = new One2AnyChannel[size]; for (int i = 0;i < size;i++) { r[i] = one2any(); } return r; } /** * This constructs an array of any-one Object channels. * * @param size defines size of the array (must be positive). * @return the channel array. */ public static Any2OneChannel[] any2oneArray(int size) { Any2OneChannel[] r = new Any2OneChannel[size]; for (int i = 0;i < size;i++) { r[i] = any2one(); } return r; } /** * This constructs an array of any-any Object channels. * * @param size defines size of the array (must be positive). * @return the channel array. */ public static Any2AnyChannel[] any2anyArray(int size) { Any2AnyChannel[] r = new Any2AnyChannel[size]; for (int i = 0;i < size;i++) { r[i] = any2any(); } return r; } /** * This constructs an array of poisonable one-one Object channels. * * @param size defines size of the array (must be positive). * @param immunity the channels are immune to poison strengths up to and including this level. * @return the channel array. */ public static One2OneChannel[] one2oneArray(int size, int immunity) { One2OneChannel[] r = new One2OneChannel[size]; for (int i = 0;i < size;i++) { r[i] = one2one(immunity); } return r; } /** * This constructs an array of poisonable one-any Object channels. * * @param size defines size of the array (must be positive). * @param immunity the channels are immune to poison strengths up to and including this level. * @return the channel array. */ public static One2AnyChannel[] one2anyArray(int size, int immunity) { One2AnyChannel[] r = new One2AnyChannel[size]; for (int i = 0;i < size;i++) { r[i] = one2any(immunity); } return r; } /** * This constructs an array of poisonable any-one Object channels. * * @param size defines size of the array (must be positive). * @param immunity the channels are immune to poison strengths up to and including this level. * @return the channel array. */ public static Any2OneChannel[] any2oneArray(int size, int immunity) { Any2OneChannel[] r = new Any2OneChannel[size]; for (int i = 0;i < size;i++) { r[i] = any2one(immunity); } return r; } /** * This constructs an array of poisonable any-any Object channels. * * @param size defines size of the array (must be positive). * @param immunity the channels are immune to poison strengths up to and including this level. * @return the channel array. */ public static Any2AnyChannel[] any2anyArray(int size, int immunity) { Any2AnyChannel[] r = new Any2AnyChannel[size]; for (int i = 0;i < size;i++) { r[i] = any2any(immunity); } return r; } /** * This constructs an array of buffered one-one Object channels. * * @param size defines size of the array (must be positive). * @param buffer defines size and policy (the channel will clone its own). * @return the channel array. */ public static One2OneChannel[] one2oneArray(int size, ChannelDataStore buffer) { One2OneChannel[] r = new One2OneChannel[size]; for (int i = 0;i < size;i++) { r[i] = one2one(buffer); } return r; } /** * This constructs an array of buffered one-any Object channels. * * @param size defines size of the array (must be positive). * @param buffer defines size and policy (the channel will clone its own). * @return the channel array. */ public static One2AnyChannel[] one2anyArray(int size, ChannelDataStore buffer) { One2AnyChannel[] r = new One2AnyChannel[size]; for (int i = 0;i < size;i++) { r[i] = one2any(buffer); } return r; } /** * This constructs an array of buffered any-one Object channels. * * @param size defines size of the array (must be positive). * @param buffer defines size and policy (the channel will clone its own). * @return the channel array. */ public static Any2OneChannel[] any2oneArray(int size, ChannelDataStore buffer) { Any2OneChannel[] r = new Any2OneChannel[size]; for (int i = 0;i < size;i++) { r[i] = any2one(buffer); } return r; } /** * This constructs an array of buffered any-any Object channels. * * @param size defines size of the array (must be positive). * @param buffer defines size and policy (the channel will clone its own). * @return the channel array. */ public static Any2AnyChannel[] any2anyArray(int size, ChannelDataStore buffer) { Any2AnyChannel[] r = new Any2AnyChannel[size]; for (int i = 0;i < size;i++) { r[i] = any2any(buffer); } return r; } /** * This constructs an array of buffered poisonable one-one Object channels. * * @param size defines size of the array (must be positive). * @param buffer defines size and policy (the channel will clone its own). * @param immunity the channels are immune to poison strengths up to and including this level. * @return the channel array. */ public static One2OneChannel[] one2oneArray(int size, ChannelDataStore buffer, int immunity) { One2OneChannel[] r = new One2OneChannel[size]; for (int i = 0;i < size;i++) { r[i] = one2one(buffer,immunity); } return r; } /** * This constructs an array of buffered poisonable one-any Object channels. * * @param size defines size of the array (must be positive). * @param buffer defines size and policy (the channel will clone its own). * @param immunity the channels are immune to poison strengths up to and including this level. * @return the channel array. */ public static One2AnyChannel[] one2anyArray(int size, ChannelDataStore buffer, int immunity) { One2AnyChannel[] r = new One2AnyChannel[size]; for (int i = 0;i < size;i++) { r[i] = one2any(buffer,immunity); } return r; } /** * This constructs an array of buffered poisonable any-one Object channels. * * @param size defines size of the array (must be positive). * @param buffer defines size and policy (the channel will clone its own). * @param immunity the channels are immune to poison strengths up to and including this level. * @return the channel array. */ public static Any2OneChannel[] any2oneArray(int size, ChannelDataStore buffer, int immunity) { Any2OneChannel[] r = new Any2OneChannel[size]; for (int i = 0;i < size;i++) { r[i] = any2one(buffer,immunity); } return r; } /** * This constructs an array of buffered poisonable any-any Object channels. * * @param size defines size of the array (must be positive). * @param buffer defines size and policy (the channel will clone its own). * @param immunity the channels are immune to poison strengths up to and including this level. * @return the channel array. */ public static Any2AnyChannel[] any2anyArray(int size, ChannelDataStore buffer, int immunity) { Any2AnyChannel[] r = new Any2AnyChannel[size]; for (int i = 0;i < size;i++) { r[i] = any2any(buffer,immunity); } return r; } /** * This constructs an Object carrying channel that * may only be connected to one writer and one reader process at a time. * The channel is zero-buffered – the writer and reader processes must synchronise. ** The symmetry relates to the use of the channel's ends as {@link Guard guards} * in an {@link Alternative}: both ends may be so used. * * @return the channel. */ public static One2OneChannelSymmetric one2oneSymmetric () { return new BasicOne2OneChannelSymmetric (); } /** * This constructs an array of symmetric one-one Object channels. * * @param size defines size of the array (must be positive). * @return the channel array. */ public static One2OneChannelSymmetric[] one2oneSymmetricArray(int size) { One2OneChannelSymmetric[] r = new One2OneChannelSymmetric[size]; for (int i = 0;i < size;i++) { r[i] = one2oneSymmetric(); } return r; } /** * This constructs an integer carrying channel that * may only be connected to one writer and one reader process at a time. * The channel is zero-buffered – the writer and reader processes must synchronise. * * @return the channel. */ public static One2OneChannelInt one2oneInt() { return new One2OneChannelIntImpl(); } /** * This constructs an integer carrying channel that * may only be connected to one writer at a time, * but any number of reader processes. * The readers contend safely with each other to take the next message. * Each message flows from the writer to just one of the readers – * this is not a broadcasting channel. * The channel is zero-buffered – the writer and reader processes must synchronise. * * @return the channel. */ public static One2AnyChannelInt one2anyInt() { return new One2AnyChannelIntImpl(); } /** * This constructs an integer carrying channel that * may be connected to any number of writer processes, * but only one reader at a time. * The writers contend safely with each other to send the next message. * Each message flows from just one of the writers to the reader – * this is not a combining channel. * The channel is zero-buffered – the writer and reader processes must synchronise. * * @return the channel. */ public static Any2OneChannelInt any2oneInt() { return new Any2OneChannelIntImpl(); } /** * This constructs an integer carrying channel that * may be connected to any number of writer processes * and any number of reader processes. * The writers contend safely with each other to send the next message. * The readers contend safely with each other to take the next message. * Each message flows from just one of the writers to just one of the readers – * this is not a broadcasting-and-combining channel. * The channel is zero-buffered – the writer and reader processes must synchronise. * * @return the channel. */ public static Any2AnyChannelInt any2anyInt() { return new Any2AnyChannelIntImpl(); } /** * This constructs a one-one integer channel with user chosen buffering size and policy. * * @param buffer defines size and policy (the channel will clone its own). * @return the channel. */ public static One2OneChannelInt one2oneInt(ChannelDataStoreInt buffer) { return new BufferedOne2OneChannelIntImpl(buffer); } /** * This constructs a one-any integer channel with user chosen buffering size and policy. * * @param buffer defines size and policy (the channel will clone its own). * @return the channel. */ public static One2AnyChannelInt one2anyInt(ChannelDataStoreInt buffer) { return new BufferedOne2AnyChannelIntImpl(buffer); } /** * This constructs an any-one integer channel with user chosen buffering size and policy. * * @param buffer defines size and policy (the channel will clone its own). * @return the channel. */ public static Any2OneChannelInt any2oneInt(ChannelDataStoreInt buffer) { return new BufferedAny2OneChannelIntImpl(buffer); } /** * This constructs an any-any integer channel with user chosen buffering size and policy. * * @param buffer defines size and policy (the channel will clone its own). * @return the channel. */ public static Any2AnyChannelInt any2anyInt(ChannelDataStoreInt buffer) { return new BufferedAny2AnyChannelIntImpl(buffer); } /** * This constructs a poisonable one-one integer channel. * * @param immunity the channel is immune to poison strengths up to and including this level. * @return the channel. */ public static One2OneChannelInt one2oneInt(int immunity) { return new PoisonableOne2OneChannelIntImpl(immunity); } /** * This constructs a poisonable one-any integer channel. * * @param immunity the channel is immune to poison strengths up to and including this level. * @return the channel. */ public static One2AnyChannelInt one2anyInt(int immunity) { return new PoisonableOne2AnyChannelIntImpl(immunity); } /** * This constructs a poisonable any-one integer channel. * * @param immunity the channel is immune to poison strengths up to and including this level. * @return the channel. */ public static Any2OneChannelInt any2oneInt(int immunity) { return new PoisonableAny2OneChannelIntImpl(immunity); } /** * This constructs a poisonable any-any integer channel. * * @param immunity the channel is immune to poison strengths up to and including this level. * @return the channel. */ public static Any2AnyChannelInt any2anyInt(int immunity) { return new PoisonableAny2AnyChannelIntImpl(immunity); } /** * This constructs a buffered poisonable one-one integer channel. * * @param buffer defines size and policy (the channel will clone its own). * @param immunity the channel is immune to poison strengths up to and including this level. * @return the channel. */ public static One2OneChannelInt one2oneInt(ChannelDataStoreInt buffer, int immunity) { return new PoisonableBufferedOne2OneChannelInt(buffer, immunity); } /** * This constructs a buffered poisonable one-any integer channel. * * @param buffer defines size and policy (the channel will clone its own). * @param immunity the channel is immune to poison strengths up to and including this level. * @return the channel. */ public static One2AnyChannelInt one2anyInt(ChannelDataStoreInt buffer, int immunity) { return new PoisonableBufferedOne2AnyChannelInt(buffer, immunity); } /** * This constructs a buffered poisonable any-one integer channel. * * @param buffer defines size and policy (the channel will clone its own). * @param immunity the channel is immune to poison strengths up to and including this level. * @return the channel. */ public static Any2OneChannelInt any2oneInt(ChannelDataStoreInt buffer, int immunity) { return new PoisonableBufferedAny2OneChannelInt(buffer, immunity); } /** * This constructs a buffered poisonable any-any integer channel. * * @param buffer defines size and policy (the channel will clone its own). * @param immunity the channel is immune to poison strengths up to and including this level. * @return the channel. */ public static Any2AnyChannelInt any2anyInt(ChannelDataStoreInt buffer, int immunity) { return new PoisonableBufferedAny2AnyChannelInt(buffer, immunity); } /** * This constructs an array of one-one integer channels. * * @param size defines size of the array (must be positive). * @return the channel array. */ public static One2OneChannelInt[] one2oneIntArray(int size) { One2OneChannelInt[] r = new One2OneChannelInt[size]; for (int i = 0;i < size;i++) { r[i] = one2oneInt(); } return r; } /** * This constructs an array of one-any integer channels. * * @param size defines size of the array (must be positive). * @return the channel array. */ public static One2AnyChannelInt[] one2anyIntArray(int size) { One2AnyChannelInt[] r = new One2AnyChannelInt[size]; for (int i = 0;i < size;i++) { r[i] = one2anyInt(); } return r; } /** * This constructs an array of any-one integer channels. * * @param size defines size of the array (must be positive). * @return the channel array. */ public static Any2OneChannelInt[] any2oneIntArray(int size) { Any2OneChannelInt[] r = new Any2OneChannelInt[size]; for (int i = 0;i < size;i++) { r[i] = any2oneInt(); } return r; } /** * This constructs an array of any-any integer channels. * * @param size defines size of the array (must be positive). * @return the channel array. */ public static Any2AnyChannelInt[] any2anyIntArray(int size) { Any2AnyChannelInt[] r = new Any2AnyChannelInt[size]; for (int i = 0;i < size;i++) { r[i] = any2anyInt(); } return r; } /** * This constructs an array of poisonable one-one integer channels. * * @param size defines size of the array (must be positive). * @param immunity the channels are immune to poison strengths up to and including this level. * @return the channel array. */ public static One2OneChannelInt[] one2oneIntArray(int size, int immunity) { One2OneChannelInt[] r = new One2OneChannelInt[size]; for (int i = 0;i < size;i++) { r[i] = one2oneInt(immunity); } return r; } /** * This constructs an array of poisonable one-any integer channels. * * @param size defines size of the array (must be positive). * @param immunity the channels are immune to poison strengths up to and including this level. * @return the channel array. */ public static One2AnyChannelInt[] one2anyIntArray(int size, int immunity) { One2AnyChannelInt[] r = new One2AnyChannelInt[size]; for (int i = 0;i < size;i++) { r[i] = one2anyInt(immunity); } return r; } /** * This constructs an array of poisonable any-one integer channels. * * @param size defines size of the array (must be positive). * @param immunity the channels are immune to poison strengths up to and including this level. * @return the channel array. */ public static Any2OneChannelInt[] any2oneIntArray(int size, int immunity) { Any2OneChannelInt[] r = new Any2OneChannelInt[size]; for (int i = 0;i < size;i++) { r[i] = any2oneInt(immunity); } return r; } /** * This constructs an array of poisonable any-any integer channels. * * @param size defines size of the array (must be positive). * @param immunity the channels are immune to poison strengths up to and including this level. * @return the channel array. */ public static Any2AnyChannelInt[] any2anyIntArray(int size, int immunity) { Any2AnyChannelInt[] r = new Any2AnyChannelInt[size]; for (int i = 0;i < size;i++) { r[i] = any2anyInt(immunity); } return r; } /** * This constructs an array of buffered one-one integer channels. * * @param size defines size of the array (must be positive). * @param buffer defines size and policy (the channel will clone its own). * @return the channel array. */ public static One2OneChannelInt[] one2oneIntArray(int size, ChannelDataStoreInt buffer) { One2OneChannelInt[] r = new One2OneChannelInt[size]; for (int i = 0;i < size;i++) { r[i] = one2oneInt(buffer); } return r; } /** * This constructs an array of buffered one-any integer channels. * * @param size defines size of the array (must be positive). * @param buffer defines size and policy (the channel will clone its own). * @return the channel array. */ public static One2AnyChannelInt[] one2anyIntArray(int size, ChannelDataStoreInt buffer) { One2AnyChannelInt[] r = new One2AnyChannelInt[size]; for (int i = 0;i < size;i++) { r[i] = one2anyInt(buffer); } return r; } /** * This constructs an array of buffered any-one integer channels. * * @param size defines size of the array (must be positive). * @param buffer defines size and policy (the channel will clone its own). * @return the channel array. */ public static Any2OneChannelInt[] any2oneIntArray(int size, ChannelDataStoreInt buffer) { Any2OneChannelInt[] r = new Any2OneChannelInt[size]; for (int i = 0;i < size;i++) { r[i] = any2oneInt(buffer); } return r; } /** * This constructs an array of buffered any-any integer channels. * * @param size defines size of the array (must be positive). * @param buffer defines size and policy (the channel will clone its own). * @return the channel array. */ public static Any2AnyChannelInt[] any2anyIntArray(int size, ChannelDataStoreInt buffer) { Any2AnyChannelInt[] r = new Any2AnyChannelInt[size]; for (int i = 0;i < size;i++) { r[i] = any2anyInt(buffer); } return r; } /** * This constructs an array of buffered poisonable one-one integer channels. * * @param size defines size of the array (must be positive). * @param buffer defines size and policy (the channel will clone its own). * @param immunity the channels are immune to poison strengths up to and including this level. * @return the channel array. */ public static One2OneChannelInt[] one2oneIntArray(int size, ChannelDataStoreInt buffer, int immunity) { One2OneChannelInt[] r = new One2OneChannelInt[size]; for (int i = 0;i < size;i++) { r[i] = one2oneInt(buffer,immunity); } return r; } /** * This constructs an array of buffered poisonable one-any integer channels. * * @param size defines size of the array (must be positive). * @param buffer defines size and policy (the channel will clone its own). * @param immunity the channels are immune to poison strengths up to and including this level. * @return the channel array. */ public static One2AnyChannelInt[] one2anyIntArray(int size, ChannelDataStoreInt buffer, int immunity) { One2AnyChannelInt[] r = new One2AnyChannelInt[size]; for (int i = 0;i < size;i++) { r[i] = one2anyInt(buffer,immunity); } return r; } /** * This constructs an array of buffered poisonable any-one integer channels. * * @param size defines size of the array (must be positive). * @param buffer defines size and policy (the channel will clone its own). * @param immunity the channels are immune to poison strengths up to and including this level. * @return the channel array. */ public static Any2OneChannelInt[] any2oneIntArray(int size, ChannelDataStoreInt buffer, int immunity) { Any2OneChannelInt[] r = new Any2OneChannelInt[size]; for (int i = 0;i < size;i++) { r[i] = any2oneInt(buffer,immunity); } return r; } /** * This constructs an array of buffered poisonable any-any integer channels. * * @param size defines size of the array (must be positive). * @param buffer defines size and policy (the channel will clone its own). * @param immunity the channels are immune to poison strengths up to and including this level. * @return the channel array. */ public static Any2AnyChannelInt[] any2anyIntArray(int size, ChannelDataStoreInt buffer, int immunity) { Any2AnyChannelInt[] r = new Any2AnyChannelInt[size]; for (int i = 0;i < size;i++) { r[i] = any2anyInt(buffer,immunity); } return r; } /** * This constructs an integer carrying channel that * may only be connected to one writer and one reader process at a time. * The channel is zero-buffered – the writer and reader processes must synchronise. *
* The symmetry relates to the use of the channel's ends as {@link Guard guards}
* in an {@link Alternative}: both ends may be so used.
*
* @return the channel.
*/
public static One2OneChannelSymmetricInt one2oneSymmetricInt ()
{
return new BasicOne2OneChannelSymmetricInt ();
}
/**
* This constructs an array of symmetric one-one integer channels.
*
* @param size defines size of the array (must be positive).
* @return the channel array.
*/
public static One2OneChannelSymmetricInt[] one2oneSymmetricIntArray(int size)
{
One2OneChannelSymmetricInt[] r = new One2OneChannelSymmetricInt[size];
for (int i = 0;i < size;i++)
{
r[i] = one2oneSymmetricInt();
}
return r;
}
/* Helper methods to get arrays of channel ends ... */
/**
* This extracts the input-ends from the given channel array.
* Each element of the returned array is the input-end of the channel
* at the corresponding index in the given channel array.
*
* @param c an array of channels.
* @return the array of input-ends from the given channel array.
*/
public static AltingChannelInput[] getInputArray(One2OneChannel[] c)
{
AltingChannelInput[] in = new AltingChannelInput[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].in();
return in;
}
/**
* This extracts the input-ends from the given channel array.
* Each element of the returned array is the input-end of the channel
* at the corresponding index in the given channel array.
*
* @param c an array of channels.
* @return the array of input-ends from the given channel array.
*/
public static SharedChannelInput[] getInputArray(One2AnyChannel[] c)
{
SharedChannelInput[] in = new SharedChannelInput[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].in();
return in;
}
/**
* This extracts the input-ends from the given channel array.
* Each element of the returned array is the input-end of the channel
* at the corresponding index in the given channel array.
*
* @param c an array of channels.
* @return the array of input-ends from the given channel array.
*/
public static AltingChannelInput[] getInputArray(Any2OneChannel[] c)
{
AltingChannelInput[] in = new AltingChannelInput[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].in();
return in;
}
/**
* This extracts the input-ends from the given channel array.
* Each element of the returned array is the input-end of the channel
* at the corresponding index in the given channel array.
*
* @param c an array of channels.
* @return the array of input-ends from the given channel array.
*/
public static SharedChannelInput[] getInputArray(Any2AnyChannel[] c)
{
SharedChannelInput[] in = new SharedChannelInput[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].in();
return in;
}
/**
* This extracts the output-ends from the given channel array.
* Each element of the returned array is the output-end of the channel
* at the corresponding index in the given channel array.
*
* @param c an array of channels.
* @return the array of output-ends from the given channel array.
*/
public static ChannelOutput[] getOutputArray(One2OneChannel[] c)
{
ChannelOutput[] in = new ChannelOutput[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].out();
return in;
}
/**
* This extracts the output-ends from the given channel array.
* Each element of the returned array is the output-end of the channel
* at the corresponding index in the given channel array.
*
* @param c an array of channels.
* @return the array of output-ends from the given channel array.
*/
public static ChannelOutput[] getOutputArray(One2AnyChannel[] c)
{
ChannelOutput[] in = new ChannelOutput[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].out();
return in;
}
/**
* This extracts the output-ends from the given channel array.
* Each element of the returned array is the output-end of the channel
* at the corresponding index in the given channel array.
*
* @param c an array of channels.
* @return the array of output-ends from the given channel array.
*/
public static SharedChannelOutput[] getOutputArray(Any2OneChannel[] c)
{
SharedChannelOutput[] in = new SharedChannelOutput[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].out();
return in;
}
/**
* This extracts the output-ends from the given channel array.
* Each element of the returned array is the output-end of the channel
* at the corresponding index in the given channel array.
*
* @param c an array of channels.
* @return the array of output-ends from the given channel array.
*/
public static SharedChannelOutput[] getOutputArray(Any2AnyChannel[] c)
{
SharedChannelOutput[] in = new SharedChannelOutput[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].out();
return in;
}
/**
* This extracts the input-ends from the given channel array.
* Each element of the returned array is the input-end of the channel
* at the corresponding index in the given channel array.
*
* @param c an array of channels.
* @return the array of input-ends from the given channel array.
*/
public static AltingChannelInputInt[] getInputArray(One2OneChannelInt[] c)
{
AltingChannelInputInt[] in = new AltingChannelInputInt[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].in();
return in;
}
/**
* This extracts the input-ends from the given channel array.
* Each element of the returned array is the input-end of the channel
* at the corresponding index in the given channel array.
*
* @param c an array of channels.
* @return the array of input-ends from the given channel array.
*/
public static SharedChannelInputInt[] getInputArray(One2AnyChannelInt[] c)
{
SharedChannelInputInt[] in = new SharedChannelInputInt[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].in();
return in;
}
/**
* This extracts the input-ends from the given channel array.
* Each element of the returned array is the input-end of the channel
* at the corresponding index in the given channel array.
*
* @param c an array of channels.
* @return the array of input-ends from the given channel array.
*/
public static AltingChannelInputInt[] getInputArray(Any2OneChannelInt[] c)
{
AltingChannelInputInt[] in = new AltingChannelInputInt[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].in();
return in;
}
/**
* This extracts the input-ends from the given channel array.
* Each element of the returned array is the input-end of the channel
* at the corresponding index in the given channel array.
*
* @param c an array of channels.
* @return the array of input-ends from the given channel array.
*/
public static SharedChannelInputInt[] getInputArray(Any2AnyChannelInt[] c)
{
SharedChannelInputInt[] in = new SharedChannelInputInt[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].in();
return in;
}
/**
* This extracts the output-ends from the given channel array.
* Each element of the returned array is the output-end of the channel
* at the corresponding index in the given channel array.
*
* @param c an array of channels.
* @return the array of output-ends from the given channel array.
*/
public static ChannelOutputInt[] getOutputArray(One2OneChannelInt[] c)
{
ChannelOutputInt[] in = new ChannelOutputInt[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].out();
return in;
}
/**
* This extracts the output-ends from the given channel array.
* Each element of the returned array is the output-end of the channel
* at the corresponding index in the given channel array.
*
* @param c an array of channels.
* @return the array of output-ends from the given channel array.
*/
public static ChannelOutputInt[] getOutputArray(One2AnyChannelInt[] c)
{
ChannelOutputInt[] in = new ChannelOutputInt[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].out();
return in;
}
/**
* This extracts the output-ends from the given channel array.
* Each element of the returned array is the output-end of the channel
* at the corresponding index in the given channel array.
*
* @param c an array of channels.
* @return the array of output-ends from the given channel array.
*/
public static SharedChannelOutputInt[] getOutputArray(Any2OneChannelInt[] c)
{
SharedChannelOutputInt[] in = new SharedChannelOutputInt[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].out();
return in;
}
/**
* This extracts the output-ends from the given channel array.
* Each element of the returned array is the output-end of the channel
* at the corresponding index in the given channel array.
*
* @param c an array of channels.
* @return the array of output-ends from the given channel array.
*/
public static SharedChannelOutputInt[] getOutputArray(Any2AnyChannelInt[] c)
{
SharedChannelOutputInt[] in = new SharedChannelOutputInt[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].out();
return in;
}
/* Methods that are the same as the Factory Methods (all now deprecated) */
/**
* Constructs and returns a One2OneChannel object.
*
* @return the channel.
*
* @see org.jcsp.lang.ChannelFactory#createOne2One()
*
* @deprecated Use the {@link #one2one()} method instead.
*/
public static One2OneChannel createOne2One()
{
return factory.createOne2One();
}
/**
* Constructs and returns an Any2OneChannel object.
*
* @return the channel.
*
* @see org.jcsp.lang.ChannelFactory#createAny2One()
*
* @deprecated Use the {@link #any2one()} method instead.
*/
public static Any2OneChannel createAny2One()
{
return factory.createAny2One();
}
/**
* Constructs and returns a One2AnyChannel object.
*
* @return the channel.
*
* @see org.jcsp.lang.ChannelFactory#createOne2Any()
*
* @deprecated Use the {@link #one2any()} method instead.
*/
public static One2AnyChannel createOne2Any()
{
return factory.createOne2Any();
}
/**
* Constructs and returns an Any2AnyChannel object.
*
* @return the channel.
*
* @see org.jcsp.lang.ChannelFactory#createAny2Any()
*
* @deprecated Use the {@link #any2any()} method instead.
*/
public static Any2AnyChannel createAny2Any()
{
return factory.createAny2Any();
}
/**
* Constructs and returns an array of One2OneChannel
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createOne2One(int)
*
* @deprecated Use the {@link #one2oneArray(int)} method instead.
*/
public static One2OneChannel[] createOne2One(int n)
{
return factory.createOne2One(n);
}
/**
* Constructs and returns an array of Any2OneChannel
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createAny2One(int)
*
* @deprecated Use the {@link #any2oneArray(int)} method instead.
*/
public static Any2OneChannel[] createAny2One(int n)
{
return factory.createAny2One(n);
}
/**
* Constructs and returns an array of One2AnyChannel
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createOne2Any(int)
*
* @deprecated Use the {@link #one2anyArray(int)} method instead.
*/
public static One2AnyChannel[] createOne2Any(int n)
{
return factory.createOne2Any(n);
}
/**
* Constructs and returns an array of Any2AnyChannel
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createAny2Any(int)
*
* @deprecated Use the {@link #any2anyArray(int)} method instead.
*/
public static Any2AnyChannel[] createAny2Any(int n)
{
return factory.createAny2Any(n);
}
/**
*
Constructs and returns a One2OneChannel object which
* uses the specified ChannelDataStore object as a buffer.
*
The buffer supplied to this method is cloned before it is inserted into * the channel. *
* * @param buffer theChannelDataStore to use.
* @return the buffered channel.
*
* @see org.jcsp.lang.BufferedChannelFactory#createOne2One(ChannelDataStore)
* @see org.jcsp.util.ChannelDataStore
*
* @deprecated Use the {@link #one2one(ChannelDataStore)} method instead.
*/
public static One2OneChannel createOne2One(ChannelDataStore buffer)
{
return factory.createOne2One(buffer);
}
/**
* Constructs and returns a Any2OneChannel object which
* uses the specified ChannelDataStore object as a buffer.
*
The buffer supplied to this method is cloned before it is inserted into * the channel. *
* * @param buffer theChannelDataStore to use.
* @return the buffered channel.
*
* @see org.jcsp.lang.BufferedChannelFactory#createAny2One(ChannelDataStore)
* @see org.jcsp.util.ChannelDataStore
*
* @deprecated Use the {@link #any2one(ChannelDataStore)} method instead.
*/
public static Any2OneChannel createAny2One(ChannelDataStore buffer)
{
return factory.createAny2One(buffer);
}
/**
* Constructs and returns a One2AnyChannel object which
* uses the specified ChannelDataStore object as a buffer.
*
The buffer supplied to this method is cloned before it is inserted into * the channel. *
* * @param buffer theChannelDataStore to use.
* @return the buffered channel.
*
* @see org.jcsp.lang.BufferedChannelFactory#createOne2Any(ChannelDataStore)
* @see org.jcsp.util.ChannelDataStore
*
* @deprecated Use the {@link #one2any(ChannelDataStore)} method instead.
*/
public static One2AnyChannel createOne2Any(ChannelDataStore buffer)
{
return factory.createOne2Any(buffer);
}
/**
* Constructs and returns a Any2AnyChannel object which
* uses the specified ChannelDataStore object as a buffer.
*
The buffer supplied to this method is cloned before it is inserted into * the channel. *
* * @param buffer theChannelDataStore to use.
* @return the buffered channel.
*
* @see org.jcsp.lang.BufferedChannelFactory#createAny2Any(ChannelDataStore)
* @see org.jcsp.util.ChannelDataStore
*
* @deprecated Use the {@link #any2any(ChannelDataStore)} method instead.
*/
public static Any2AnyChannel createAny2Any(ChannelDataStore buffer)
{
return factory.createAny2Any(buffer);
}
/**
* Constructs and returns an array of One2OneChannel objects
* which use the specified ChannelDataStore object as a
* buffer.
*
The buffer supplied to this method is cloned before it is inserted into * the channel. This is why an array of buffers is not required. *
* * @param buffer theChannelDataStore to use.
* @param n the size of the array of channels.
* @return the array of buffered channels.
*
* @see org.jcsp.lang.BufferedChannelArrayFactory#createOne2One(ChannelDataStore, int)
* @see org.jcsp.util.ChannelDataStore
*
* @deprecated Use the {@link #one2oneArray(int,ChannelDataStore)} method instead.
*/
public static One2OneChannel[] createOne2One(ChannelDataStore buffer, int n)
{
return factory.createOne2One(buffer, n);
}
/**
* Constructs and returns an array of Any2OneChannel objects
* which use the specified ChannelDataStore object as a
* buffer.
*
The buffer supplied to this method is cloned before it is inserted into * the channel. This is why an array of buffers is not required. *
* * @param buffer theChannelDataStore to use.
* @param n the size of the array of channels.
* @return the array of buffered channels.
*
* @see org.jcsp.lang.BufferedChannelArrayFactory#createAny2One(ChannelDataStore, int)
* @see org.jcsp.util.ChannelDataStore
*
* @deprecated Use the {@link #any2oneArray(int,ChannelDataStore)} method instead.
*/
public static Any2OneChannel[] createAny2One(ChannelDataStore buffer, int n)
{
return factory.createAny2One(buffer, n);
}
/**
* Constructs and returns an array of One2AnyChannel objects
* which use the specified ChannelDataStore object as a
* buffer.
*
The buffer supplied to this method is cloned before it is inserted into * the channel. This is why an array of buffers is not required. *
* * @param buffer theChannelDataStore to use.
* @param n the size of the array of channels.
* @return the array of buffered channels.
*
* @see org.jcsp.lang.BufferedChannelArrayFactory#createOne2Any(ChannelDataStore, int)
* @see org.jcsp.util.ChannelDataStore
*
* @deprecated Use the {@link #one2anyArray(int,ChannelDataStore)} method instead.
*/
public static One2AnyChannel[] createOne2Any(ChannelDataStore buffer, int n)
{
return factory.createOne2Any(buffer, n);
}
/**
* Constructs and returns an array of Any2AnyChannel objects
* which use the specified ChannelDataStore object as a
* buffer.
*
The buffer supplied to this method is cloned before it is inserted into * the channel. This is why an array of buffers is not required. *
* * @param buffer theChannelDataStore to use.
* @param n the size of the array of channels.
* @return the array of buffered channels.
*
* @see org.jcsp.lang.BufferedChannelArrayFactory#createAny2Any(ChannelDataStore, int)
* @see org.jcsp.util.ChannelDataStore
*
* @deprecated Use the {@link #any2anyArray(int,ChannelDataStore)} method instead.
*/
public static Any2AnyChannel[] createAny2Any(ChannelDataStore buffer, int n)
{
return factory.createAny2Any(buffer, n);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelOutputWrapper.java 0000644 0000000 0000000 00000006121 11105701167 021057 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* Defines a wrapper to go around a channel output end. This wrapper allows a channel end to be given
* away without any risk of the user of that end casting it to a channel input because they cannot
* gain access to the actual channel end.
*
* @deprecated There is no longer any need to use this class, after the 1.1 class reorganisation.
*
* @author Quickstone Technologies Limited
*/
public class ChannelOutputWrapper implements ChannelOutput
{
/**
* The actual channel end.
*/
private ChannelOutput out;
/**
* Creates a new wrapper for the given channel end.
*
* @param out the existing channel end.
*/
public ChannelOutputWrapper(ChannelOutput out)
{
this.out = out;
}
/**
* Writes a value to the channel.
*
* @param o the value to write.
* @see org.jcsp.lang.ChannelOutput
*/
public void write(Object o)
{
out.write(o);
}
public void poison(int strength)
{
out.poison(strength);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/RejectableChannelInputImpl.java 0000644 0000000 0000000 00000004375 11113671251 022130 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
class RejectableChannelInputImpl extends ChannelInputImpl implements RejectableChannelInput {
public RejectableChannelInputImpl(ChannelInternals _channel, int _immunity) {
super(_channel, _immunity);
}
public void reject()
{
super.poison(Integer.MAX_VALUE);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Any2OneChannel.java 0000644 0000000 0000000 00000013214 11113671251 017471 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This defines an interface for an any-to-one Object channel,
* safe for use by many writers and one reader.
* * The only methods provided are to obtain the ends of the channel, * through which all reading and writing operations are done. * Only an appropriate channel-end should be plugged into a process * – not the whole channel. * A process may use its external channels in one direction only * – either for writing or reading. *
*Actual channels conforming to this interface are made using the relevant * static construction methods from {@link Channel}. * Channels may be {@link Channel#any2one() synchronising}, * {@link Channel#any2one(org.jcsp.util.ChannelDataStore) buffered}, * {@link Channel#any2one(int) poisonable} * or {@link Channel#any2one(org.jcsp.util.ChannelDataStore,int) both} * (i.e. buffered and poisonable). *
*Description
* Any2OneChannel is an interface for a channel which * is safe for use by many writing processes but only one reader. * Writing processes compete with each other to use the channel. * Only the reader and one writer will * actually be using the channel at any one time. This is managed by the * channel – user processes just read from or write to it. * ** Please note that this is a safely shared channel and not a message gatherer. * Currently, gathering has to be managed by writing an active process. *
* The reading process may {@link Alternative ALT} on this channel. * The writing process is committed (i.e. it may not back off). *
** The default semantics of the channel is that of CSP – i.e. it is * zero-buffered and fully synchronised. The reading process must wait * for a matching writer and vice-versa. *
** The static methods of {@link Channel} construct channels with * either the default semantics or with buffering to user-specified capacity * and a range of blocking/overwriting policies. * Various buffering plugins are given in the org.jcsp.util package, but * careful users may write their own. *
** The {@link Channel} methods also provide for the construction of * {@link Poisonable} channels and for arrays of channels. * *
Implementation Note and Caution
* Fair servicing of writers to this channel depends on the fair * servicing of requests to enter a synchronized block (or method) by * the underlying Java Virtual Machine (JVM). Java does not specify how threads * waiting to synchronize should be handled. Currently, Sun's standard JDKs queue * these requests - which is fair. However, there is at least one JVM * that puts such competing requests on a stack - which is legal but unfair * and can lead to infinite starvation. This is a problem for any Java system * relying on good behaviour from synchronized, not just for these * any-1 channels. * * @see org.jcsp.lang.Channel * @see org.jcsp.lang.Alternative * @see org.jcsp.lang.One2OneChannel * @see org.jcsp.lang.One2AnyChannel * @see org.jcsp.lang.Any2AnyChannel * @see org.jcsp.util.ChannelDataStore * * @author P.D. Austin and P.H. Welch */ public interface Any2OneChannel { /** * Returns the input end of the channel. */ public AltingChannelInput in(); /** * Returns the output end of the channel. */ public SharedChannelOutput out(); } jcsp-1.1-rc4.orig/src/org/jcsp/lang/TaggedProtocol.java 0000644 0000000 0000000 00000024227 11105701167 017651 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * TaggedProtocol is the base class for messages carrying * an occam2-like tagged (CASE) protocol over JCSP channels. **
Example
*Protocol Definition
* SampleProtocol illustrates one approach to the passing of different * information structures across the same JCSP channel. It corresponds to the tagged * (CASE) PROTOCOL of occam2.1. The example was invented * by Rick Beton (of Roke Manor Research Ltd.): * ** PROTOCOL String IS BYTE::[]BYTE: -- slight licence here! * * DATA TYPE Complex32 * RECORD * REAL32 real, imag: * : * * PROTOCOL SampleProtocol * CASE * NOTHING.IN.PARTICULAR * STRING; String * INTEGER; INT * COMPLEX; Complex32 * BOO.TO.A.GOOSE * : ** * * This corresponds to the (JCSP) Java declaration: * *
* public class SampleProtocol {
*
* public static final int NOTHING_IN_PARTICULAR = 0;
* public static final int STRING = 1;
* public static final int INTEGER = 2;
* public static final int COMPLEX = 3;
* public static final int BOO_TO_A_GOOSE = 4;
*
* static public class NothingInParticular extends TaggedProtocol {
* public NothingInParticular () {
* super (NOTHING_IN_PARTICULAR);
* }
* }
*
* static public class String extends TaggedProtocol {
* public final java.lang.String string;
* public String (final java.lang.String string) {
* super (STRING);
* this.string = string;
* }
* }
*
* static public class Integer extends TaggedProtocol {
* public final int value;
* public Integer (final int value) {
* super (INTEGER);
* this.value = value;
* }
* }
*
* static public class Complex extends TaggedProtocol {
* public final float real;
* public final float imag;
* public Complex (final float real, final float imag) {
* super (COMPLEX);
* this.real = real;
* this.imag = imag;
* }
* }
*
* static public class BooToAGoose extends TaggedProtocol {
* public BooToAGoose () {
* super (BOO_TO_A_GOOSE);
* }
* }
*
* }
*
* The emphasis in the above definition is security. The protocol variants
* hold only immutable data (whose transmission, therefore, can never lead to race
* hazards). Secondly, it is impossible for the user of the protocol to set up
* an incorrect tag or misinterpret a correct one without raising an exception.
*
* Protocol Use
* This example has a simple pair of CSProcesses communicating over a channel * using the SampleProtocol. ** First, here is the occam2.1 version. The network is defined * (and started) by: *
* CHAN OF SampleProtocol c: * * PAR * Producer (c) * Consumer (c, screen) ** where: *
* PROC Producer (CHAN OF SampleProtocol out) * * VAL []BYTE m1 IS "Hello World ...": * VAL []BYTE m2 IS "Goodbye World ...": * * SEQ * out ! NOTHING.IN.PARTICULAR * out ! STRING; (BYTE SIZE m1)::m1 * out ! INTEGER; 42 * out ! NOTHING.IN.PARTICULAR * out ! COMPLEX; [3.1416, 0.7071] * out ! STRING; (BYTE SIZE m2)::m2 * out ! BOO.TO.A.GOOSE * * : ** and where: *
* PROC Consumer (CHAN OF SampleProtocol in, CHAN OF BYTE screen)
*
* INITIAL BOOL running IS TRUE:
*
* WHILE running
* in ? CASE
* NOTHING.IN.PARTICULAR
* out.string ("==> NothingInParticular happening ...*c*n", 0, screen)
* BYTE size:
* [255]BYTE s:
* STRING; size::s
* SEQ
* out.string ("==> *"", 0, screen)
* out.string ([s FOR INT size], 0, screen)
* out.string ("*"*c*n", 0, screen)
* INT i:
* INTEGER; i
* SEQ
* out.string ("==> ", 0, screen)
* out.number (i, 0, screen)
* out.string ("*c*n", 0, screen)
* Complex32 c:
* COMPLEX; c
* SEQ
* out.string ("==> [", 0, screen)
* out.real32 (c[real], 0, screen)
* out.string (", ", 0, screen)
* out.real32 (c[imag], 0, screen)
* out.string ("*c*n", 0, screen)
* BOO.TO.A.GOOSE
* SEQ
* out.string ("==> Waaaaaa! You scared me!! I'm off!!!", 0, screen)
* running := FALSE
*
* :
*
* * Here is the (JCSP) Java version. The network is defined * (and started) by: *
* final One2OneChannel c = Channel.one2one ();
*
* new Parallel (
* new CSProcess[] {
* new Producer (c),
* new Consumer (c)
* }
* ).run ();
*
*
* where:
*
* import org.jcsp.lang.*;
*
* public class Producer implements CSProcess {
*
* private final ChannelOutput out;
*
* public Producer (ChannelOutput out) {
* this.out = out;
* }
*
* public void run() {
*
* out.write (new SampleProtocol.NothingInParticular ());
* out.write (new SampleProtocol.String ("Hello World ..."));
* out.write (new SampleProtocol.Integer (42));
* out.write (new SampleProtocol.NothingInParticular ());
* out.write (new SampleProtocol.Complex (3.1416f, 0.7071f));
* out.write (new SampleProtocol.String ("Goodbye World ..."));
* out.write (new SampleProtocol.BooToAGoose ());
*
* }
*
* }
*
*
* and where:
*
* import org.jcsp.lang.*;
*
* public class Consumer implements CSProcess {
*
* private final ChannelInput in;
*
* public Consumer (ChannelInput in) {
* this.in = in;
* }
*
* public void run () {
*
* boolean running = true;
*
* while (running) {
*
* TaggedProtocol tp = (TaggedProtocol) in.read ();
*
* switch (tp.tag) {
* case SampleProtocol.NOTHING_IN_PARTICULAR:
* System.out.println ("==> NothingInParticular happening ...");
* break;
* case SampleProtocol.STRING:
* SampleProtocol.String sms = (SampleProtocol.String) tp;
* System.out.println ("==> \"" + sms.string + "\"");
* break;
* case SampleProtocol.INTEGER:
* SampleProtocol.Integer smi = (SampleProtocol.Integer) tp;
* System.out.println ("==> " + smi.value);
* break;
* case SampleProtocol.COMPLEX:
* SampleProtocol.Complex smc = (SampleProtocol.Complex) tp;
* System.out.println ("==> [" + smc.real + ", " + smc.imag + "]");
* break;
* case SampleProtocol.BOO_TO_A_GOOSE:
* System.out.println ("==> Waaaaaa! You scared me!! I'm off!!!");
* running = false;
* break;
* }
*
* }
*
* }
*
* }
*
*
* @author P.H. Welch
*/
public class TaggedProtocol
{
/**
* This public tag is used by the receiving process to determine which variant
* of a tagged protocol has been received.
* See the above Consumer example (and the definition of
* its input channel's SampleProtocol).
*/
public final int tag;
/**
* This super-constructor is invoked by the extending sub-class constructor.
* It should be passed a tag that is unique for the tagged protocol for which
* that sub-class is one variant.
* See the above SampleProtocol (and its use
* in Producer and Consumer).
*/
public TaggedProtocol(final int tag)
{
this.tag = tag;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/One2AnyIntImpl.java 0000644 0000000 0000000 00000006720 11113671251 017501 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
class One2AnyIntImpl implements One2AnyChannelInt, ChannelInternalsInt {
private ChannelInternalsInt channel;
/** The mutex on which readers must synchronize */
private final Mutex readMutex = new Mutex();
One2AnyIntImpl(ChannelInternalsInt _channel) {
channel = _channel;
}
public SharedChannelInputInt in() {
return new SharedChannelInputIntImpl(this,0);
}
public ChannelOutputInt out() {
return new ChannelOutputIntImpl(channel,0);
}
public void endRead() {
channel.endRead();
readMutex.release();
}
public int read() {
readMutex.claim();
//A poison exception might be thrown, hence the try/finally:
try
{
return channel.read();
}
finally
{
readMutex.release();
}
}
//begin never used:
public boolean readerDisable() {
return false;
}
public boolean readerEnable(Alternative alt) {
return false;
}
public boolean readerPending() {
return false;
}
//end never used
public void readerPoison(int strength) {
readMutex.claim();
channel.readerPoison(strength);
readMutex.release();
}
public int startRead() {
readMutex.claim();
try
{
return channel.startRead();
}
catch (RuntimeException e)
{
channel.endRead();
readMutex.release();
throw e;
}
}
//begin never used
public void write(int n) {
channel.write(n);
}
public void writerPoison(int strength) {
channel.writerPoison(strength);
}
//end never used
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelDataRejectedException.java 0000644 0000000 0000000 00000004523 11105701167 022420 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* Thrown by a read or a write method of a channel when a reject has been
* called and the synchronization and data transfer will not complete.
*
* @author Quickstone Technologies Limited
*/
public class ChannelDataRejectedException extends RuntimeException
{
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/AltingChannelAccept.java 0000644 0000000 0000000 00000005542 11105701167 020562 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This extends {@link Guard} and {@link ChannelAccept}
* to enable a process to choose between many CALL channel (and other) events.
* Description
* AltingChannelAccept extends {@link Guard} and {@link ChannelAccept} * to enable a process * to choose between many CALL channel (and other) events. The methods inherited from * Guard are of no concern to users of this package. * *Example
* See the explanations and examples documented in {@link One2OneCallChannel} and * {@link Any2OneCallChannel}. * * @see org.jcsp.lang.Alternative * @see org.jcsp.lang.One2OneCallChannel * @see org.jcsp.lang.Any2OneCallChannel * * @author P.H. Welch */ public abstract class AltingChannelAccept extends Guard implements ChannelAccept { // nothing to add ... } jcsp-1.1-rc4.orig/src/org/jcsp/lang/BufferedOne2OneChannelIntImpl.java 0000644 0000000 0000000 00000025071 11105701167 022430 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; import org.jcsp.util.ChannelDataStore; import org.jcsp.util.ints.*; /** * This implements a one-to-one integer channel with user-definable buffering. *Description
* BufferedOne2OneChannelIntImpl implements a one-to-one integer channel with * user-definable buffering. Multiple readers or multiple writers are * not allowed -- these are catered for by {@link BufferedAny2OneChannel}, * {@link BufferedOne2AnyChannel} or {@link BufferedAny2AnyChannel}. ** The reading process may {@link Alternative ALT} on this channel. * The writing process is committed (i.e. it may not back off). *
* The constructor requires the user to provide
* the channel with a plug-in driver conforming to the
* {@link org.jcsp.util.ints.ChannelDataStoreInt ChannelDataStoreInt}
* interface. This allows a variety of different channel semantics to be
* introduced -- including buffered channels of user-defined capacity
* (including infinite), overwriting channels (with various overwriting
* policies) etc..
* Standard examples are given in the org.jcsp.util package, but
* careful users may write their own.
*
* @see org.jcsp.lang.Alternative
* @see org.jcsp.lang.BufferedAny2OneChannelIntImpl
* @see org.jcsp.lang.BufferedOne2AnyChannelIntImpl
* @see org.jcsp.lang.BufferedAny2AnyChannelIntImpl
* @see org.jcsp.util.ints.ChannelDataStoreInt
*
* @author P.D. Austin
* @author P.H. Welch
*/
class BufferedOne2OneChannelIntImpl implements One2OneChannelInt, ChannelInternalsInt
{
/** The monitor synchronising reader and writer on this channel */
private Object rwMonitor = new Object();
/** The Alternative class that controls the selection */
private Alternative alt;
/** The ChannelDataStoreInt used to store the data for the channel */
private final ChannelDataStoreInt data;
/*************Methods from One2OneChannelInt******************************/
/**
* Returns the AltingChannelInputInt object to use for this
* channel. As One2OneChannelIntImpl implements
* AltingChannelInputInt itself, this method simply returns
* a reference to the object that it is called on.
*
* @return the AltingChannelInputInt object to use for this
* channel.
*/
public AltingChannelInputInt in()
{
return new AltingChannelInputIntImpl(this,0);
}
/**
* Returns the ChannelOutputInt object to use for this
* channel. As One2OneChannelIntImpl implements
* ChannelOutputInt itself, this method simply returns
* a reference to the object that it is called on.
*
* @return the ChannelOutputInt object to use for this
* channel.
*/
public ChannelOutputInt out()
{
return new ChannelOutputIntImpl(this,0);
}
/**
* Constructs a new BufferedOne2OneChannelIntImpl with the specified ChannelDataStoreInt.
*
* @param data the ChannelDataStoreInt used to store the data for the channel
*/
public BufferedOne2OneChannelIntImpl(ChannelDataStoreInt data)
{
if (data == null)
throw new IllegalArgumentException
("Null ChannelDataStoreInt given to channel constructor ...\n");
this.data = (ChannelDataStoreInt) data.clone();
}
/**
* Reads an int from the channel.
*
* @return the integer read from the channel.
*/
public int read () {
synchronized (rwMonitor) {
if (data.getState () == ChannelDataStoreInt.EMPTY) {
try {
rwMonitor.wait ();
while (data.getState () == ChannelDataStoreInt.EMPTY) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.One2OneChannelIntXRead);
}
rwMonitor.wait ();
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException (
"*** Thrown from One2OneChannelInt.read (int)\n" + e.toString ()
);
}
}
rwMonitor.notify ();
return data.get ();
}
}
public int startRead() {
synchronized (rwMonitor) {
if (data.getState () == ChannelDataStore.EMPTY) {
try {
rwMonitor.wait ();
while (data.getState () == ChannelDataStore.EMPTY) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.One2OneChannelXRead);
}
rwMonitor.wait ();
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException (
"*** Thrown from One2OneChannel.read (int)\n" + e.toString ()
);
}
}
return data.startGet();
}
}
public void endRead() {
synchronized(rwMonitor) {
data.endGet();
rwMonitor.notify ();
}
}
/**
* Writes an int to the channel.
*
* @param value the integer to write to the channel.
*/
public void write (int value) {
synchronized (rwMonitor) {
data.put (value);
if (alt != null) {
alt.schedule ();
} else {
rwMonitor.notify ();
}
if (data.getState () == ChannelDataStoreInt.FULL) {
try {
rwMonitor.wait ();
while (data.getState () == ChannelDataStoreInt.FULL) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.One2OneChannelIntXWrite);
}
rwMonitor.wait ();
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException (
"*** Thrown from One2OneChannelInt.write (int)\n" + e.toString ()
);
}
}
}
}
/**
* turns on Alternative selection for the channel. Returns true if the
* channel has data that can be read immediately.
*
* Note: this method should only be called by the Alternative class * * @param alt the Alternative class which will control the selection * @return true if the channel has data that can be read, else false */ public boolean readerEnable (Alternative alt) { synchronized (rwMonitor) { if (data.getState () == ChannelDataStoreInt.EMPTY) { this.alt = alt; return false; } else { return true; } } } /** * turns off Alternative selection for the channel. Returns true if the * channel contained data that can be read. *
* Note: this method should only be called by the Alternative class * * @return true if the channel has data that can be read, else false */ public boolean readerDisable () { synchronized (rwMonitor) { alt = null; return data.getState () != ChannelDataStoreInt.EMPTY; } } /** * Returns whether there is data pending on this channel. *
* Note: if there is, it won't go away until you read it. But if there * isn't, there may be some by the time you check the result of this method. *
* This method is provided for convenience. Its functionality can be provided * by Pri Alting the channel against a SKIP guard, although * at greater run-time and syntactic cost. For example, the following code * fragment: *
* if (c.pending ()) {
* int x = c.read ();
* ... do something with x
* } else (
* ... do something else
* }
*
* is equivalent to:
*
* if (c_pending.priSelect () == 0) {
* int x = c.read ();
* ... do something with x
* } else (
* ... do something else
* }
*
* where earlier would have had to have been declared:
*
* final Alternative c_pending =
* new Alternative (new Guard[] {c, new Skip ()});
*
*
* @return state of the channel.
*/
public boolean readerPending () {
synchronized (rwMonitor) {
return (data.getState () != ChannelDataStoreInt.EMPTY);
}
}
// No poison in these channels:
public void writerPoison(int strength) {
}
public void readerPoison(int strength) {
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/RejectableBufferedOne2OneChannel.java 0000644 0000000 0000000 00000007111 11105701167 023107 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.*;
/**
* This implements a one-to-one object channel with user-definable buffering, * for use by a single writer and single reader. Refer to {@link One2OneChannel} for a * description of this behaviour.
* *Additionally, this channel supports a reject operation. The reader may call
* the reject method to force any current writer to abort with a
* ChannelDataRejectedException. Subsequent read and write attempts will immediately cause a
* ChannelDataRejectedException.
Note that the reject operation cannot be called concurrently to a read.
* Only one process may be engaged in an enable sequence involving a barrier. *
* Disable sequences, triggered by a successful barrier enable, may happen * in parallel. Disable sequences, triggered by a successful barrier enable, * may not happen in parallel with an enable sequence involving a barrier. *
* Disable sequences involving a barrier, triggered by a successful non-barrier * enable, may happen in parallel with an enable sequence involving a barrier. * Should the enable sequence complete a barrier that is in a disable sequence * (which can't yet have been disabled, else it could not have been completed), * the completed barrier will be found (when it is disabled) and that disable * sequence becomes as though it had been triggered by that successful barrier * enable (rather than the non-barrier event). */ private static int active = 0; /** Lock object for coordinating enable/disable sequences. */ private static Object activeLock = new Object (); /* Invoked at start of an enable sequence involving a barrier. */ static void startEnable () { synchronized (activeLock) { if (active > 0) { try { activeLock.wait (); while (active > 0) { // This may be a spurious wakeup. More likely, this is a properly // notified wakeup that has been raced to the 'activelock' monitor // by another thread (quite possibly the notifying one) that has // (re-)acquired it and set 'active' greater than zero. We have // not instrumented the code to tell the difference. Either way: activeLock.wait (); } } catch (InterruptedException e) { throw new ProcessInterruptedException (e.toString ()); } } if (active != 0) { throw new JCSP_InternalError ( "\n*** AltingBarrier enable sequence starting " + "with 'active' count not equal to zero: " + active ); } active = 1; } } /* Invoked at finish of an unsuccessful enable sequence involving a barrier. */ static void finishEnable () { synchronized (activeLock) { if (active != 1) { throw new JCSP_InternalError ( "\n*** AltingBarrier enable sequence finished " + "with 'active' count not equal to one: " + active ); } active = 0; activeLock.notify (); } } /* * Invoked by a successful barrier enable. * * @param n The number of processes being released to start their disable sequences. */ static void startDisable (int n) { if (n <= 0) { throw new JCSP_InternalError ( "\n*** attempt to start " + n + " disable sequences!" ); } synchronized (activeLock) { // not necessary ... ? if (active != 1) { throw new JCSP_InternalError ( "\n*** completed AltingBarrier found in ALT sequence " + "with 'active' count not equal to one: " + active ); } active = n; } } /* Invoked at finish of a disable sequence selecting a barrier. */ static void finishDisable () { synchronized (activeLock) { if (active < 1) { throw new JCSP_InternalError ( "\n*** AltingBarrier disable sequence finished " + "with 'active' count less than one: " + active ); } active--; if (active == 0) { activeLock.notify (); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/PoisonableOne2AnyChannelImpl.java 0000644 0000000 0000000 00000004176 11113671251 022336 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; class PoisonableOne2AnyChannelImpl extends One2AnyImpl { PoisonableOne2AnyChannelImpl(int _immunity) { super(new PoisonableOne2OneChannelImpl(_immunity)); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/BasicOne2OneChannelSymmetric.java 0000644 0000000 0000000 00000004235 11105701167 022326 0 ustar /************************************************************************* * * * JCSP ("CSP for Java") libraries * * Copyright (C) 1996-2001 Peter Welch and Paul Austin. * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This library is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, * * USA. * * * * Author contact: P.H.Welch@kent.ac.uk * * * *************************************************************************/ package org.jcsp.lang; class BasicOne2OneChannelSymmetric implements One2OneChannelSymmetric { private final AltingBarrier[] ab = AltingBarrier.create (2); private final One2OneChannel c = Channel.one2one(); public AltingChannelInput in () { return new AltingChannelInputSymmetricImpl (ab[0], c.in()); } public AltingChannelOutput out (){ return new AltingChannelOutputSymmetricImpl (ab[1], c.out()); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/AltingChannelOutputIntSymmetricImpl.java 0000644 0000000 0000000 00000005047 11105701167 024055 0 ustar /************************************************************************* * * * JCSP ("CSP for Java") libraries * * Copyright (C) 1996-2001 Peter Welch and Paul Austin. * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This library is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, * * USA. * * * * Author contact: P.H.Welch@kent.ac.uk * * * *************************************************************************/ package org.jcsp.lang; class AltingChannelOutputIntSymmetricImpl extends AltingChannelOutputInt implements MultiwaySynchronisation { private final AltingBarrier ab; private final ChannelOutputInt out; private boolean syncDone = false; public AltingChannelOutputIntSymmetricImpl ( AltingBarrier ab, ChannelOutputInt out) { this.ab = ab; this.out = out; } boolean enable (Alternative alt) { syncDone = ab.enable (alt); return syncDone; } boolean disable () { syncDone = ab.disable (); return syncDone; } public void write (int i) { if (!syncDone) ab.sync (); syncDone = false; out.write (i); } public boolean pending () { syncDone = ab.poll (10); return syncDone; } public void poison(int strength) { out.poison(strength); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/Any2OneChannelInt.java 0000644 0000000 0000000 00000013317 11113671251 020150 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * This defines an interface for an any-to-one integer channel, * safe for use by many writers and one reader. *
* The only methods provided are to obtain the ends of the channel, * through which all reading and writing operations are done. * Only an appropriate channel-end should be plugged into a process * – not the whole channel. * A process may use its external channels in one direction only * – either for writing or reading. *
*Actual channels conforming to this interface are made using the relevant * static construction methods from {@link Channel}. * Channels may be {@link Channel#any2oneInt() synchronising}, * {@link Channel#any2oneInt(org.jcsp.util.ints.ChannelDataStoreInt) buffered}, * {@link Channel#any2oneInt(int) poisonable} * or {@link Channel#any2oneInt(org.jcsp.util.ints.ChannelDataStoreInt,int) both} * (i.e. buffered and poisonable). *
*Description
* Any2OneChannelInt is an interface for an integer channel which * is safe for use by many writing processes but only one reader. * Writing processes compete with each other to use the channel. * Only the reader and one writer will * actually be using the channel at any one time. This is managed by the * channel – user processes just read from or write to it. * ** Please note that this is a safely shared channel and not a message gatherer. * Currently, gathering has to be managed by writing an active process. *
* The reading process may {@link Alternative ALT} on this channel. * The writing process is committed (i.e. it may not back off). *
** The default semantics of the channel is that of CSP – i.e. it is * zero-buffered and fully synchronised. The reading process must wait * for a matching writer and vice-versa. *
** The static methods of {@link Channel} construct channels with * either the default semantics or with buffering to user-specified capacity * and a range of blocking/overwriting policies. * Various buffering plugins are given in the org.jcsp.util package, but * careful users may write their own. *
** The {@link Channel} methods also provide for the construction of * {@link Poisonable} channels and for arrays of channels. * *
Implementation Note and Caution
* Fair servicing of writers to this channel depends on the fair * servicing of requests to enter a synchronized block (or method) by * the underlying Java Virtual Machine (JVM). Java does not specify how threads * waiting to synchronize should be handled. Currently, Sun's standard JDKs queue * these requests - which is fair. However, there is at least one JVM * that puts such competing requests on a stack - which is legal but unfair * and can lead to infinite starvation. This is a problem for any Java system * relying on good behaviour from synchronized, not just for these * any-1 channels. * * @see org.jcsp.lang.Channel * @see org.jcsp.lang.Alternative * @see org.jcsp.lang.One2OneChannelInt * @see org.jcsp.lang.One2AnyChannelInt * @see org.jcsp.lang.Any2AnyChannelInt * @see org.jcsp.util.ints.ChannelDataStoreInt * * @author P.D. Austin and P.H. Welch */ public interface Any2OneChannelInt { /** * Returns the input end of the channel. */ public AltingChannelInputInt in(); /** * Returns the output end of the channel. */ public SharedChannelOutputInt out(); } jcsp-1.1-rc4.orig/src/org/jcsp/lang/BufferedChannelIntFactory.java 0000644 0000000 0000000 00000007006 11105701167 021746 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; import org.jcsp.util.ints.*; /** * Defines an interface for a factory that can create integer carrying channels with * user-definable buffering semantics. * * @author Quickstone Technologies Limited * * @deprecated These channel factories are deprecated in favour of the new one2one() methods in the Channel class. */ public interface BufferedChannelIntFactory { /** * Creates a newOne2One channel with the given buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @return the created channel.
*/
public One2OneChannelInt createOne2One(ChannelDataStoreInt buffer);
/**
* Creates a new Any2One channel with the given buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @return the created channel.
*/
public Any2OneChannelInt createAny2One(ChannelDataStoreInt buffer);
/**
* Creates a new One2Any channel with the given buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @return the created channel.
*/
public One2AnyChannelInt createOne2Any(ChannelDataStoreInt buffer);
/**
* Creates a new Any2Any channel with the given buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @return the created channel.
*/
public Any2AnyChannelInt createAny2Any(ChannelDataStoreInt buffer);
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Any2OneConnection.java 0000644 0000000 0000000 00000005666 11105701167 020235 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
*
* Defines an interface for a connection that can be shared
* by multiple concurrent clients but used by
* a single server. The server end of the connection can be
* used as a guard in an Alternative.
*
SharedAltingConnectionClient object.
*/
public SharedAltingConnectionClient client();
/**
* Returns the server end of the connection.
*
* @return the instance of the AltingConnectionServer.
*/
public AltingConnectionServer server();
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelInputImpl.java 0000644 0000000 0000000 00000004747 11113671251 020152 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
class ChannelInputImpl implements ChannelInput {
private ChannelInternals channel;
private int immunity;
ChannelInputImpl(ChannelInternals _channel, int _immunity) {
channel = _channel;
immunity = _immunity;
}
public void endRead() {
channel.endRead();
}
public Object read() {
return channel.read();
}
public Object startRead() {
return channel.startRead();
}
public void poison(int strength) {
if (strength > immunity) {
channel.readerPoison(strength);
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Any2AnyChannel.java 0000644 0000000 0000000 00000013556 11113671251 017510 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This defines the interface for an any-to-any Object channel,
* safe for use by many writers and many readers.
* * The only methods provided are to obtain the ends of the channel, * through which all reading and writing operations are done. * Only an appropriate channel-end should be plugged into a process * – not the whole channel. * A process may use its external channels in one direction only * – either for writing or reading. *
*Actual channels conforming to this interface are made using the relevant * static construction methods from {@link Channel}. * Channels may be {@link Channel#any2any() synchronising}, * {@link Channel#any2any(org.jcsp.util.ChannelDataStore) buffered}, * {@link Channel#any2any(int) poisonable} * or {@link Channel#any2any(org.jcsp.util.ChannelDataStore,int) both} * (i.e. buffered and poisonable). *
*Description
* Any2AnyChannel is an interface for a channel which * is safe for use by many reading and writing processes. Reading processes * compete with each other to use the channel. Writing processes compete * with each other to use the channel. Only one reader and one writer will * actually be using the channel at any one time. This is managed by the * channel – user processes just read from or write to it. * ** Please note that this is a safely shared channel and not * a broadcaster or message gatherer. Currently, broadcasting or gathering has to be managed by * writing active processes (see {@link org.jcsp.plugNplay.DynamicDelta} * for an example of broadcasting). *
** All reading processes and writing processes commit to the channel * (i.e. may not back off). This means that the reading processes * may not {@link Alternative ALT} on this channel. *
** The default semantics of the channel is that of CSP – i.e. it is * zero-buffered and fully synchronised. A reading process must wait * for a matching writer and vice-versa. *
** The static methods of {@link Channel} construct channels with * either the default semantics or with buffering to user-specified capacity * and a range of blocking/overwriting policies. * Various buffering plugins are given in the org.jcsp.util package, but * careful users may write their own. *
** The {@link Channel} methods also provide for the construction of * {@link Poisonable} channels and for arrays of channels. * *
Implementation Note and Caution
* Fair servicing of readers and writers to this channel depends on the fair * servicing of requests to enter a synchronized block (or method) by * the underlying Java Virtual Machine (JVM). Java does not specify how threads * waiting to synchronize should be handled. Currently, Sun's standard JDKs queue * these requests - which is fair. However, there is at least one JVM * that puts such competing requests on a stack - which is legal but unfair * and can lead to infinite starvation. This is a problem for any Java system * relying on good behaviour from synchronized, not just for these * any-any channels. * * @see org.jcsp.lang.Channel * @see org.jcsp.lang.One2OneChannel * @see org.jcsp.lang.Any2OneChannel * @see org.jcsp.lang.One2AnyChannel * @see org.jcsp.util.ChannelDataStore * * @author P.D. Austin and P.H. Welch */ public interface Any2AnyChannel { /** * Returns the input end of the channel. */ public SharedChannelInput in(); /** * Returns the output end of the channel. */ public SharedChannelOutput out(); } jcsp-1.1-rc4.orig/src/org/jcsp/lang/ConnectionFactory.java 0000644 0000000 0000000 00000006220 11105701167 020354 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** ** Defines an interface for a factory than can create connections. *
* * @author Quickstone Technologies Limited */ public interface ConnectionFactory { /** * Constructs and returns an implementation of *One2OneConnection.
*
* @return the constructed One2OneConnection object.
*/
public One2OneConnection createOne2One();
/**
* Constructs and returns an implementation of
* Any2OneConnection.
*
* @return the constructed Any2OneConnection object.
*/
public Any2OneConnection createAny2One();
/**
* Constructs and returns an implementation of
* One2AnyConnection.
*
* @return the constructed One2AnyConnection object.
*/
public One2AnyConnection createOne2Any();
/**
* Constructs and returns an implementation of
* Any2AnyConnection.
*
* @return the constructed Any2AnyConnection object.
*/
public Any2AnyConnection createAny2Any();
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelInput.java 0000644 0000000 0000000 00000017045 11113671251 017323 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This defines the interface for reading from an Object channel.
* * A reading-end, conforming to this interface, * is obtained from a channel by invoking its in() method. *
Description
* ChannelInput defines the interface for reading from object channels. * The interface contains three methods: * {@link #readread}, {@link #startRead startRead} and
* {@link #endRead endRead}.
* The {@link #read read} and {@link #startRead startRead}
* methods block until an Object has been written
* to the channel by a process at the other end. If an Object has
* already been written when this method is called, the method will return
* without blocking. Either way, the methods return the Object
* sent down the channel.
*
* When a {@link #read read} completes, the matching
* {@link ChannelOutput#write write} method (invoked by
* the writing process) also completes.
* When a {@link #startRead startRead} completes, the matching
* {@link ChannelOutput#write write} method does not complete
* until the reader process invokes an {@link #endRead endRead}.
* Actions performed by the reader in between a {@link #startRead startRead}
* and {@link #endRead endRead} make up an extended rendezvous.
*
*
* ChannelInput variables are used to hold channels * that are going to be used only for input by the declaring process. * This is a security matter -- by declaring a ChannelInput * interface, any attempt to output to the channel will generate * a compile-time error. For example, the following code fragment will * not compile: * *
* void doWrite (ChannelInput c, Object o) {
* c.write (o); // illegal
* }
*
*
* When configuring a CSProcess with input channels, they should
* be declared as ChannelInput (or, if we wish to be able to make
* choices between events, as AltingChannelInput)
* variables. The actual channel passed,
* of course, may belong to any channel class that implements
* ChannelInput (or AltingChannelInput).
* * The Object returned can be cast into the actual * class the reader process expects. If the reader can handle more than one * class of Object (similar to tagged protocols * in occam), checks should be made before casting. *
Examples
*Discard data
*
* void doRead (ChannelInput c) {
* c.read (); // clear the channel
* }
*
* Cast data to expected type
*
* void doRead (ChannelInput c) {
* Boolean b = (Boolean) c.read(); // will cause a ClassCastException
* // if read does not return a Boolean
* ... etc.
* }
*
* Cast data after checking type
*
* void doRead (ChannelInput c) {
* Object o = c.read ();
* if (o instanceof Boolean) {
* System.out.println ("Boolean: " + (Boolean) o);
* }
* else if (o instanceof Integer) {
* System.out.println ("Integer: " + (Integer) o);
* }
* else {
* System.out.println ("Unexpected Class: " + o);
* }
* }
*
*
* @see org.jcsp.lang.AltingChannelInput
* @see org.jcsp.lang.SharedChannelInput
* @see org.jcsp.lang.ChannelOutput
* @author P.D. Austin and P.H. Welch and N.C.C.Brown
*/
public interface ChannelInput extends Poisonable
{
/**
* Read an Object from the channel.
*
* @return the object read from the channel
*/
public Object read();
/**
* Begin an extended rendezvous read from the channel.
* An extended rendezvous is not completed until the reader
* has completed its extended action. This method starts
* an extended rendezvous. When a writer to this channel
* writes, this method returns what was sent immediately.
* The extended rendezvous continues with reader actions
* until the reader invokes {@link #endRead endRead}.
* Only then will the writer be released (from its
* {@link ChannelOutput#write write} method).
* The writer is unaware of the extended nature of the communication.
*
*
* The reader process must call {@link #endRead endRead}
* at some point after this function, otherwise the writer will not
* be freed and deadlock will probably follow.
*
* The reader process may perform any actions between calling
* {@link #startRead startRead} and
* {@link #endRead endRead}, including communications
* on other channels. Further communications on this channel, of course,
* should not be made.
*
* An extended rendezvous may be started after the channel's Guard
* has been selected by an {@link Alternative} (i.e.
* {@link #startRead startRead} instead of
* {@link #read read}).
*
* @return The object read from the channel
*/
public Object startRead();
/**
* End an extended rendezvous.
* It must be invoked once (and only once) following
* a {@link #startRead startRead}.
*/
public void endRead();
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelIntArrayFactory.java 0000644 0000000 0000000 00000006516 11105701167 021307 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* Defines an interface for a factory that can create arrays of channels carrying integers.
*
* @author Quickstone Technologies Limited
*
* @deprecated These channel factories are deprecated in favour of the new one2one() methods in the Channel class.
*/
public interface ChannelIntArrayFactory
{
/**
* Creates a populated array of n One2One channels.
*
* @param n the size of the array.
* @return the created array of channels.
*/
public One2OneChannelInt[] createOne2One(int n);
/**
* Creates a populated array of n Any2One channels.
*
* @param n the size of the array.
* @return the created array of channels.
*/
public Any2OneChannelInt[] createAny2One(int n);
/**
* Creates a populated array of n One2Any channels.
*
* @param n the size of the array.
* @return the created array of channels.
*/
public One2AnyChannelInt[] createOne2Any(int n);
/**
* Creates a populated array of n Any2Any channels.
*
* @param n the size of the array.
* @return the created array of channels.
*/
public Any2AnyChannelInt[] createAny2Any(int n);
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelInputInt.java 0000644 0000000 0000000 00000015247 11113671251 020000 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This defines the interface for reading from object channels.
*
* A reading-end, conforming to this interface, * is obtained from a channel by invoking its in() method. *
Description
* ChannelInput defines the interface for reading from object channels. * The interface contains three methods: * {@link #readread}, {@link #startRead startRead} and
* {@link #endRead endRead}.
* The {@link #read read} and {@link #startRead startRead}
* methods block until an Object has been written
* to the channel by a process at the other end. If an Object has
* already been written when this method is called, the method will return
* without blocking. Either way, the methods return the Object
* sent down the channel.
*
* When a {@link #read read} completes, the matching
* {@link ChannelOutputInt#write write} method (invoked by
* the writing process) also completes.
* When a {@link #startRead startRead} completes, the matching
* {@link ChannelOutputInt#write write} method does not complete
* until the reader process invokes an {@link #endRead endRead}.
* Actions performed by the reader in between a {@link #startRead startRead}
* and {@link #endRead endRead} make up an extended rendezvous.
*
*
* ChannelInputInt variables are used to hold integer channels * that are going to be used only for input by the declaring process. * This is a security matter -- by declaring a ChannelInputInt * interface, any attempt to output to the channel will generate * a compile-time error. For example, the following code fragment will * not compile: * *
* void doWrite (ChannelInputInt c, int i) {
* c.write (i); // illegal
* }
*
*
* When configuring a CSProcess with input integer channels, they should
* be declared as ChannelInputInt (or, if we wish to be able to make
* choices between events, as AltingChannelInputInt)
* variables. The actual channel passed,
* of course, may belong to any channel class that implements
* ChannelInputInt (or AltingChannelInputInt).
* Example
*Discard data
*
* void doRead (ChannelInputInt c) {
* c.read (); // clear the channel
* }
*
*
* @see org.jcsp.lang.AltingChannelInputInt
* @see org.jcsp.lang.SharedChannelInputInt
* @see org.jcsp.lang.ChannelOutputInt
* @author P.D. Austin and P.H. Welch and N.C.C.Brown
*/
public interface ChannelInputInt extends Poisonable
{
/**
* Read an int from the channel.
*
* @return the integer read from the channel
*/
public int read();
/**
* Begin an extended rendezvous read from the channel.
* An extended rendezvous is not completed until the reader
* has completed its extended action. This method starts
* an extended rendezvous. When a writer to this channel
* writes, this method returns what was sent immediately.
* The extended rendezvous continues with reader actions
* until the reader invokes {@link #endRead endRead}.
* Only then will the writer be released (from its
* {@link ChannelOutputInt#write write} method).
* The writer is unaware of the extended nature of the communication.
*
*
* The reader process must call {@link #endRead endRead}
* at some point after this function, otherwise the writer will not
* be freed and deadlock will probably follow.
*
* The reader process may perform any actions between calling
* {@link #startRead startRead} and
* {@link #endRead endRead}, including communications
* on other channels. Further communications on this channel, of course,
* should not be made.
*
* An extended rendezvous may be started after the channel's Guard
* has been selected by an {@link Alternative} (i.e.
* {@link #startRead startRead} instead of
* {@link #read read}).
*
* @return The object read from the channel
*/
public int startRead();
/**
* End an extended rendezvous.
* It must be invoked once (and only once) following
* a {@link #startRead startRead}.
*/
public void endRead();
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/One2OneChannelSymmetricInt.java 0000644 0000000 0000000 00000007665 11113671251 022050 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This defines the interface for a symmetric one-to-one integer channel.
* The symmetry relates to the use of its channel ends as {@link Guard guards}
* in an {@link Alternative}: both ends may be so used.
*
* The only methods provided are to obtain the ends of the channel, * through which all reading and writing operations are done. * Only an appropriate channel-end should be plugged into a process * – not the whole channel. * A process may use its external channels in one direction only * – either for writing or reading. *
*Actual channels conforming to this interface are made using the relevant * static construction methods from {@link Channel}. * Only fully {@link Channel#one2oneSymmetricInt() synchronising} channels are currently supported. *
Description
* One2OneChannelImpl is an interface for a symmetric one-to-one object channel. * Multiple readers or multiple writers are not allowed. ** Both the reading and writing processes may {@link Alternative ALT} on this channel. *
** The semantics of the channel is that of CSP – i.e. it is * zero-buffered and fully synchronised. The reading process must wait * for a matching writer and vice-versa. *
*
* These channels may be constructed by the {@link Channel#one2oneSymmetricInt()}. * Channel poisoning and buffering are not currently supported for these channels. * * * @see org.jcsp.lang.Alternative * @see org.jcsp.lang.One2OneChannel * * @author P.H. Welch * @author N.C.C. Brown */ public interface One2OneChannelSymmetricInt { /** * Returns the input channel end. */ public AltingChannelInputInt in (); /** * Returns the output channel end. */ public AltingChannelOutputInt out (); } jcsp-1.1-rc4.orig/src/org/jcsp/lang/One2AnyChannelIntImpl.java 0000644 0000000 0000000 00000011263 11105701167 020771 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * This implements a one-to-any integer channel, * safe for use by one writer and many readers. *Description
* One2AnyChannelIntImpl is an implementation of a channel which is safe * for use by many reading processes but only one writer. Reading processes * compete with each other to use the channel. Only one reader and the writer will * actually be using the channel at any one time. This is taken care of by * One2AnyChannelIntImpl -- user processes just read from or write to it. ** Please note that this is a safely shared channel and not * a broadcaster. Currently, broadcasting has to be managed by * writing active processes (see {@link org.jcsp.plugNplay.DynamicDelta} * for an example). *
* All reading processes and the writing process commit to the channel * (i.e. may not back off). This means that the reading processes * may not {@link Alternative ALT} on this channel. *
* The default semantics of the channel is that of CSP -- i.e. it is * zero-buffered and fully synchronised. A reading process must wait * for the matching writer and vice-versa. *
* A factory pattern is used to create channel instances. The create methods of {@link Channel} * allow creation of channels, arrays of channels and channels with varying semantics such as * buffering with a user-defined capacity or overwriting with various policies. * Standard examples are given in the org.jcsp.util package, but * careful users may write their own. * *
Implementation Note and Caution
* Fair servicing of readers to this channel depends on the fair * servicing of requests to enter a synchronized block (or method) by * the underlying Java Virtual Machine (JVM). Java does not specify how threads * waiting to synchronize should be handled. Currently, Sun's standard JDKs queue * these requests - which is fair. However, there is at least one JVM * that puts such competing requests on a stack - which is legal but unfair * and can lead to infinite starvation. This is a problem for any Java system * relying on good behaviour from synchronized, not just for these * 1-any channels. * * @see org.jcsp.lang.One2OneChannelIntImpl * @see org.jcsp.lang.Any2OneChannelIntImpl * @see org.jcsp.lang.Any2AnyChannelIntImpl * @see org.jcsp.util.ints.ChannelDataStoreInt * * @author P.D. Austin and P.H. Welch */ class One2AnyChannelIntImpl extends One2AnyIntImpl { One2AnyChannelIntImpl() { super(new One2OneChannelIntImpl()); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/AltingChannelInputIntImpl.java 0000644 0000000 0000000 00000005325 11113671251 021755 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; class AltingChannelInputIntImpl extends AltingChannelInputInt { private ChannelInternalsInt channel; private int immunity; AltingChannelInputIntImpl(ChannelInternalsInt _channel, int _immunity) { channel = _channel; immunity = _immunity; } public boolean pending() { return channel.readerPending(); } boolean disable() { return channel.readerDisable(); } boolean enable(Alternative alt) { return channel.readerEnable(alt); } public void endRead() { channel.endRead(); } public int read() { return channel.read(); } public int startRead() { return channel.startRead(); } public void poison(int strength) { if (strength > immunity) { channel.readerPoison(strength); } } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/PoisonableBufferedAny2OneChannelInt.java 0000644 0000000 0000000 00000004351 11113671251 023625 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; import org.jcsp.util.ints.ChannelDataStoreInt; class PoisonableBufferedAny2OneChannelInt extends Any2OneIntImpl { PoisonableBufferedAny2OneChannelInt(ChannelDataStoreInt _data, int _immunity) { super(new PoisonableBufferedOne2OneChannelInt(_data,_immunity)); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/One2OneChannelInt.java 0000644 0000000 0000000 00000011210 11113671251 020130 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * This defines the interface for a one-to-one integer channel. ** The only methods provided are to obtain the ends of the channel, * through which all reading and writing operations are done. * Only an appropriate channel-end should be plugged into a process * – not the whole channel. * A process may use its external channels in one direction only * – either for writing or reading. *
*Actual channels conforming to this interface are made using the relevant * static construction methods from {@link Channel}. * Channels may be {@link Channel#one2oneInt() synchronising}, * {@link Channel#one2oneInt(org.jcsp.util.ints.ChannelDataStoreInt) buffered}, * {@link Channel#one2oneInt(int) poisonable} * or {@link Channel#one2oneInt(org.jcsp.util.ints.ChannelDataStoreInt,int) both} * (i.e. buffered and poisonable). *
*Description
* One2OneChannelInt is an interface for a one-to-one integer channel. Multiple * readers or multiple writers are not allowed – these are catered for * by {@link Any2OneChannelInt}, * {@link One2AnyChannelInt} or * {@link Any2AnyChannelInt}. ** The reading process may {@link Alternative ALT} on this channel. * The writing process is committed (i.e. it may not back off). *
** The default semantics of the channel is that of CSP – i.e. it is * zero-buffered and fully synchronised. The reading process must wait * for a matching writer and vice-versa. *
** The static methods of {@link Channel} construct channels with * either the default semantics or with buffering to user-specified capacity * and a range of blocking/overwriting policies. * Various buffering plugins are given in the org.jcsp.util package, but * careful users may write their own. *
*
* The {@link Channel} methods also provide for the construction of
* {@link Poisonable} channels and for arrays of channels.
*
* @see org.jcsp.lang.Channel
* @see org.jcsp.lang.Alternative
* @see org.jcsp.lang.Any2OneChannelInt
* @see org.jcsp.lang.One2AnyChannelInt
* @see org.jcsp.lang.Any2AnyChannelInt
* @see org.jcsp.util.ints.ChannelDataStoreInt
*
* @author P.D. Austin
* @author P.H. Welch
*/
public interface One2OneChannelInt
{
/**
* Returns the input end of the channel.
*/
public AltingChannelInputInt in();
/**
* Returns the output end of the channel.
*/
public ChannelOutputInt out();
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/doc-files/ 0000755 0000000 0000000 00000000000 11410045045 015722 5 ustar jcsp-1.1-rc4.orig/src/org/jcsp/lang/doc-files/Any2OneCallChannel3.gif 0000644 0000000 0000000 00000012117 10520670125 022042 0 ustar GIF89a¤Ô ÷ $$$(((,,,000444888<<<@@@HHHLLLPPPUUUYYY]]]aaaeeeiiimmmqqquuuyyy}}}………•••¡¡¡¥¥¥®®®²²²¶¶¶¾¾¾ÆÆÆÎÎÎÖÖÖÚÚÚÞÞÞæææîîîòòòöööÿÿÿ , ¤Ô ÿ c H° Áƒ*\È°¡Ã‡#JœH±¢Å‹3jÜȱ£Ç CŠ I²¤É“(Sª\ɲ¥Ë—0cÊœI³¦Í›8sêÜɳ§ÏŸ@ƒ
J´¨Ñ£H“"mñ¡ƒÓ§P£JJµêT.”jÝʵ§ ¬Š KV*†*ºª]Ë–åƒ6?hhK·®]Ž nžxp·¯ß¿ óÚÜ ¸°á¿‚k≯±ÚÄ4;žL¹(ä™’+kÞ¼ó²ÌÌœC‹Žé9&èÑG Àºµë×°cËž-»A
‰., Í»·oØ8L<‘à·ñã²À%YæiÔ[ `Q…‰ 4À 邈ˆ0Üÿ¦™âÀö‘Í_>‡.Ѓp›
PDL¶¦ GP¸ù–¹^¾ì äË=4Ý` >‚ú‡`€vÐ D*– C N(Rz¥0^ +¬àЇÇÞ€6õG!uF”aŠ†Ä!A" € Üæ€
¥ ‰ ™ Š5©h ‹‘]ØЋEÆÒŒ €-œ€ ;öø#DB¢F$MF:Ta’.2£ƒ m€À@)ˆ˜e ظ@j^Ù‚)Ô(BC]ŽöåLa64&fJ2Ä$˜N~e ¬YP–qžP H B làã ÌÉg¡þ)S
ú¨
h¢ -Úè@/ÿ”%¥²:à£ùhc %¢z¢„g®ø DªŽÊjG‹‚ Àr`É#žîx«@%¬àc³ô
¡A¢ÆDêB¦šæ+BÅz{,^Ùè2Ê£ˆà "¬0eàY²Ÿn[P·0}«P¸Î{P¹Ÿ»Ñ¢1´ ¯Y`æ;~C ;2¸‚"Jܯ¿ü’À ¬žÁ!<²Â1œRŸ¢‰<ÐWB
* The only methods provided are to obtain the ends of the channel,
* through which all reading and writing operations are done.
* Only an appropriate channel-end should be plugged into a process
* – not the whole channel.
* A process may use its external channels in one direction only
* – either for writing or reading.
* Actual channels conforming to this interface are made using the relevant
* static construction methods from {@link Channel}.
* Channels may be {@link Channel#one2any() synchronising},
* {@link Channel#one2any(org.jcsp.util.ChannelDataStore) buffered},
* {@link Channel#one2any(int) poisonable}
* or {@link Channel#one2any(org.jcsp.util.ChannelDataStore,int) both}
* (i.e. buffered and poisonable).
* Description
* One2AnyChannel is an interface for a channel which is safe
* for use by many reading processes but only one writer. Reading processes
* compete with each other to use the channel. Only one reader and the writer will
* actually be using the channel at any one time. This is managed by the
* channel – user processes just read from or write to it.
*
* Please note that this is a safely shared channel and not * a broadcaster. Currently, broadcasting has to be managed by * writing an active process (see {@link org.jcsp.plugNplay.DynamicDelta} * for an example). *
** All reading processes and the writing process commit to the channel * (i.e. may not back off). This means that the reading processes * may not {@link Alternative ALT} on this channel. *
* The default semantics of the channel is that of CSP – i.e. it is * zero-buffered and fully synchronised. A reading process must wait * for the matching writer and vice-versa. *
** The static methods of {@link Channel} construct channels with * either the default semantics or with buffering to user-specified capacity * and a range of blocking/overwriting policies. * Various buffering plugins are given in the org.jcsp.util package, but * careful users may write their own. *
** The {@link Channel} methods also provide for the construction of * {@link Poisonable} channels and for arrays of channels. * *
Implementation Note and Caution
* Fair servicing of readers to this channel depends on the fair * servicing of requests to enter a synchronized block (or method) by * the underlying Java Virtual Machine (JVM). Java does not specify how threads * waiting to synchronize should be handled. Currently, Sun's standard JDKs queue * these requests - which is fair. However, there is at least one JVM * that puts such competing requests on a stack - which is legal but unfair * and can lead to infinite starvation. This is a problem for any Java system * relying on good behaviour from synchronized, not just for these * 1-any channels. * * @see org.jcsp.lang.Channel * @see org.jcsp.lang.One2OneChannel * @see org.jcsp.lang.Any2OneChannel * @see org.jcsp.lang.Any2AnyChannel * @see org.jcsp.util.ChannelDataStore * * @author P.D. Austin and P.H. Welch */ public interface One2AnyChannel { /** * Returns the input end of the channel. */ public SharedChannelInput in(); /** * Returns the output end of the channel. */ public ChannelOutput out(); } jcsp-1.1-rc4.orig/src/org/jcsp/lang/PoisonableAny2AnyChannelIntImpl.java 0000644 0000000 0000000 00000004212 11113671251 023006 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; class PoisonableAny2AnyChannelIntImpl extends Any2AnyIntImpl { PoisonableAny2AnyChannelIntImpl(int _immunity) { super(new PoisonableOne2OneChannelIntImpl(_immunity)); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/SharedChannelInput.java 0000644 0000000 0000000 00000004725 11113671251 020453 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * This is the same as {@link ChannelInput} except that it is guaranteed * safe to pass on to more than one internal process for parallel reading. ** A reading-end, obtained from a one-any or any-any * channel by invoking its in() method, will implement this interface. * * @author Quickstone Technologies Limited */ public interface SharedChannelInput extends ChannelInput { } jcsp-1.1-rc4.orig/src/org/jcsp/lang/SharedChannelInputIntImpl.java 0000644 0000000 0000000 00000005002 11113671251 021735 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; class SharedChannelInputIntImpl implements SharedChannelInputInt { private ChannelInternalsInt channel; private int immunity; SharedChannelInputIntImpl(ChannelInternalsInt _channel, int _immunity) { channel = _channel; immunity = _immunity; } public void endRead() { channel.endRead(); } public int read() { return channel.read(); } public int startRead() { return channel.startRead(); } public void poison(int strength) { if (strength > immunity) { channel.readerPoison(strength); } } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/Crew.java 0000644 0000000 0000000 00000056452 11105701167 015641 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * This provides a Concurrent Read Exclusive Write (CREW) lock for synchronising * fair and secure access to a shared resource. *
* Shortcut to the Constructor and Method Summaries. * *
Description
*Concurrent Read Exclusive Write
* Parallel processes must ensure controlled access to shared resources whose state can * change as a side-effect of that access. Otherwise, there will be race hazards * resulting from arbitrary interleaving of that access between competing processes. * For example, a reader of a resource may observe partially updated (and, hence, * invalid) state because of the activities of a concurrent writer. * Or two writers may interfere with each other's updating to leave a resource * in an invalid state (as well as confusing themselves). * ** Where possible, each resource should be kept wrapped up in a process and accessed via * a channel interface - this will always be safe. However, this also serialises * access to the resource so that it can be used by only one process at a time, * regardless of whether that usage is read-only or read-write. This is an example of * Exclusive Read Exclusive Write (EREW). *
* [Note: the above assumes the resource process has only a serial implementation. * A parallel implementation, of course, will allow parallel access along parallel channels. * However, if that parallel implementation needs to share state, that shared state is * itself a resource and we have only deferred the problem of secure parallel access.] *
* Parallel reader operations on a resource do not lead to race hazards, so long as * no writer is present, and many applications need to be able to exploit this. * Parallel writer operations are always dangerous and must be suppressed. * This principle is known as Concurrent Read Exclusive Write (CREW). * *
Design Pattern
* Suppose many processes hold a reference to a shared object. Associate that shared object * with a shared Crew lock, reference to which must also be given to each of those * processes. ** For example, suppose Resource is a class whose methods may be * classified as either readers (i.e. cause no state change) or writers * (i.e. cause state change). Whenever we construct a Resource, construct * an associated Crew lock: *
* Resource resource = new Resource (...); * Crew resourceCrew = new Crew (); ** * Each process holding a reference to resource must also be given a reference * to resourceCrew. Invocations of reader methods must be sandwiched * between a claim and release of the reader lock within resourceCrew: *
* resourceCrew.startRead(); // this will block until no writer is present * ... // invoke reader methods of resource * resourceCrew.endRead(); // releases this reader's lock on resource ** Invocations of writer methods must be sandwiched * between a claim and release of the writer lock within resourceCrew: *
* resourceCrew.startWrite(); // this will block until no reader * // or writer is present * ... // invoke writer (or reader) methods * // of resource * resourceCrew.endWrite(); // releases this writer's lock on resource ** This pattern enables fair and secure access to a shared resource according to CREW rules. * Concurrent readers will be allowed, so long as no writer is present. A single writer * will be allowed, so long as no readers nor other writers are present. So long as each * read or write operation is finite, readers will not be blocked indefinitely by writers * and vice-versa (but see the Cautionary Note). * *
Access Sequences for the Worried
* Java is a language that allows the throwing and catching of exceptions (and a return * from a method invocation anywhere). * This means that the normal sequential flow of control is not necessarilly what happens: * what-you-see-is-NOT-what-you-get, a worrying property. * If an uncaught exception is thrown (or a return executed) from * the resource-using part of either of the above access sequences, * the corresponding Crew lock would not be released. * To protect ourselves from this, embed the access sequence within * a try-finally clause - for example: *
* try {
* resourceCrew.startRead(); // this will block until no writer is present
* ... // invoke reader methods of resource
* } finally {
* resourceCrew.endRead(); // releases this reader's lock on resource
* }
*
* and:
*
* try {
* resourceCrew.startWrite(); // this will block until no reader
* // or writer is present
* ... // invoke writer (or reader)
* // methods of resource
* } finally {
* resourceCrew.endWrite (); // releases this writer's lock on resource
* }
*
* Now, the lock will always be released whether the reader/writer section exits normally
* or exceptionally. This asymmetric pattern is not very pretty, but is a classic
* application of the try-finally facility.
*
* Binding the Shared Resource to its CREW Lock
* In JCSP, shared references may be passed to processes through constructors, through * mutator (set...) methods (but only, of course, before and in between runs) * or through channels (when running). ** If a resource and its lock are held in separate objects (as above), passing them * both to the processes that share them is a little tedious and error prone. * It is better to combine them into a single object. *
* One way is to define the Resource class to extend Crew. * Then, we only need to distribute the Resource object and its access is * protected by inherited methods - for example: *
* resource.startRead (); // this will block until no writer is present * ... // invoke reader methods of resource * resource.endRead (); // releases this reader's lock on resource ** However, this may not be possible (since our design may require Resource * to extend something else). *
* Alternatively, we could declare (or extend) Resource to contain * an additional Crew attribute. Again, we need only distribute * the Resource object. The sharing processes recover the associated lock: *
* Crew resourceCrew = resource.getCrew (); ** and can use the original access sequences. *
* However, this Crew class offers the option of doing this the other way around, * so that no modifications are needed on the application Resource. Pass the * Resource object to the Crew {@link #Crew(java.lang.Object) constructor} * and a reference will be saved as an attribute of the Crew object. For example: *
* Crew resourceCrew = new Crew (new Resource (...)); ** Processes to which this resourceCrew object are distributed can recover * the original resource by invoking {@link #getShared getShared} - for example: *
* Resource resource = (Resource) resourceCrew.getShared (); ** and can again use the original access sequences. * *
CREW-synchronised Methods
* The safest way to ensure adherence to the design pattern * is to burn the correct access sequence into each reader and writer method. * For example, extend Resource to contain a private * Crew field and override each method to sandwich its invocation * between the appropriate synchronisations: *
* class ResourceCrew extends Resource {
*
* private final Crew crew = new Crew ();
*
* public Thing readerMethod (...) {
* crew.startRead (); // this will block until no writer is present
* Thing result = super.readerMethod (...);
* crew.endRead (); // releases this reader's lock on resource
* return result;
* }
*
* public void writerMethod (...) {
* crew.startWrite (); // this will block until no reader
* // or writer is present
* super.writerMethod (...);
* crew.endWrite (); // releases this writer's lock on resource
* }
*
* ... etc. for all other methods.
*
* }
*
* Now, parallel processes can safely share references to an instance of
* ResourceCrew. Invocations of its reader and writer
* methods will be automatically CREW-synchronised.
* * Notes: *
-
*
- * this is similar to declaring all class methods to be synchronized * (which guarantees EREW-synchronisation for parallel access to its instances); *
- * it may have been better to have designed Resource like this * in the first place (rather than extending it as in the above); *
- * the above access sequences may need to be of the defensive * variety; *
- * a disadvantage of this approach is that we do not have the capability of grouping * a sequence of reader or reader/writer methods within a single * CREW-synchronisation envelope. *
Alternatives to CREW for Shared Objects
* The proliferation of references in object-oriented design is a common source of error, * even for single-threaded systems. For concurrent object-oriented design, we must be * especially careful if we are to avoid the perils of race hazard. ** Protocols other than CREW may be applied to ensure * the safe parallel use of these references. For instance, if the shared reference is to * an immutable object (like {@link java.lang.String String}), no special * action is needed - this is Concurrent Read (CR). *
* On the other hand, if a reference to a mutable object (A) is passed * between processes over channels, the sender may agree not to refer to A * (nor to any objects referred to within A) in the future - unless, of course, * the original reference to A is passed back. In this way, the reference acts * as a unique token, possesion of which must be held before access is allowed. * See also {@link org.jcsp.plugNplay.Paraplex} for a double buffering adaptation of this. *
* Such patterns give us safe, secure and dynamic forms of Exclusive Read Exclusive * Write (EREW) sharing which, along with the dynamic CREW provided by this class, * complement the static control automatically conferred by the CSP * process model. We just have to know when each is appropriate and apply them * with due care. * *
Implementation Note
* Channels, which are a specialisation of the multiway CSP event, are a fundamental * primitive for synchronising the actions of concurrent processes. Common patterns of * use have given rise to higher-level synchronisation paradigms that (when applicable) * are easier and, therefore, safer to use than the raw primitives. This CREW * lock is an example of this. [Another is the * {@link One2OneCallChannel CALL channel}.] ** The implementation is given here because it is short and simple - an example of the power * of expression (and provability) that follows from the CSP/occam model. Correct * implementation of a CREW lock has been notoriously difficult. See, for example, * Hoare's short but rather tricky solution from his paper, `Monitors: an Operating * System Structuring Concept' [C.A.R.Hoare, CACM, 17(10) pp. 549-557, October 1974] - * a paper often quoted as one of the sources for the Java monitor model. In contrast, * this CSP version is easy and that easiness is important. *
* Each Crew object spawns off a private and anonymous CrewServer process * with which it interacts only via channels: *
* public void startRead () {
* request.write (CrewServer.READER);
* }
*
* public void startWrite () {
* request.write (CrewServer.WRITER);
* writerControl.write (0);
* // wait for all current readers to finish
* }
*
* For startRead, this is all that happens - CrewServer will refuse
* the communication if there is a writer present. When accepted, there will be no writer
* present and the reader has permission to read the shared resource.
* * The startWrite communication will also be refused if another writer is present. * If there are readers present, it is accepted. This has to be the case since, as far as * the CrewServer is aware, it might have been from a startRead. * So, acceptance of this communication does not yet give the writer permission to start * writing - but it does let CrewServer know that a writer wants to write. * To get that permission, the writer performs a second communication on * writerControl - see above. *
* After accepting a writer request, CrewServer refuses further * communications on request and writerControl until all readers have * finished - which they do by signalling on readerRelease: *
* public void endRead () {
* readerRelease.write (0);
* }
*
* Refusing the request channel parks newly arriving readers and writers safely.
* When all existing readers have gone away, CrewServer accepts the outstanding
* communication on writerControl, which gives the waiting writer permission
* to write. CrewServer then waits for a second communication on
* writerControl, which is the signal from the writer that it has finished writing:
*
* public void endWrite () {
* writerControl.write (0);
* }
*
* before returning to its initial state (listening on request and
* readerRelease).
* * The logic is easier to explain in JCSP: *
* package org.jcsp.lang;
*
* class CrewServer implements CSProcess { // this is not a public class
*
* public static final int READER = 0;
* public static final int WRITER = 1;
*
* private final AltingChannelInputInt request;
* private final ChannelInputInt writerControl;
* private final AltingChannelInputInt readerRelease;
*
* public CrewServer (final AltingChannelInputInt request,
* final ChannelInputInt writerControl,
* final AltingChannelInputInt readerRelease) {
* this.request = request;
* this.writerControl = writerControl;
* this.readerRelease = readerRelease;
* }
*
* public void run () {
* int nReaders = 0;
* Guard[] c = {readerRelease, request};
* final int READER_RELEASE = 0;
* final int REQUEST = 1;
* Alternative alt = new Alternative (c);
* while (true) {
* // invariant : (nReaders is the number of current readers) and
* // invariant : (there are no writers)
* switch (alt.priSelect ()) {
* case READER_RELEASE:
* readerRelease.read (); // always let a reader finish reading
* nReaders--;
* break;
* case REQUEST:
* switch (request.read ()) {
* case READER:
* nReaders++; // let a reader start reading
* break;
* case WRITER:
* for (int i = 0; i < nReaders; i++) {
* readerRelease.read (); // wait for all readers to go away
* }
* nReaders = 0;
* writerControl.read (); // let the writer start writing
* writerControl.read (); // wait for writer to finish writing
* break;
* }
* break;
* }
* }
* }
*
* }
*
* Note that a CrewServer cannot be misused by reader and writer processes.
* It is private to each Crew lock and operated correctly by the
* methods of that lock. Given this correct operation, it is trivial to establish
* the declared loop invariant. All readers and writers start by communicating
* on the request channel so, so long as that is
* fairly serviced and that no read or write lasts forever,
* processes cannot be indefinitely blocked (e.g. readers by writers or writers by readers).
*
* Cautionary Note
* Fair servicing of readers and writers in the above depends on fair * servicing of the {@link Any2OneChannelInt any-1} request and * readerRelease channels. In turn, this depends on the fair * servicing of requests to enter a synchronized block (or method) by * the underlying Java Virtual Machine (JVM). Java does not specify how threads * waiting to synchronize should be handled. Currently, Sun's standard JDKs queue * these requests - which is fair. However, there is at least one JVM * that puts such competing requests on a stack - which is legal but unfair * and can lead to infinite starvation. This is a problem for any Java system * relying on good behaviour from synchronized, not just for JCSP's * any-1 channels or Crew locks. * * @author P.H. Welch */ public class Crew { private final Any2OneChannelIntImpl request = new Any2OneChannelIntImpl(); private final One2OneChannelIntImpl writerControl = new One2OneChannelIntImpl(); private final Any2OneChannelIntImpl readerRelease = new Any2OneChannelIntImpl(); ///TODO make this poison the existing channels, once poison is added private final Any2OneChannelIntImpl poison = new Any2OneChannelIntImpl(); private final ProcessManager manager = new ProcessManager(new CrewServer(request.in(), writerControl.in(), readerRelease.in(), poison.in())); private final Object shared; /** * Construct a lock for CREW-guarded operations on a shared resource. */ public Crew() { manager.start(); shared = null; } /** * Construct a lock for CREW-guarded operations on a shared resource. * * @param shared the shared resource for which this lock is to be used (see * {@link #getShared getShared}). */ public Crew(Object shared) { manager.start(); this.shared = shared; } /** * Finalize method added to terminate the process that it spawned. The spawned process holds no references * to this object so this object will eventually fall out of scope and gets finalized. */ protected void finalize() throws Throwable { poison.write(0); } /** * This must be invoked before any read operations on the associated shared resource. */ public void startRead() { request.write(CrewServer.READER); } /** * This must be invoked after any read operations on the associated shared resource. */ public void endRead() { readerRelease.write(0); } /** * This must be invoked before any write operations on the associated shared resource. */ public void startWrite() { request.write(CrewServer.WRITER); writerControl.write(0); // wait for all current readers to finish } /** * This must be invoked after any write operations on the associated shared resource. */ public void endWrite() { writerControl.write(0); } /** * This returns the shared resource associated with this lock by its * {@link #Crew(java.lang.Object) constructor}. * Note: if the {@link #Crew parameterless constructor} was used, * this will return null. * * @return the shared resource associated with this lock. */ public Object getShared() { return shared; } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/InlineAlternative.java 0000644 0000000 0000000 00000025665 11113402355 020354 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; // (NCCB) what is the reason for this class, over and above using a simple flat Alternative? /** * This class is experimental (i.e. not properly documented yet). * It is intended to allow {@link Alternative}s to be nested. * * @author Quickstone Technologies Limited * */ public class InlineAlternative extends Guard { /** Flags to control behaviour of this ALT if used as a guard. */ public static final int MODE_ARBITRARY = 0, MODE_FAIR = 1, MODE_PRI = 2; /** If used as a top level ALT, the work will be delegated to this */ private Alternative alt; /** Mode of the select */ private int selectMode; /** Index last selected */ private int selected; /** Index to favour (fair / pri) */ private int favourite; /** The preconditions set for the ALT when it is being used as a guard. */ private boolean[] preconditions; /** The guards */ private final Guard[] guard; /** The timer guards */ private final CSTimer[] timers; /** Nested ALTs */ private final InlineAlternative[] ialts; /** Timeout index */ private int timeoutIndex; /** Shortest alarm set by a timer */ private long minAlarm; /** Creates a new one */ public InlineAlternative(Guard[] guards) { this(guards, MODE_ARBITRARY); } /** Creates a new one */ public InlineAlternative(Guard[] guards, int mode) { super(); guard = guards; selectMode = mode; timers = new CSTimer[guards.length]; ialts = new InlineAlternative[guards.length]; for (int i = 0; i < guards.length; i++) if (guards[i] instanceof CSTimer) timers[i] = (CSTimer)guards[i]; else if (guards[i] instanceof InlineAlternative) ialts[i] = (InlineAlternative)guards[i]; } /** * Returns the index of the guard obtained by a call to select() or if this guard became ready within its parent ALT. */ public int getSelected() { if (selectMode == MODE_FAIR) { favourite = selected + 1; if (favourite == guard.length) favourite = 0; } return selected; } /** * Establishes a precondition array that will be used by default in calls to select(). This is useful when the ALT * is used as a guard within another ALT. */ public void setPreconditions(boolean[] precons) { preconditions = precons; } /** * Alters the precondition on a guard. */ public void setPreconditionByIndex(int index, boolean on) { if (preconditions == null) { preconditions = new boolean[guard.length]; for (int i = 0; i < preconditions.length; i++) preconditions[i] = true; } preconditions[index] = on; } /** * Returns the actual guard object corresponding to the selected guard. For example it can return the channel * or the ALT object. */ public Guard getSelectedGuard() { return guard[selected]; } /** * Returns the guard object at a given index. For example to obtain a channel or ALT object. */ public Guard getGuardByIndex(int index) { return guard[index]; } /** * Creates an Alternative (if needed) and delegates the call to it. */ public int select() { if (alt == null) alt = new Alternative(guard); if (preconditions != null) return alt.select(preconditions); else return alt.select(); } /** * Creates an Alternative (if needed) and delegates the call to it. */ public int priSelect() { if (alt == null) alt = new Alternative(guard); if (preconditions != null) return alt.priSelect(preconditions); else return alt.priSelect(); } /** * Creates an Alternative (if needed) and delegates the call to it. */ public int fairSelect() { if (alt == null) alt = new Alternative(guard); if (preconditions != null) return alt.fairSelect(preconditions); else return alt.fairSelect(); } /** * Enable this ALT as a guard within its parent ALT. This will enable all of its guards. */ boolean enable(Alternative alt) { timeoutIndex = -1; for (int i = favourite; i < guard.length; i++) { if ((preconditions == null) || (preconditions[i])) { if (guard[i].enable(alt)) { selected = i; return true; } if (timers[i] != null) { if (timeoutIndex < 0) { timeoutIndex = i; minAlarm = timers[i].getAlarm(); } else { long a = timers[i].getAlarm(); if (a < minAlarm) { timeoutIndex = i; minAlarm = a; } } } else if (ialts[i] != null) { if (timeoutIndex < 0) { timeoutIndex = i; minAlarm = ialts[i].minAlarm; } else { long a = ialts[i].minAlarm; if (a < minAlarm) { timeoutIndex = i; minAlarm = a; } } } } } for (int i = 0; i < favourite; i++) { if ((preconditions == null) || (preconditions[i])) { if (guard[i].enable(alt)) { selected = i; return true; } if (timers[i] != null) { if (timeoutIndex < 0) { timeoutIndex = i; minAlarm = timers[i].getAlarm(); } else { long a = timers[i].getAlarm(); if (a < minAlarm) { timeoutIndex = i; minAlarm = a; } } } else if (ialts[i] != null) { if (timeoutIndex < 0) { timeoutIndex = i; minAlarm = ialts[i].minAlarm; } else { long a = ialts[i].minAlarm; if (a < minAlarm) { timeoutIndex = i; minAlarm = a; } } } } } selected = -1; return false; } /** * Disable this ALT as a guard within its parent ALT. This will disable all of its guards. */ boolean disable() { boolean result = false; int startIndex; if (selected == -1) startIndex = favourite - 1; else startIndex = selected - 1; if (startIndex < favourite) { for (int i = startIndex; i >= 0; i--) { if (((preconditions == null) || (preconditions[i])) && guard[i].disable()) { result = true; selected = i; } } startIndex = guard.length - 1; } for (int i = startIndex; i >= favourite; i--) { if (((preconditions == null) || (preconditions[i])) && guard[i].disable()) { result = true; selected = i; } } if (selected == -1) { // We might be here because no guards were ready or because a timer // returned early. The workaround in the Alternative class will make // it OK to return FALSE. However it will probe down into the nested // ALTs so we must set 'selected' to refer to the timer, or point to // the nested ALT which contains the timer. selected = timeoutIndex; } return result; } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/ProcessManager.java 0000644 0000000 0000000 00000027506 11105701167 017650 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * This enables a {@link CSProcess} to be spawned * concurrently with the process doing the spawning. ** Shortcut to the Constructor and Method Summaries. * *
Description
* The ProcessManager class enables a {@link CSProcess} to be spawned * concurrently with the process doing the spawning. The class provides * methods to manage the spawned process: {@link #start start}, * {@link #join join} and {@link #stop stop}. The spawned process may, of course, * be a {@link Parallel} network of processes to any depth of nesting, in which * case the whole network comes under this management. ** Spawning processes is not the normal way of creating a network in JCSP - the * normal method is to use the {@link Parallel} class. However, when we need * to add processes in response to some run-time event, this capability is very * useful. *
* For completeness, ProcessManager is itself a CSProcess * - {@link #run run}ning a ProcessManager simply runs the process * it is managing. *
* *Spawning a CSProcess
* * This example demonstrates that the managed CSProcess is * executed concurrently with the spawning process and that it dies when * its manager terminates. The managed process is `infinite' and * just counts and chatters. The managed process is automatically terminated * if the main Java thread terminates (as in the case, eventually, below). *
* import org.jcsp.lang.*;
*
* public class ProcessManagerExample1 {
*
* public static void main (String[] argv) {
*
* final ProcessManager manager = new ProcessManager (
* new CSProcess () {
* public void run () {
* final CSTimer tim = new CSTimer ();
* long timeout = tim.read ();
* int count = 0;
* while (true) {
* System.out.println (count + " :-) managed process running ...");
* count++;
* timeout += 100;
* tim.after (timeout); // every 1/10th of a second ...
* }
* }
* }
* );
*
* final CSTimer tim = new CSTimer ();
* long timeout = tim.read ();
*
* System.out.println ("\n\n\t\t\t\t\t
* *** start the managed process");
* manager.start ();
*
* for (int i = 0; i < 10; i++) {
* System.out.println ("\n\n\t\t\t\t\t
* *** I'm still executing as well");
* timeout += 1000;
* tim.after (timeout); // every second ...
* }
*
* System.out.println ("\n\n\t\t\t\t\t
* *** I'm finishing now!");
* }
* }
*
*
* Stopping, Interrupting, Race-Hazards and Poison
* * Stopping a Java thread releases any locks it (or any sub-process) may be * holding, so this reduces the danger of other threads deadlocking through * a failure to acquire a needed lock. * However, if the stopped process were in the middle of some synchronised * transaction, the data update may be incomplete (and, hence, corrupt) * depending on the precise moment of the stopping. This is a race-hazard. * Further, if some other thread later needed to interact with the stopped * thread, it would deadlock. ** Instead of stopping a JCSP process, it is much safer to * {@link #interrupt() interrupt} it. * This gives the process the chance to notice the interrupt (through an * exception handler) and tidy up. * If no such handler is provided and the JCSP process attempts any * synchronisation afterwards, the process will bomb out with * a {@link ProcessInterruptedException}. *
* For historical reasons, a {@link #stop()} method is provided below – * but it is implemented as {@link #interrupt()} (and deprecated). *
* If the managed process has gone parallel, managing an interrupt to achieve * a clean exit is more tricky. * Stopping a network by setting a global volatile flag that each process polls * from time to time is not safe. * For example, a thread blocked on a monitor wait will remain blocked * if the thread that was going to notify it spots the shut-down flag * and terminates. *
* For JCSP processes, there is a general solution to this [`Graceful Termination * and Graceful Resetting', P.H.Welch, Proceedings of OUG-10, pp. 310-317, * Ed. A.W.P.Bakkers, IOS Press (Amsterdam), ISBN 90 5199 011 1, April, 1989], * based on the careful distribution of poison over the network's normal * communication channels. *
* However, JCSP now supports graceful termination of process networks and sub-networks
* through a notion of poisoning synchoronisation objects (e.g. channels)
* – see {@link Poisonable}.
*
* @see org.jcsp.lang.CSProcess
* @see org.jcsp.lang.Parallel
* @see org.jcsp.awt.ActiveApplet
* @see org.jcsp.lang.Poisonable
* @see org.jcsp.lang.PoisonException
*
* @author P.H. Welch
* @author P.D. Austin
*/
public class ProcessManager implements CSProcess
{
/**
* The maximum priority value for running a process.
*/
public static final int PRIORITY_MAX = Thread.MAX_PRIORITY;
/**
* The normal priority value for running a process.
*/
public static final int PRIORITY_NORM = Thread.NORM_PRIORITY;
/**
* The minimum priority value for running a process.
*/
public static final int PRIORITY_MIN = Thread.MIN_PRIORITY;
/** The CSProcess to be executed by this ProcessManager */
private final CSProcess process;
/** The thread supporting the CSProcess being executed by this ProcessManager */
private Thread thread;
/**
* @param proc the {@link CSProcess} to be executed by this ProcessManager
*/
public ProcessManager(CSProcess proc)
{
this.process = proc;
thread = new Thread()
{
public void run()
{
try
{
Parallel.addToAllParThreads(this);
process.run();
}
catch (Throwable e)
{
Parallel.uncaughtException("org.jcsp.lang.ProcessManager", e);
}
finally
{
Parallel.removeFromAllParThreads(this);
}
}
};
thread.setDaemon(true);
}
//}}}
//{{{ public void start ()
/**
* Start the managed process (but keep running ourselves).
*/
public void start()
{
thread.start();
}
/**
* Start the managed process at a specified priority
* (but keep running ourselves). The priority of the
*
* Run the managed process (that is start it and wait for it to terminate).
* This will adjust the priority of the calling process to the priority of
* this
* The managed process can be run at the caller's priority simply by directly
* calling the
* Public mutator for setting the
* The priority should be specified as an
* Public accessor for obtaining the
* Shortcut to the Constructor and Method Summaries.
*
*
* This corresponds loosely with the client-server communication pattern between
* active processes, but where information flows over a pair of channels connecting
* them. However, there are major semantic differences between the two mechanisms.
* A server process is in charge of its own life, can act spontaenously and
* can refuse to accept a client call. A server object is passive, never does
* anything unless invoked and, then, has no choice but to obey. We must be careful,
* therefore, not to become confused by the same words computer scientists have chosen
* to mean very different things.
*
* CALL channels risk deepening this confusion. They provide a method interface for
* client-server communication between active processes, yet their semantics
* remain those of a synchronising zero-buffered channel. However, the attraction of
* replacing a sequence of channel write(s) and read (matched at
* the other end of the channel-pair by a sequence of channel read(s) and
* write) with a single method invocation (and a single matching
* {@link #accept accept}) makes this risk worthwhile.
*
* [Note: CALL channels were part of the occam3 language specification.
* They provide an extended rendezvous in the sense of an Ada entry,
* but are considerably more flexible and lightweight.]
*
*
*
* Consider the following:
*
* In between the join and the fork, the client and server
* processes are locked together in extended rendezvous, commonly executing
* the chosen method in the server environment.
* [Actually, it is the client that invokes the method on the server,
* temporarilly referenced by the {@link #server server} field from this
* One2OneCallChannel super-class and blocked waiting for its accept
* to complete.]
* Setting the {@link #selected selected} field is optional. However, its value
* is returned to the server by the {@link #accept accept} method and
* can be used (as in the above) to let the server know which of its methods
* the client invoked.
*
* [Note: a One2OneFooChannel is only safe to use between a single
* client and a single server. Any-1, 1-Any and Any-Any
* versions may be derived from {@link Any2OneCallChannel}, {@link One2AnyCallChannel}
* and {@link Any2AnyCallChannel} (respectively) using exactly the same pattern
* as above.]
*
*
* It is also semantically misleading - B's interface is through the CALL channel
* passed to its constructor, not through its (necessarilly public) Foo
* methods.
*
* So, B should not be the public server process - we need to hide
* its directly invocable methods. A simple way to do this is to wrap it up in
* another process that simply omits the public declaration of the relevant interface:
*
* [Note: the only difference needed in the server code to support
* Any-1, 1-Any and Any-Any CALL channels is in the parameter
* declaration that specifies the variety to be used. For complete flexibility,
* constructors (or setFooChannel methods) for each kind
* (i.e. One2OneFooChannel,
* Any2OneFooChannel,
* One2AnyFooChannel and
* Any2AnyFooChannel
* may be provided.]
*
*
* However, when implementing the server, the CALL channel field needs to be declared as
* an {@link AltingChannelAccept}, rather than a {@link ChannelAccept}.
* So, in the above example, the first field declaration of B
* needs to become:
*
* [Note: a server may ALT on a Any-1 CALL channel with this same change.
* However, as for ordinary channels, ALTing over 1-Any or Any-Any versions
* is not supported.]
*
*
* For example, the simple two process network:
*
* [Note: simple network examples using
* Any-1,
* 1-Any
* and Any-Any CALL channels
* are given in their respective classes.]
*
*
* Note: BlackHoleChannels are used for masking off unwanted outputs
* from processes. They are useful when we want to reuse an existing process component
* intact, but don't need some of its output channels (i.e. we don't want to redesign
* and reimplement the component to remove the redundant channels). Normal channels cannot
* be plugged in and left dangling as this may deadlock (parts of) the component being
* reused.
*
*
* @see org.jcsp.lang.ChannelOutput
* @see org.jcsp.lang.One2OneChannel
* @see org.jcsp.lang.Any2OneChannel
* @see org.jcsp.lang.One2AnyChannel
* @see org.jcsp.lang.Any2AnyChannel
*
* @author P.H. Welch
*/
public class BlackHoleChannel implements ChannelOutput
{
/**
* Write an Object to the channel and lose it.
*
* @param object the object to write to the channel.
*/
public void write(Object object)
{
}
public void poison(int strength)
{
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/One2AnyImpl.java 0000644 0000000 0000000 00000006677 11113671251 017041 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
class One2AnyImpl implements One2AnyChannel, ChannelInternals {
private ChannelInternals channel;
/** The mutex on which readers must synchronize */
private final Mutex readMutex = new Mutex();
One2AnyImpl(ChannelInternals _channel) {
channel = _channel;
}
public SharedChannelInput in() {
return new SharedChannelInputImpl(this,0);
}
public ChannelOutput out() {
return new ChannelOutputImpl(channel,0);
}
public void endRead() {
channel.endRead();
readMutex.release();
}
public Object read() {
readMutex.claim();
//A poison exception might be thrown, hence the try/finally:
try
{
return channel.read();
}
finally
{
readMutex.release();
}
}
//begin never used:
public boolean readerDisable() {
return false;
}
public boolean readerEnable(Alternative alt) {
return false;
}
public boolean readerPending() {
return false;
}
//end never used
public void readerPoison(int strength) {
readMutex.claim();
channel.readerPoison(strength);
readMutex.release();
}
public Object startRead() {
readMutex.claim();
try
{
return channel.startRead();
}
catch (RuntimeException e)
{
channel.endRead();
readMutex.release();
throw e;
}
}
//begin never used
public void write(Object obj) {
channel.write(obj);
}
public void writerPoison(int strength) {
channel.writerPoison(strength);
}
//end never used
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/package.html 0000644 0000000 0000000 00000016317 11077567615 016373 0 ustar
Processes encapsulate both data and algorithms. Parallel processes interact
either by synchronised communication along {@link org.jcsp.lang.Channel}s
(the cleanest and simplest way) or by synchronised access to shared
objects. The latter synchronisation may be achieved through channel signals
or by a range of other JCSP primitives (such as {@link org.jcsp.lang.Barrier},
{@link org.jcsp.lang.AltingBarrier},
{@link org.jcsp.lang.Bucket} or {@link org.jcsp.lang.Crew}).
Processes may passively wait for a number of events using {@link org.jcsp.lang.Alternative}.
These events include channel inputs
({@link org.jcsp.lang.AltingChannelInput} / {@link org.jcsp.lang.AltingChannelInputInt}),
channel accepts
({@link org.jcsp.lang.AltingChannelAccept}),
alting barriers ({@link org.jcsp.lang.AltingBarrier}),
timeouts ({@link org.jcsp.lang.CSTimer}) and skips ({@link org.jcsp.lang.Skip}).
If more than one event is ready, an {@link org.jcsp.lang.Alternative#select() arbitrary},
{@link org.jcsp.lang.Alternative#priSelect() prioritised}
or {@link org.jcsp.lang.Alternative#select() fair} choice can be made between them.
The super-interface for all these ALTable events is {@link org.jcsp.lang.Guard}.
Note that the default semantics for all the above channels are zero-buffering and full
synchronisation. This means that a writer to a channel will wait for a matching reader
and vice-versa - whoever gets to the channel first will wait
for its partner. Various forms of buffering can be introduced by splicing active
buffer processes into these channels. However, because this is a common need,
JCSP provides a range of plug-ins that can be used to create channels
with the common varieties of buffering:
{@link org.jcsp.util.Buffer
It is the network builder's responsibility to decide whether to use 1-1,
any-1, 1-any or any-any channels and whether to incorporate
buffers in them.
The process designer is not concerned with these decisions - only with whether
the channel is for input or output and what type of information it carries.
The client process sees a server-specific method interface and invokes it in the normal
way - however, the invocation will block until the server chooses to accept the call.
The server sees the {@link org.jcsp.lang.ChannelAccept} interface - invoking
an {@link org.jcsp.lang.ChannelAccept#accept accept} will block until the client
makes a call.
The network builder constructs a server-specific actual call channel by sub-classing
from one of
{@link org.jcsp.lang.One2OneCallChannel}, {@link org.jcsp.lang.Any2OneCallChannel},
{@link org.jcsp.lang.One2AnyCallChannel} and {@link org.jcsp.lang.Any2AnyCallChannel}.
Precise rules for making this extension are given in their documentation.
* Shortcut to the Constructor and Method Summaries.
*
* Note: for those familiar with the occam programming
* language, the Sequence class gives the semantics of the
* SEQ construct.
*
* This class is included for completeness. Sequential code is normally
* be handled by sequential Java code. If we need to run some
* CSProcesses in sequence, we can just execute their run
* methods in sequence. However, using this Sequence class
* lets us switch between sequential and parallel composition of processes
* with a single word change (replace Sequence by Parallel)
* in our code. For some applications (e.g. the example below), this may provide
* a useful comparison.
*
* CSProcesses can be added to a Sequence object either via the
* {@link #Sequence(CSProcess[]) constructor} or the {@link #addProcess addProcess}
* methods. If a call to addProcess is made while the
* run method is executing, the extra process(es) will not be
* executed until the next time run is invoked.
*
* CSProcesses can be removed from Sequence object via
* the {@link #removeProcess removeProcess} or
* {@link #removeAllProcesses removeAllProcesses} method.
* If a call to removeProcess or removeAllProcesses
* is made while the run method is executing, the process will
* not be removed from the network until the next time run is
* invoked.
*
* The following example illustrates a simple transformation of sequential code
* into parallel code. On a shared-memory parallel machine (e.g. a Symmetric
* Multi-Processor) and depending on the overheads for starting up and shutting
* down the concurrency and the scale of the problem to which it is applied,
* the parallel code will terminate earlier than its sequential equivalent.
*
*
* If this were occam, all we would need to do is replace the two outer
* for-loops with par-loops. Since this is Java, we have
* to jump through some slightly higher syntactic hoops. First, we need
* to transform the body of the for-loop into a process and
* use the loop to assign each one to consecutive elements of a process
* array. Then, we simply run the array in parallel:
*
* In parMultiply, however, the Parallel
* process is anonymous and local to the method and so can never be used again.
* Worse, the threads it created and parked are left parked - wasting space for
* the remainder of the program. Repeated invocations of parMultiply,
* therefore, will leak memory.
*
* There are two ways to fix this. The first is to accept that the Parallel
* process created by parMultiply remains local to it (and, hence, un-reusable)
* and, explicitly, to unpark and terminate its unwanted threads. This can be done by
* invoking {@link org.jcsp.lang.Parallel#releaseAllThreads releaseAllThreads} on
* the Parallel after it has been run - the memory associated with
* those threads will be released. A temporary name for the process needs to be
* assigned and the last executable line of parMultiply
* becomes the three lines:
*
* Much better is to give the user of parMultiply the responsibilty of
* looking after - and directly using, reusing and (if necessary) terminating the threads
* in - the Parallel process. So, we change the method into something that
* manufactures a process that does parallel matrix multiplication.
* That multiplication will be specific to the three matrices given as parameters
* (i.e. it performs Z = X*Y on those matrices only):
*
* Please note that this is a safely shared channel and not
* a multicaster. Currently, multicasting has to be managed by
* writing active processes (see {@link org.jcsp.plugNplay.DynamicDelta}
* for an example of broadcasting).
*
* All reading processes and writing processes commit to the channel
* (i.e. may not back off). This means that the reading processes
* may not {@link Alternative ALT} on this channel.
*
* The constructor requires the user to provide
* the channel with a plug-in driver conforming to the
* {@link org.jcsp.util.ints.ChannelDataStoreInt ChannelDataStoreInt}
* interface. This allows a variety of different channel semantics to be
* introduced -- including buffered channels of user-defined capacity
* (including infinite), overwriting channels (with various overwriting
* policies) etc..
* Standard examples are given in the org.jcsp.util package, but
* careful users may write their own.
*
*
* Channels are immune to poisoning unless explicitly constructed to be poisonable
* (by those static methods in {@link Channel} that prescribe a level
* of immunity – e.g. {@link Channel#one2one(int) this one}).
*
* Poisonable channels are immune to poisons with strength below the level
* of immunity given when they were constructed.
* Above this level, the poison will take effect.
*
* Any attempt to use a poisoned channel will cause a {@link PoisonException}
* to be thrown.
* Processes blocked on a channel that gets poisoned will be awoken with
* a thrown {@link PoisonException}.
*
* Poisoning is an effective technique for the safe interruption of processes and
* termination of process networks or sub-networks (of any connected topology).
* Note that poisoning a channel is non-blocking.
* Also, poisoning an already poisoned channel does no (extra) harm.
*
* The algorithm is simple.
* One or more processes may independently decide to poison their environment
* and terminate.
* To do this, they poison their external channels, tidy up and die.
* Any process accessing or waiting on a poisoned channel gets a {@link PoisonException}
* thrown: this should be caught, local affairs settled and external channels
* posioned before the process terminates.
* That's all.
*
* An example is shown in {@link org.jcsp.plugNplay.Generate} and
* here,
* where the channels in the example network are constructed to be poisonable
* (with an immunity of zero) and FairMuxTime initiates the shut-down
* (by injecting poison of strength 42).
*
* To bring down only a sub-network, the internal channels of the subnet
* should have an immunity lower than its external channels.
* One of the subnet processes must choose (or be told) to release poison with
* strength one greater than the subnet channel immunity.
* That will terminate just the subnet, leaving the surrounding processes unaffected
* – until they next try to communicate with the shut-down subnet.
* This is no problem so long as the subnet is being replaced, which is
* the usual reason for closing the previous one.
*
* The reading process may {@link Alternative ALT} on this channel.
* The writing process is committed (i.e. it may not back off).
*
* The constructor requires the user to provide
* the channel with a plug-in driver conforming to the
* {@link org.jcsp.util.ChannelDataStore ChannelDataStore}
* interface. This allows a variety of different channel semantics to be
* introduced -- including buffered channels of user-defined capacity
* (including infinite), overwriting channels (with various overwriting
* policies) etc..
* Standard examples are given in the org.jcsp.util package, but
* careful users may write their own.
*
* @see org.jcsp.lang.Alternative
* @see org.jcsp.lang.BufferedAny2OneChannel
* @see org.jcsp.lang.BufferedOne2AnyChannel
* @see org.jcsp.lang.BufferedAny2AnyChannel
* @see org.jcsp.util.ChannelDataStore
*
* @author P.D. Austin
* @author P.H. Welch
*/
class PoisonableBufferedOne2OneChannel implements One2OneChannel, ChannelInternals
{
/** The ChannelDataStore used to store the data for the channel */
private final ChannelDataStore data;
private final Object rwMonitor = new Object();
private Alternative alt;
//Only passed to channel-ends, not used directly:
private int immunity;
private int poisonStrength = 0;
/**
* Constructs a new BufferedOne2OneChannel with the specified ChannelDataStore.
*
* @param data the ChannelDataStore used to store the data for the channel
*/
public PoisonableBufferedOne2OneChannel(ChannelDataStore data, int _immunity)
{
if (data == null)
throw new IllegalArgumentException
("Null ChannelDataStore given to channel constructor ...\n");
this.data = (ChannelDataStore) data.clone();
immunity = _immunity;
}
private boolean isPoisoned() {
return poisonStrength > 0;
}
/**
* Reads an Object from the channel.
*
* @return the object read from the channel.
*/
public Object read () {
synchronized (rwMonitor) {
if (data.getState () == ChannelDataStore.EMPTY) {
//Reader only sees poison if buffer is empty:
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
try {
rwMonitor.wait ();
while (data.getState () == ChannelDataStore.EMPTY && !isPoisoned()) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.One2OneChannelXRead);
}
rwMonitor.wait ();
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException (
"*** Thrown from One2OneChannel.read (int)\n" + e.toString ()
);
}
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
}
rwMonitor.notify ();
return data.get ();
}
}
public Object startRead() {
synchronized (rwMonitor) {
if (data.getState () == ChannelDataStore.EMPTY) {
// Reader only sees poison if buffer is empty:
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
try {
rwMonitor.wait ();
while (data.getState () == ChannelDataStore.EMPTY && !isPoisoned()) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.One2OneChannelXRead);
}
rwMonitor.wait ();
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException (
"*** Thrown from One2OneChannel.read (int)\n" + e.toString ()
);
}
// Reader only sees poison if buffer is empty:
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
}
return data.startGet();
}
}
public void endRead() {
synchronized(rwMonitor) {
data.endGet();
rwMonitor.notify ();
}
}
/**
* Writes an Object to the channel.
*
* @param value the object to write to the channel.
*/
public void write (Object value) {
synchronized (rwMonitor) {
//Writer always sees poison:
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
data.put (value);
if (alt != null) {
alt.schedule ();
} else {
rwMonitor.notify ();
}
if (data.getState () == ChannelDataStore.FULL) {
try {
rwMonitor.wait ();
while (data.getState () == ChannelDataStore.FULL && !isPoisoned()) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.One2OneChannelXWrite);
}
rwMonitor.wait ();
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException (
"*** Thrown from One2OneChannel.write (Object)\n" + e.toString ()
);
}
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
}
}
}
/**
* turns on Alternative selection for the channel. Returns true if the
* channel has data that can be read immediately.
*
* Note: this method should only be called by the Alternative class
*
* @param alt the Alternative class which will control the selection
* @return true if the channel has data that can be read, else false
*/
public boolean readerEnable (Alternative alt) {
synchronized (rwMonitor) {
if (isPoisoned()) {
//If it's poisoned, it will be ready whether because of the poison, or because
//the buffer has data in it
return true;
} else if (data.getState () == ChannelDataStore.EMPTY) {
this.alt = alt;
return false;
}
else {
return true;
}
}
}
/**
* turns off Alternative selection for the channel. Returns true if the
* channel contained data that can be read.
*
* Note: this method should only be called by the Alternative class
*
* @return true if the channel has data that can be read, else false
*/
public boolean readerDisable () {
synchronized (rwMonitor) {
alt = null;
return data.getState () != ChannelDataStore.EMPTY || isPoisoned();
}
}
/**
* Returns whether there is data pending on this channel.
*
* Note: if there is, it won't go away until you read it. But if there
* isn't, there may be some by the time you check the result of this method.
*
* This method is provided for convenience. Its functionality can be provided
* by Pri Alting the channel against a SKIP guard, although
* at greater run-time and syntactic cost. For example, the following code
* fragment:
*
* Some browsers, when shutting down an applet, may do this to processes
* spawned by an {@link org.jcsp.awt.ActiveApplet} that have not died naturally.
*
* Alternatively, this may be raised by processes stopped prematurely as a result of
* a call to Parallel.destroy, or by calling stop on the
* ProcessManager responsible for the process (or network).
*
* @author P.H. Welch
*/
//}}}
public class ProcessInterruptedException extends Error {
public ProcessInterruptedException (String s) {
super ("\n*** Interrupting a running process is not compatible with JCSP\n" +
"*** Please don't do this!\n" + s);
// System.out.println ("Someone is creating a ProcessInterruptedException!\n" + s);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/SharedChannelOutputIntImpl.java 0000644 0000000 0000000 00000004633 11113671251 022147 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
class SharedChannelOutputIntImpl implements SharedChannelOutputInt {
private ChannelInternalsInt channel;
private int immunity;
SharedChannelOutputIntImpl(ChannelInternalsInt _channel, int _immunity) {
channel = _channel;
immunity = _immunity;
}
public void write(int object) {
channel.write(object);
}
public void poison(int strength) {
if (strength > immunity) {
channel.writerPoison(strength);
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/PoisonableBufferedAny2AnyChannelInt.java 0000644 0000000 0000000 00000004351 11113671251 023633 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.ints.ChannelDataStoreInt;
class PoisonableBufferedAny2AnyChannelInt extends Any2AnyIntImpl
{
PoisonableBufferedAny2AnyChannelInt(ChannelDataStoreInt _data, int _immunity) {
super(new PoisonableBufferedAny2AnyChannelInt(_data,_immunity));
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/StandardConnectionFactory.java 0000644 0000000 0000000 00000010211 11105701167 022030 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
*
* Implements a factory for creating connections.
*
* Shortcut to the Constructor and Method Summaries.
*
* Note: for those familiar with the occam multiprocessing
* language, this gives the semantics of the
* The
* Eight types of
* By invoking one of the following methods, a process may passively wait for
* one or more of the guards associated with an
* Finally, each guard may be
* pre-conditioned with a run-time test
* to decide if it should be considered in the current choice. This allows
* considerable flexibilty -- for example, we can decide whether timeouts
* shoud be set, channels refused or polling enabled depending
* on the run-time state of the Alting process.
*
* Sometimes we need to use
* To demonstrate
* The {@link org.jcsp.plugNplay.Generate} and {@link org.jcsp.plugNplay.Printer} are
* programmed to deal with being poisoned.
* Here is the run() method for Generate:
*
* The interval (in msecs) defining the output flow rate is given by a constructor argument.
* This can be changed at any time by sending a new interval (as a
* Note: this example shows how simple it is to program time-regulated functionality
* like that performed by
* To demonstrate
* Note: polling is an often overused technique. Make sure your design would
* not be better suited with a blocking ALT and with the `something else' done by
* a process running in parallel.
*
*
*
* The
* Contrast the above programming of the canteen as a CSP process rather
* than a monitor. A monitor cannot refuse a callback when noone has the lock,
* even though it may not be in a state to process it. In the above, a
* On the other hand, the above
* The transputer designers always said that getting its microcoded scheduler
* logic right was one of their hardest tasks. Working directly with the monitor
* concept means working at a similar level of difficulty for application programs.
* One of the goals of JCSP is to protect users from ever having to work at that level,
* providing instead a range of CSP primitives whose ease of use scales well with
* application complexity -- and in whose implementation those monitor complexities
* are correctly distilled and hidden.
*
* @see org.jcsp.lang.Guard
* @see org.jcsp.lang.AltingChannelInput
* @see org.jcsp.lang.AltingChannelInputInt
* @see org.jcsp.lang.AltingChannelAccept
* @see org.jcsp.lang.AltingBarrier
* @see org.jcsp.lang.CSTimer
* @see org.jcsp.lang.Skip
*
* @author P.H. Welch and P.D. Austin
*/
//}}}
public class Alternative
{
/** The monitor synchronising the writers and alting reader */
protected Object altMonitor = new Object ();
private static final int enabling = 0;
private static final int waiting = 1;
private static final int ready = 2;
private static final int inactive = 3;
/** The state of the ALTing process. */
private int state = inactive;
/** The array of guard events from which we are selecting. */
private final Guard[] guard;
/** The index of the guard with highest priority for the next select. */
private int favourite = 0; // invariant: 0 <= favourite < guard.length
/** The index of the selected guard. */
private int selected; // after the enable/disable sequence :
// 0 <= selected < guard.length
private final int NONE_SELECTED = -1;
/** This indicates whether an AltingBarrier is one of the Guards. */
private boolean barrierPresent;
/** This flag is set by a successful AltingBarrier enable/disable. */
private boolean barrierTrigger = false;
/** The index of a selected AltingBarrier. */
private int barrierSelected;
/**
* This is the index variable used during the enable/disable sequences.
* This has been made global to simplify the call-back (setTimeout) from
* a CSTimer that is being enabled. That call-back sets the timeout, msecs
* and timeIndex variables below. The latter variable is needed only to
* work around the bug that Java wait-with-timeouts sometimes return early.
*/
private int enableIndex;
/** This flag is set if one of the enabled guards was a CSTimer guard. */
private boolean timeout = false;
/** If one or more guards were CSTimers, this holds the earliest timeout. */
private long msecs;
/**
* If one or more guards were CSTimers, this holds the index of the one
* with the earliest timeout.
*/
private int timeIndex;
/**
* Construct an
*
* @param guard the event guards over which the select operations will be made.
*/
public Alternative(final Guard[] guard)
{
this.guard = guard;
for (int i = 0; i < guard.length; i++)
{
if (guard[i] instanceof MultiwaySynchronisation)
{
barrierPresent = true;
return;
}
}
barrierPresent = false;
}
/**
* Returns the index of one of the ready guards. The method will block
* until one of the guards becomes ready. If more than one is ready,
* an arbitrary choice is made.
*/
public final int select()
{
return fairSelect (); // a legal implementation of arbitrary choice!
}
/**
* Returns the index of one of the ready guards. The method will block
* until one of the guards becomes ready. If more than one is ready,
* the one with the lowest index is selected.
*/
public final int priSelect () {
// if (barrierPresent) {
// throw new AlternativeError (
// "*** Cannot 'priSelect' with an AltingBarrier in the Guard array"
// );
// }
state = enabling;
favourite = 0;
enableGuards ();
synchronized (altMonitor) {
if (state == enabling) {
state = waiting;
try {
if (timeout) {
long delay = msecs - System.currentTimeMillis ();
if (delay > Spurious.earlyTimeout) {
altMonitor.wait (delay);
/*
while ((state == waiting) &&
((delay = (msecs - System.currentTimeMillis ()))
> Spurious.earlyTimeout)) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.AlternativeSelectWithTimeout);
}
altMonitor.wait (delay);
}
if ((state == waiting) && (delay > 0)) {
if (Spurious.logging) {
SpuriousLog.incEarlyTimeouts ();
}
}
*/
while (state == waiting) {
delay = msecs - System.currentTimeMillis ();
if (delay > Spurious.earlyTimeout) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.AlternativeSelectWithTimeout);
}
altMonitor.wait (delay);
}
else {
if ((delay > 0) && (Spurious.logging)) {
SpuriousLog.incEarlyTimeouts ();
}
break;
}
}
// System.out.println (state + " [" + delay + "]");
}
} else {
altMonitor.wait ();
while (state == waiting) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.AlternativeSelect);
}
altMonitor.wait ();
}
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException (
"*** Thrown from Alternative.priSelect ()\n" + e.toString ()
);
}
state = ready;
}
}
disableGuards ();
state = inactive;
timeout = false;
return selected;
}
/**
* Returns the index of one of the ready guards. The method will block
* until one of the guards becomes ready. Consequetive invocations will
* service the guards `fairly' in the case when many guards are always
* ready. Implementation note: the last guard serviced has the lowest
* priority next time around.
*/
public final int fairSelect () {
state = enabling;
enableGuards ();
synchronized (altMonitor) {
if (state == enabling) {
state = waiting;
try {
if (timeout) {
long delay = msecs - System.currentTimeMillis ();
// NOTE: below is code that demonstrates whether wait (delay)
// sometimes returns early! Because this happens in some JVMs,
// we are forced into a workaround - see disableGuards ().
// long now = System.currentTimeMillis ();
// long delay = msecs - now;
if (delay > Spurious.earlyTimeout) {
altMonitor.wait (delay);
/*
while ((state == waiting) &&
((delay = msecs - System.currentTimeMillis ())
> Spurious.earlyTimeout)) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.AlternativeSelectWithTimeout);
}
altMonitor.wait (delay);
}
if ((state == waiting) && (delay > 0)) {
if (Spurious.logging) {
SpuriousLog.incEarlyTimeouts ();
}
}
*/
while (state == waiting) {
delay = msecs - System.currentTimeMillis ();
if (delay > Spurious.earlyTimeout) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.AlternativeSelectWithTimeout);
}
altMonitor.wait (delay);
}
else {
if ((delay > 0) && (Spurious.logging)) {
SpuriousLog.incEarlyTimeouts ();
}
break;
}
}
}
// long then = System.currentTimeMillis ();
// System.out.println ("*** fairSelect: " + msecs +
// ", " + now + ", " + delay +
// ", " + then);
} else {
altMonitor.wait ();
while (state == waiting) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.AlternativeSelect);
}
altMonitor.wait ();
}
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException (
"*** Thrown from Alternative.fairSelect/select ()\n" + e.toString ()
);
}
state = ready;
}
}
disableGuards ();
state = inactive;
favourite = selected + 1;
if (favourite == guard.length)
favourite = 0;
timeout = false;
return selected;
}
/**
* Enables the guards for selection. If any of the guards are ready,
* it sets selected to the ready guard's index, state to ready and returns.
* Otherwise, it sets selected to NONE_SELECTED and returns.
*/
private final void enableGuards () {
if (barrierPresent) {
// System.out.println ("ENABLE barrier(s) present ...");
AltingBarrierCoordinate.startEnable ();
}
barrierSelected = NONE_SELECTED;
for (enableIndex = favourite; enableIndex < guard.length; enableIndex++) {
if (guard[enableIndex].enable (this)) {
// if (guard[enableIndex] instanceof AltingChannelInput) {
// System.out.println ("CHANNEL ENABLE " + enableIndex + " SUCCEED");
// } else {
// System.out.println ("ENABLE " + enableIndex + " SUCCEED");
// }
selected = enableIndex;
state = ready;
if (barrierTrigger) {
barrierSelected = selected;
barrierTrigger = false;
} else if (barrierPresent) {
// System.out.println ("ENABLE " + enableIndex + " NON-BARRIER SUCCEED");
AltingBarrierCoordinate.finishEnable ();
}
return;
} // else {
// if (guard[enableIndex] instanceof AltingChannelInput) {
// System.out.println ("CHANNEL ENABLE " + enableIndex + " FAIL");
// } else {
// System.out.println ("ENABLE " + enableIndex + " FAIL");
// }
// }
}
for (enableIndex = 0; enableIndex < favourite; enableIndex++) {
if (guard[enableIndex].enable (this)) {
// if (guard[enableIndex] instanceof AltingChannelInput) {
// System.out.println ("CHANNEL ENABLE " + enableIndex + " SUCCEED");
// } else {
// System.out.println ("ENABLE " + enableIndex + " SUCCEED");
// }
selected = enableIndex;
state = ready;
if (barrierTrigger) {
barrierSelected = selected;
barrierTrigger = false;
} else if (barrierPresent) {
// System.out.println ("ENABLE " + enableIndex + " NON-BARRIER SUCCEED");
AltingBarrierCoordinate.finishEnable ();
}
return;
} // else {
// if (guard[enableIndex] instanceof AltingChannelInput) {
// System.out.println ("CHANNEL ENABLE " + enableIndex + " FAIL");
// } else {
// System.out.println ("ENABLE " + enableIndex + " FAIL");
// }
// }
}
// System.out.println ("ENABLE ALL FAIL");
selected = NONE_SELECTED;
if (barrierPresent) {
AltingBarrierCoordinate.finishEnable ();
}
}
/**
* Disables the guards for selection. Sets selected to the index of
* the ready guard, taking care of priority/fair choice.
*/
private void disableGuards () {
if (selected != favourite) { // else there is nothing to disable
int startIndex = (selected == NONE_SELECTED) ? favourite - 1: selected - 1;
if (startIndex < favourite) {
for (int i = startIndex; i >= 0; i--) {
if (guard[i].disable ()) {
selected = i;
if (barrierTrigger) {
if (barrierSelected != NONE_SELECTED) {
throw new JCSP_InternalError (
"*** Second AltingBarrier completed in ALT sequence: " +
barrierSelected + " and " + i
);
}
barrierSelected = selected;
barrierTrigger = false;
}
}
}
startIndex = guard.length - 1;
}
for (int i = startIndex; i >= favourite; i--) {
if (guard[i].disable ()) {
selected = i;
if (barrierTrigger) {
if (barrierSelected != NONE_SELECTED) {
throw new JCSP_InternalError (
"\n*** Second AltingBarrier completed in ALT sequence: " +
barrierSelected + " and " + i
);
}
barrierSelected = selected;
barrierTrigger = false;
}
}
}
if (selected == NONE_SELECTED) {
// System.out.println ("disableGuards: NONE_SELECTED ==> " + timeIndex);
// NOTE: this is a work-around for Java wait-with-timeouts sometimes
// returning early. If this did not happen, we would not get here!
selected = timeIndex;
}
}
if (barrierSelected != NONE_SELECTED) { // We must choose a barrier sync
selected = barrierSelected; // if one is ready - so that all
AltingBarrierCoordinate.finishDisable (); // parties make the same choice.
}
}
/**
* This is the call-back from enabling a CSTimer guard. It is part of the
* work-around for Java wait-with-timeouts sometimes returning early.
* It is still in the flow of control of the ALTing process.
*/
void setTimeout (long msecs) {
if (timeout) {
if (msecs < this.msecs) {
this.msecs = msecs;
timeIndex = enableIndex;
}
} else {
timeout = true;
this.msecs = msecs;
timeIndex = enableIndex;
}
}
/**
* This is a call-back from an AltingBarrier.
* It is still in the flow of control of the ALTing process.
*/
void setBarrierTrigger () {
barrierTrigger = true;
}
/**
* This is the wake-up call to the process ALTing on guards controlled
* by this object. It is in the flow of control of a process writing
* to an enabled channel guard.
*/
void schedule () {
synchronized (altMonitor) {
switch (state) {
case enabling:
state = ready;
break;
case waiting:
state = ready;
altMonitor.notify ();
break;
// case ready: case inactive:
// break
}
}
}
/////////////////// The pre-conditioned versions of select ///////////////////
/**
* Returns the index of one of the ready guards whose
* Note: the length of the
*
* @param preCondition the guards from which to select
*/
public final int select (boolean[] preCondition) {
return fairSelect (preCondition); // a legal implementation of arbitrary choice!
}
/**
* Returns the index of one of the ready guards whose
* Note: the length of the
*
* @param preCondition the guards from which to select
*/
public final int priSelect (boolean[] preCondition) {
// if (barrierPresent) {
// throw new AlternativeError (
// "*** Cannot 'priSelect' with an AltingBarrier in the Guard array"
// );
// }
if (preCondition.length != guard.length) {
throw new IllegalArgumentException (
"*** org.jcsp.lang.Alternative.select called with a preCondition array\n" +
"*** whose length does not match its guard array"
);
}
state = enabling;
favourite = 0;
enableGuards (preCondition);
synchronized (altMonitor) {
if (state == enabling) {
state = waiting;
try {
if (timeout) {
long delay = msecs - System.currentTimeMillis ();
if (delay > Spurious.earlyTimeout) {
altMonitor.wait (delay);
while (state == waiting) {
delay = msecs - System.currentTimeMillis ();
if (delay > Spurious.earlyTimeout) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.AlternativeSelectWithTimeout);
}
altMonitor.wait (delay);
}
else {
if ((delay > 0) && (Spurious.logging)) {
SpuriousLog.incEarlyTimeouts ();
}
break;
}
}
}
} else {
altMonitor.wait ();
while (state == waiting) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.AlternativeSelect);
}
altMonitor.wait ();
}
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException (
"*** Thrown from Alternative.priSelect (boolean[])\n" + e.toString ()
);
}
state = ready;
}
}
disableGuards (preCondition);
state = inactive;
timeout = false;
return selected;
}
/**
* Returns the index of one of the ready guards whose
* Note: the length of the
*
* @param preCondition the guards from which to select
*/
public final int fairSelect (boolean[] preCondition) {
if (preCondition.length != guard.length) {
throw new IllegalArgumentException (
"*** org.jcsp.lang.Alternative.select called with a preCondition array\n" +
"*** whose length does not match its guard array"
);
}
state = enabling;
enableGuards (preCondition);
synchronized (altMonitor) {
if (state == enabling) {
state = waiting;
try {
if (timeout) {
long delay = msecs - System.currentTimeMillis ();
if (delay > Spurious.earlyTimeout) {
altMonitor.wait (delay);
while (state == waiting) {
delay = msecs - System.currentTimeMillis ();
if (delay > Spurious.earlyTimeout) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.AlternativeSelectWithTimeout);
}
altMonitor.wait (delay);
}
else {
if ((delay > 0) && (Spurious.logging)) {
SpuriousLog.incEarlyTimeouts ();
}
break;
}
}
}
} else {
altMonitor.wait ();
while (state == waiting) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.AlternativeSelect);
}
altMonitor.wait ();
}
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException (
"*** Thrown from Alternative.fairSelect/select (boolean[])\n" + e.toString ()
);
}
state = ready;
}
}
disableGuards (preCondition);
state = inactive;
favourite = selected + 1;
if (favourite == guard.length) favourite = 0;
timeout = false;
return selected;
}
/**
* Enables the guards for selection. The preCondition must be true for
* an guard to be selectable. If any of the guards are ready, it sets
* selected to the ready guard's index, state to ready and returns.
* Otherwise, it sets selected to NONE_SELECTED and returns.
*
*
* @return true if and only if one of the guards is ready
*/
private final void enableGuards (boolean[] preCondition) {
if (barrierPresent) {
AltingBarrierCoordinate.startEnable ();
}
barrierSelected = NONE_SELECTED;
for (enableIndex = favourite; enableIndex < guard.length; enableIndex++) {
if (preCondition[enableIndex] && guard[enableIndex].enable (this)) {
selected = enableIndex;
state = ready;
if (barrierTrigger) {
barrierSelected = selected;
barrierTrigger = false;
} else if (barrierPresent) {
AltingBarrierCoordinate.finishEnable ();
}
return;
}
}
for (enableIndex = 0; enableIndex < favourite; enableIndex++) {
if (preCondition[enableIndex] && guard[enableIndex].enable (this)) {
selected = enableIndex;
state = ready;
if (barrierTrigger) {
barrierSelected = selected;
barrierTrigger = false;
} else if (barrierPresent) {
AltingBarrierCoordinate.finishEnable ();
}
return;
}
}
selected = NONE_SELECTED;
if (barrierPresent) {
AltingBarrierCoordinate.finishEnable ();
}
}
/**
* Disables the guards for selection. The preCondition must be true for
* an guard to be selectable. Sets selected to the index of the ready guard,
* taking care of priority/fair choice.
*/
private void disableGuards (boolean[] preCondition) {
if (selected != favourite) { // else there is nothing to disable
int startIndex = (selected == NONE_SELECTED) ? favourite - 1: selected - 1;
if (startIndex < favourite) {
for (int i = startIndex; i >= 0; i--) {
if (preCondition[i] && guard[i].disable ()) {
selected = i;
if (barrierTrigger) {
if (barrierSelected != NONE_SELECTED) {
throw new JCSP_InternalError (
"*** Second AltingBarrier completed in ALT sequence: " +
barrierSelected + " and " + i
);
}
barrierSelected = selected;
barrierTrigger = false;
}
}
}
startIndex = guard.length - 1;
}
for (int i = startIndex; i >= favourite; i--) {
if (preCondition[i] && guard[i].disable ()) {
selected = i;
if (barrierTrigger) {
if (barrierSelected != NONE_SELECTED) {
throw new JCSP_InternalError (
"*** Second AltingBarrier completed in ALT sequence: " +
barrierSelected + " and " + i
);
}
barrierSelected = selected;
barrierTrigger = false;
}
}
}
if (selected == NONE_SELECTED) {
// System.out.println ("disableGuards: NONE_SELECTED ==> " + timeIndex);
// NOTE: this is a work-around for Java wait-with-timeouts sometimes
// returning early. If this did not happen, we would not get here!
selected = timeIndex;
}
}
if (barrierSelected != NONE_SELECTED) { // We must choose a barrier sync
selected = barrierSelected; // if one is ready - so that all
AltingBarrierCoordinate.finishDisable (); // parties make the same choice.
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/AltingChannelInputIntSymmetricImpl.java 0000644 0000000 0000000 00000005251 11105701167 023651 0 ustar
/*************************************************************************
* *
* JCSP ("CSP for Java") libraries *
* Copyright (C) 1996-2001 Peter Welch and Paul Austin. *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Lesser General Public *
* License as published by the Free Software Foundation; either *
* version 2.1 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the Free Software *
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, *
* USA. *
* *
* Author contact: P.H.Welch@kent.ac.uk *
* *
*************************************************************************/
package org.jcsp.lang;
class AltingChannelInputIntSymmetricImpl extends AltingChannelInputInt
implements MultiwaySynchronisation {
private final AltingBarrier ab;
private final ChannelInputInt in;
private boolean syncDone = false;
public AltingChannelInputIntSymmetricImpl (
AltingBarrier ab, ChannelInputInt in) {
this.ab = ab;
this.in = in;
}
boolean enable (Alternative alt) {
syncDone = ab.enable (alt);
return syncDone;
}
boolean disable () {
syncDone = ab.disable ();
return syncDone;
}
public int read () {
if (!syncDone) ab.sync ();
syncDone = false;
return in.read ();
}
public boolean pending () {
syncDone = ab.poll (10);
return syncDone;
}
public void poison(int strength) {
in.poison(strength);
}
public void endRead() {
in.endRead();
}
public int startRead() {
if (!syncDone) ab.sync();
syncDone = false;
return in.read();
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/AltingChannelInputInt.java 0000644 0000000 0000000 00000010045 11113671251 021126 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This extends {@link Guard} and {@link ChannelInputInt}
* to enable a process
* to choose between many integer input (and other) events.
*
* A reading-end, obtained from a one-one or any-one
* channel by invoking its in() method, will extend this abstract class.
* ProcessManager that this is called upon
* will remain at the specified priority once the process
* has terminated.
*
* The priority should be specified as an int between
* PRIORITY_MIN and PRIORITY_MAX.
*
* @param priority the priority at which to start the process.
*/
public void start(int priority)
{
thread.setPriority(priority);
start();
}
/**
* Stop (permanently) the managed process.
*
* This method now calls interrupt(), which will not always stop the process.
*
* @deprecated
*/
public void stop()
{
interrupt();
}
/**
* Interrupt the managed process. This will usually cause the process to throw a
* {@link ProcessInterruptedException}, which will likely halt the process.
*/
public void interrupt()
{
thread.interrupt();
}
/**
* Join the managed process (that is wait for it to terminate).
*/
public void join()
{
try
{
thread.join();
}
catch (InterruptedException e)
{
throw new ProcessInterruptedException("Joining process " + process);
}
}
/**
* blocking FIFOProcessManager and then return the priority to the
* previous value once the managed process has terminated.
* CSProcess object's run() method.
* ProcessManager object's
* process' priority.
* int between
* PRIORITY_MIN and PRIORITY_MAX.
* ProcessManager object's
* process' priority.
* ProcessManager object's
* process will be run.
*/
public int getPriority()
{
return thread.getPriority();
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/One2OneCallChannel.java 0000644 0000000 0000000 00000045104 11105701167 020263 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import java.io.Serializable;
/**
* This is the super-class for one-to-one interface-specific CALL channels.
* Description
* Normal method invocation between objects is sometimes refered to as message-passing
* between a client (the invoker of the method) object and a server object
* (the invoked). Information flows from the client (the method name and parameter values)
* to the server, which reacts in some way (possibly changing state) and may return
* information back to the client (via the method result or, indirectly, by changing values
* referenced by the method parameters).
* Converting a Method Interface into a Variant CALL Channel
* A CALL channel must be individually constructed to support a specific method
* interface. This is done by extending this class to implement that
* interface in the manner outlined below. The calling (i.e. client)
* process just sees that interface and invokes its methods. The callee
* (i.e. server) process just sees the {@link #accept accept} method
* of the CALL channel and invokes that (supplying itself as argument). Both actions
* are voluntary and have to occur for the communication to take place.
*
* interface Foo {
*
* public Bar calculate (...);
* public void processQuery (...);
* public boolean closeValve (...);
*
* }
*
*
* Deriving the corresponding CALL channel is mechanical and could easilly be automated:
*
* import org.jcsp.lang.*;
*
* public class One2OneFooChannel extends One2OneCallChannel implements Foo {
*
* public static final int CALCULATE = 0; // optional
* public static final int PROCESS_QUERY = 1; // optional
* public static final int CLOSE_VALVE = 2; // optional
*
* public Bar calculate (...) {
* join (); // ready to make the CALL
* Bar result = ((Foo) server).calculate (...);
* selected = CALCULATE; // optional
* fork (); // call finished
* return result;
* }
*
* public void processQuery (...) {
* join (); // ready to make the CALL
* ((Foo) server).processQuery (...);
* selected = PROCESS_QUERY; // optional
* fork (); // call finished
* }
*
* public boolean closeValve (...) {
* join (); // ready to make the CALL
* boolean result = ((Foo) server).closeValve (...);
* selected = CLOSE_VALVE; // optional
* fork (); // call finished
* return result;
* }
*
* }
*
* The above methods will be called by the client process.
* The {@link #join join} will not complete until the server invokes
* an {@link #accept accept} on this channel.
* That accept will not complete until the client reaches
* the {@link #fork fork}. This gives the zero-buffered fully synchronised
* semantics of CSP channel communication.
* Calling a CALL Channel
* All the client needs to see is the method interface
* implemented by the CALL channel. For example:
*
* import org.jcsp.lang.*;
*
* public class A implements CSProcess {
*
* private final Foo out;
*
* public A (final Foo out) {
* this.out = out;
* }
*
* public void run () {
* ...
* Bar t = out.calculate (...);
* ...
* out.processQuery (...);
* ...
* if (! out.closeValve (...)) ...;
* ...
* }
*
* }
*
* [Note: this means, of course, that a client is blind to the variety of CALL channel
* it is calling. It may be connected to its server(s) via a 1-1, Any-1,
* 1-Any or Any-Any link without any change in its coding.]
*
* Accepting a CALL Channel
* To receive the calls forwarded by the CALL channel, the server needs to implement
* the same interface. To accept a call, it invokes the
* {@link #accept accept} method of the CALL channel, passing itself (usually
* this) as the argument. All it needs to see, therefore, is
* the {@link ChannelAccept} interface implemented by the channel. For example:
*
* import org.jcsp.lang.*;
*
* class B implements CSProcess, Foo {
*
* private final ChannelAccept in;
*
* public B (final One2OneFooChannel in) {
* this.in = in;
* }
*
* ... other fields, methods etc.
*
* ... implementation of Foo methods
*
* public void run () { // controls when Foo invocations are acceptable
* ...
* in.accept (this); // don't care which method was called
* ...
* switch (in.accept (this)) { // care which method was called
* case One2OneFooChannel.CALCULATE:
* ...
* break;
* case One2OneFooChannel.PROCESS_QUERY:
* ...
* break;
* case One2OneFooChannel.CLOSE_VALVE:
* ...
* break;
* }]
* ...
* in.accept (this); // don't care which method was called
* ...
* }
*
* }
*
* However, it is not very secure for a server process (like B) to advertise
* a standard method interface (like Foo). In the above example, there is
* the danger that someone might try to invoke one of the Foo methods
* directly on an instance of B (e.g. by plugging an instance of B,
* instead of the CALL channel, into an instance of A).
* That would not be a good idea!
*
* import org.jcsp.lang.*;
*
* public class B2 implements CSProcess { // no Foo interface
*
* private final B b;
*
* public B2 (final One2OneFooChannel in) {
* b = new B (in);
* }
*
* public void run () {
* b.run ();
* }
*
* }
*
* Notice that this wrapper imposes no run-time overhead, apart from a small start-up cost.
* The hidden inner process does all the work and has direct access to the CALL
* channel and, hence, to the client.
* ALTing on a CALL Channel
* This class is a sub-class of {@link Guard} and, therefore, its derived CALL channels
* may be included in a Guard array associated with an {@link Alternative}.
* Hence, the server may ALT between any mixture of CALL channels, ordinary
* channels, {@link CSTimer timeouts} and {@link Skip Skips}.
*
* private final AltingChannelAccept in;
*
* See Any2OneCallChannel for an example of ALTing between CALL channels.
* Building a CALL Channel Network
* Network building with CALL channels is the same as building with ordinary
* channels. First construct the channels and, then, construct the processes
* - plugging in the channels as required and running them in {@link Parallel}.
* 
* One2OneFooChannel c = new One2OneFooChannel ();
*
* new Parallel (
* new CSProcess[] {
* new A (c),
* new B2 (c)
* }
* ).run ();
*
* Example
* Please see Any2OneCallChannel for an example that includes one server,
* ALTing between two (Any-1) CALL channels, and lots of clients.
*
* @see org.jcsp.lang.Any2OneCallChannel
* @see org.jcsp.lang.One2AnyCallChannel
* @see org.jcsp.lang.Any2AnyCallChannel
* @see org.jcsp.lang.Alternative
*
* @author P.H. Welch
*/
public abstract class One2OneCallChannel extends AltingChannelAccept implements Serializable
{
/**
* This is used to synchronise the calling and accepting process.
*/
final private One2OneChannelImpl c = new One2OneChannelImpl();
/**
* This holds a reference to a server process so that a client may
* make the call. The reference is only valid between the {@link #join join}
* and {@link #fork fork} elements of the standard
* calling sequence.
* As shown in that sequence, it will need casting up to the relevant interface
* supported by the specific CALL channel derived from this class.
*/
protected CSProcess server;
/**
* This may be set during the standard calling sequence to record
* which method was invoked by a client. It is only safe to do this between
* the {@link #join join} and {@link #fork fork} elements of
* that sequence. Either all the CALL
* channel methods should do this or none - in the latter case, its default
* value remains as zero. Its value is returned to a server as the result
* the server's invocation of {@link #accept accept}.
*/
protected int selected = 0;
/**
* This is invoked by a server when it commits to accepting a CALL
* from a client. The parameter supplied must be a reference to this server
* - see the example above. It will not complete until a CALL
* has been made. If the derived CALL channel has set the {@link #selected} field
* in the way defined by the standard calling sequence,
* the value returned by this method will indicate which method was called.
*
* @param server the server process receiving the CALL.
*/
public int accept(CSProcess server)
{
this.server = server;
c.read(); // ready to ACCEPT the CALL
c.read(); // wait until the CALL is complete
return selected;
}
/**
* This is invoked by a client during the standard calling
* sequence. It will not complete until a server invokes
* an {@link #accept accept} on this channel. In turn, that accept
* will not complete until the client invokes a {@link #fork fork},
* after having made its CALL on the server.
*/
protected void join()
{
c.write(null);
}
/**
* This is invoked by a client during the standard calling
* sequence. A server must have invoked an {@link #accept accept}
* for the client to have got this far in the sequence - see
* the {@link #join join}. This call unblocks that accept,
* releasing the server and client to resume separate lives.
*/
protected void fork()
{
c.write(null);
}
/**
* This is one of the {@link Guard} methods needed by the {@link Alternative} class.
*/
boolean enable(Alternative alt)
{
return c.readerEnable(alt);
}
/**
* This is one of the {@link Guard} methods needed by the {@link Alternative} class.
*/
boolean disable()
{
return c.readerDisable();
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Any2OneChannelIntImpl.java 0000644 0000000 0000000 00000005106 11105701167 020770 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This implements an any-to-one integer channel,
* safe for use by many writers and one reader.Refer to the {@link Any2OneChannelInt} interface for
* a fuller description.
*
* @see org.jcsp.lang.One2OneChannelIntImpl
* @see org.jcsp.lang.One2AnyChannelIntImpl
* @see org.jcsp.lang.Any2AnyChannelIntImpl
* @see org.jcsp.util.ints.ChannelDataStoreInt
*
* @author P.D. Austin and P.H. Welch
*/
class Any2OneChannelIntImpl extends Any2OneIntImpl
{
Any2OneChannelIntImpl() {
super(new One2OneChannelIntImpl());
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/MultiwaySynchronisation.java 0000644 0000000 0000000 00000003773 11113671251 021664 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
interface MultiwaySynchronisation {}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/RejectableAltingChannelInputImpl.java 0000644 0000000 0000000 00000005502 11113671251 023260 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
class RejectableAltingChannelInputImpl extends RejectableAltingChannelInput {
private ChannelInternals channel;
private int immunity;
RejectableAltingChannelInputImpl(ChannelInternals _channel, int _immunity) {
channel = _channel;
immunity = _immunity;
}
public boolean pending() {
return channel.readerPending();
}
boolean disable() {
return channel.readerDisable();
}
boolean enable(Alternative alt) {
return channel.readerEnable(alt);
}
public void endRead() {
channel.endRead();
}
public Object read() {
return channel.read();
}
public Object startRead() {
return channel.startRead();
}
public void poison(int strength) {
if (strength > immunity) {
channel.readerPoison(strength);
}
}
public void reject()
{
channel.readerPoison(Integer.MAX_VALUE);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/BlackHoleChannel.java 0000644 0000000 0000000 00000006614 11105701167 020051 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This implements {@link ChannelOutput} with black hole semantics.
* Description
* BlackHoleChannel is an implementation of {@link ChannelOutput} that yields
* black hole semantics for the channel. Writers may always write but there can be
* no readers. Any number of writers may share the same black hole.
* Processes, Networks and Synchronisation
In JCSP, a process is an instance of a class implementing the
{@link org.jcsp.lang.CSProcess} interface - its behaviour being determined
by the implementation of its run() method. Processes may be composed
in {@link org.jcsp.lang.Sequence} or {@link org.jcsp.lang.Parallel} (or {@link org.jcsp.lang.PriParallel}),
the result of this composition being another process. Processes may also be spawned
to run concurrently with the spawning process - see {@link org.jcsp.lang.ProcessManager}.
A collection of parallel processes is called a network.
Channels
Channels come in two varieties: those that carry Object references and
those that carry ints. For completeness, JCSP should provide channels
specific to all the Java primitive types. These could trivially be added but,
so far, do not seem to be needed in practice.
Specialised channels, using Java generics, are easy to add and will be done
soon – please mail us if you have urgent need.
Channels (from the Point of View of a Process)
Processes should drive their channels through channel ends:
{@link org.jcsp.lang.ChannelInput} / {@link org.jcsp.lang.ChannelOutput} (for Object channels)
and {@link org.jcsp.lang.ChannelInputInt} / {@link org.jcsp.lang.ChannelOutputInt} (for int channels).
To allow choice of receiving input (see next paragraph), processes must drive
their channels through {@link org.jcsp.lang.AltingChannelInput} / {@link org.jcsp.lang.AltingChannelInputInt}
(rather than {@link org.jcsp.lang.ChannelInput} / {@link org.jcsp.lang.ChannelInputInt}).
Channels (from the Point of View of a Network)
Actual channels must be constructed by the {@link org.jcsp.lang.Parallel} network builder
with appropriate channel ends passed to the processes needing them (usually via their constructors).
Four varieties are available for Object channels:
{@link org.jcsp.lang.One2OneChannel}, {@link org.jcsp.lang.Any2OneChannel},
{@link org.jcsp.lang.One2AnyChannel} and {@link org.jcsp.lang.Any2AnyChannel}.
Similarly, four varieties are available for int channels:
{@link org.jcsp.lang.One2OneChannelInt}, {@link org.jcsp.lang.Any2OneChannelInt},
{@link org.jcsp.lang.One2AnyChannelInt} and {@link org.jcsp.lang.Any2AnyChannelInt}.
Please note that the last two in each set are not broadcasting channels
- broadcasting has to be achieved by active processes (e.g. {@link org.jcsp.plugNplay.Delta}).
Channels are constructed by the static manufacturing methods of
the {@link org.jcsp.lang.Channel} class.
Input and output channel ends are obtained from channels by their in() and out
methods, respectively.
},
{@link org.jcsp.util.OverWriteOldestBuffer overwriting (oldest) FIFO},
{@link org.jcsp.util.OverWritingBuffer overwriting (latest) FIFO} and
{@link org.jcsp.util.InfiniteBuffer infinite FIFO}.
That set of plug-ins is for Object channels and comes from
the {@link org.jcsp.util} package.
A similar set for int channels is provided in {@link org.jcsp.util.ints}.
Call Channels
Call Channels provide a method interface for client-server communication between active
processes, yet their semantics remain those of a synchronising zero-buffered channel.
Without them, we would normally have to set up a pair of channels (giving bi-directional
communication) and use a sequence of channel write(s) and read (at the client end)
matched by a sequence of channel read(s) and write (at the server end).
Symmetric Channels
Thanks to alting barriers ({@link org.jcsp.lang.AltingBarrier}),
symmetric channels are now available:
{@link org.jcsp.lang.One2OneChannelSymmetric} and {@link org.jcsp.lang.One2OneChannelSymmetricInt}.
These work the same as ordinary channels but, in addition, their output ends
can be used as guards in a choice ({@link org.jcsp.lang.Alternative}).
It is quite safe for both the sending and receiving process to be alting
on these symmetric channels.
jcsp-1.1-rc4.orig/src/org/jcsp/lang/SharedConnectionServerImpl.java 0000644 0000000 0000000 00000007440 11105701167 022171 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This class does not need to be used by standard JCSP users. It is exposed so that the connection
* mechanism can be extended for custom connections.
*
* @author Quickstone Technologies Limited
*/
public class SharedConnectionServerImpl implements SharedConnectionServer
{
private AltingConnectionServerImpl connectionServerToUse;
private ChannelInput synchIn;
private ChannelOutput synchOut;
private ConnectionWithSharedAltingServer parent;
protected SharedConnectionServerImpl(AltingChannelInput openIn,
AltingChannelInput requestIn,
ChannelInput synchIn,
SharedChannelOutput synchOut,
ConnectionWithSharedAltingServer parent)
{
connectionServerToUse = new AltingConnectionServerImpl(openIn, requestIn);
this.synchOut = synchOut;
this.synchIn = synchIn;
this.parent = parent;
}
public Object request()
{
if (connectionServerToUse.getServerState() == AltingConnectionServerImpl.SERVER_STATE_CLOSED)
synchOut.write(null);
return connectionServerToUse.request();
}
public void reply(Object data)
{
reply(data, false);
}
public void reply(Object data, boolean close)
{
connectionServerToUse.reply(data, close);
if (connectionServerToUse.getServerState() == AltingConnectionServerImpl.SERVER_STATE_CLOSED)
synchIn.read();
}
public void replyAndClose(Object data)
{
reply(data, true);
}
public SharedConnectionServer duplicate()
{
return parent.server();
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelInternals.java 0000644 0000000 0000000 00000004732 11113671251 020162 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
interface ChannelInternals {
public Object read();
public void write(Object obj);
public Object startRead();
public void endRead();
public boolean readerEnable(Alternative alt);
public boolean readerDisable();
public boolean readerPending();
/*//For Symmetric channel, later:
public boolean writerEnable(Alternative alt);
public boolean writerDisable();
public boolean writerPending();
*/
public void readerPoison(int strength);
public void writerPoison(int strength);
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Sequence.java 0000644 0000000 0000000 00000051105 11105701167 016477 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This constructor taks an array of CSProcesses
* and returns a CSProcess that is the sequential composition of
* its process arguments.
* Description
* The Sequence constructor taks an array of CSProcesses
* and returns a CSProcess that is
* the sequential composition of its process arguments.
* Example - Matrix Multiply (in Sequence and in Parallel)
* Sequential Implementation
* The example is simple matrix multiplication. The standard implementation
* consists of three nested for-loops, the innermost of which computes
* the dot-product of a row (of the first matrix) against a column (of
* the second) to produce one element of the result matrix. It is expressed
* here as a static method, which would belong to some larger collection of
* static methods providing a general matrix handling class:
*
* public static void multiply (final double[][] X,
* final double[][] Y,
* final double[][] Z) {
*
* ... check (X[0].length == Y.length)
* ... check (X.length == Z.length)
* ... check (Y[0].length == Z[0].length)
*
* for (int i = 0; i < X.length; i++) {
* final double[] Xi = X[i];
* final double[] Zi = Z[i];
* for (int j = 0; j < Y[0].length; j++) {
* double sum = 0.0d;
* for (int k = 0; k < Y.length; k++) {
* sum += Xi[k]*Y[k][j];
* }
* Zi[j] = sum;
* }
* }
*
* }
*
* The method computes the matrix multiplication of X by Y,
* leaving the result in Z.
* The (hidden) checks ensure that the supplied arrays have compatible
* dimensions for multiplication, throwing
* a {@link java.lang.RuntimeException java.lang.RuntimeException}
* if they are not.
* The abbreviations Xi and Zi are not strictly
* necessary, but for those brought up in an occam world are automatic
* good practice - the Xi[k] reference
* in the O(n3)-innermost loop saves
* an array index computation and check.
*
* Parallel Implementation
* The two outer for-loops of multiply
* set up the particular row and column
* pairs for the dot-product computed by the innermost loop.
* Unnecessarilly, they impose an ordering in which those dot-products
* are computed. Each dot-product computes one element of the result
* matrix and is independent of its sibling dot-products.
* The sequential constraint may, therefore, be removed and all elements
* of the result matrix may be computed in parallel.
*
* public static void parMultiply (final double[][] X,
* final double[][] Y,
* final double[][] Z) {
*
* ... check array dimensions are compatible
*
* final CSProcess[] rowProcess = new CSProcess[X.length];
*
* for (int i = 0; i < X.length; i++) {
* final int ii = i;
* rowProcess[ii] = new CSProcess () {
* public void run () {
* final double[] Xi = X[ii];
* final double[] Zi = Z[ii];
* final double[][] YY = Y;
* for (int j = 0; j < YY[0].length; j++) {
* double sum = 0.0d;
* for (int k = 0; k < YY.length; k++) {
* sum += Xi[k]*YY[k][j];
* }
* Zi[j] = sum;
* }
* }
* };
* }
*
* new Parallel (rowProcess).run ();
*
* }
*
* [Note: anonymous inner classes, as in the above code, may only access
* global variables that are qualified as final - hence, the need
* to freeze the loop control index, i, as ii.
* The abreviation YY, of Y, is so that access to that matrix
* is via a variable local to the process. The global Y
* could have been used, but at the cost of needless run-time overhead.]
*
* Back to Sequential Implementation
* Having expressed this algorithm in terms of processes, we come to the
* motivation for this example. To run a collection of processes, we must decide
* whether to run them is parallel or sequence. JCSP makes either
* decision equally easy to implement. The above coding ran them in parallel.
* To revert to running them is sequence, all we need do is change the last line
* of executable code to:
*
* new Sequence (rowProcess).run ();
*
* It would probably be good to name this new method seqMultiply (instead
* or parMultiply!).
* Of course, it has the same behaviour as the original sequential multiply and
* suffers only slightly increased overheads - negligible for matrices above a modest size.
*
* Sequence versus Parallel
* Beware that it is only in certain circumstances that Sequence and Parallel
* can be interchanged without upsetting the semantics of the system. The processes under
* their control must be finite (i.e. they must all terminate), they must engage in
* no synchronisations (e.g. channel communication) either between themselves or with
* other processes and they must obey CREW-parallel usage rules (i.e. if one process
* updates some data, no other process may look at it). These are fulfilled by
* the rowProcess array, each of whose processes computes a separate row
* (Zi) of the target result matrix (Z).
*
* Exercise
* The above parMultiply has transformed only the outermost
* for-loop of multiply into a par-loop. Current SMPs
* do not scale well above 4 or 8 processors, so we do not need very large matrices
* for this code to demonstrate high parallel efficiencies. Future architectures,
* however, may offer much higher levels of physical concurrency that efficiently
* support much finer granularities of process. For those machines and as an interesting
* exercise, parallelise the middle for-loop. To exploit even finer levels
* of parallel granularity, parallelise the innermost for-loop so that it
* computes its dot-product in O(log(n)) time - rather than the O(n) time of
* the sequential code.
*
* Two Important Modifications on parMultiply
* The first time it is run, the JCSP {@link org.jcsp.lang.Parallel} process
* creates a new {@link java.lang.Thread} for all but one of its component processes,
* running its last component in the thread invoking the run.
* When (and if) all those component processes terminate, the Parallel
* run terminates but leaves the newly created threads parked for later use.
* Subsequent runs of the Parallel process resuse those parked threads.
* So the overhead of thread creation occurs only for the first run.
*
* final Parallel par = new Parallel (rowProcess);
* par.run ();
* par.releaseAllThreads ();
*
*
* The second way to improve things is to save the Parallel process for later
* runs. There is no easy way for doing this local to the class to which
* parMultiply belongs. parMultiply is static and may be
* invoked with matrix parameters of different dimensions. So, a static data
* structure would need to be set up and consulted each time parMultiply was
* invoked to see if a suitable Parallel process had already been saved.
*
* public static Parallel makeParMultiply (final double[][] X,
* final double[][] Y,
* final double[][] Z) {
*
* ... check array dimensions are compatible // as before
*
* final CSProcess[] rowProcess = new CSProcess[X.length]; // as before
*
* for (int i = 0; i < X.length; i++) { // as before
* final int ii = i; // as before
* rowProcess[ii] = new CSProcess () { // as before
* public void run () { // as before
* final double[] Xi = X[ii]; // as before
* final double[] Zi = Z[ii]; // as before
* final double[][] YY = Y; // as before
* for (int j = 0; j < YY[0].length; j++) { // as before
* double sum = 0.0d; // as before
* for (int k = 0; k < YY.length; k++) { // as before
* sum += Xi[k]*YY[k][j]; // as before
* } // as before
* Zi[j] = sum; // as before
* } // as before
* } // as before
* }; // as before
* } // as before
*
* return new Parallel (rowProcess);
*
* }
*
* The invoker of makeParMultiply gets back a parallel process that can be
* invoked as often as needed and incurs a thread creation overhead only on its first use.
* The data for the matrix parameters may be freely changed between invocations - each
* invocation will work on whatever data is present at the time. All the user must
* remember is that the manufactured parallel process is good only for working with
* the matrix objects specified originally to makeParMultiply as its parameters.
* For example, if Matrix is the class to which makeParMultiply belongs:
*
* final Parallel par = Matrix.makeParMultiply (X, Y, Z);
*
* while (...) {
* ... set up matrices X and Y
* par.run ();
* ... do something with the result matrix Z
* }
*
* par.releaseAllThreads ();
*
*
*
* @see org.jcsp.lang.CSProcess
* @see org.jcsp.lang.Parallel
*
* @author P.D. Austin
* @author P.H. Welch
*/
public class Sequence implements CSProcess
{
/** The processes to be executed in sequence */
private CSProcess[] processes;
/** The number of processes in this Sequence */
private int nProcesses = 0;
// invariant : (0 <= nProcesses <= processes.length)
/**
* Construct a new Sequence object initially without any processes.
*/
public Sequence()
{
this(null);
}
/**
* Construct a new Sequence object with the processes specified.
*
* @param processes the processes to be executed in sequence
*/
public Sequence(CSProcess[] processes)
{
if (processes != null)
{
nProcesses = processes.length;
this.processes = new CSProcess[nProcesses];
System.arraycopy(processes, 0, this.processes, 0, nProcesses);
}
else
{
nProcesses = 0;
this.processes = new CSProcess[0];
}
}
/**
* Add the process to the Sequence object.
* The extended network
* will be executed the next time run() is invoked.
*
* @param process The CSProcess to be added
*/
public synchronized void addProcess(CSProcess process)
{
if (process != null)
{
final int targetProcesses = nProcesses + 1;
if (targetProcesses > processes.length)
{
final CSProcess[] tmp = processes;
processes = new CSProcess[2 * targetProcesses];
System.arraycopy(tmp, 0, processes, 0, nProcesses);
}
processes[nProcesses] = process;
nProcesses = targetProcesses;
}
}
/**
* Add the array of processes to the Sequence object.
* The extended network
* will be executed the next time run() is invoked.
*
* @param newProcesses the processes to be added
*/
public synchronized void addProcess(CSProcess[] newProcesses)
{
if (processes != null)
{
final int extra = newProcesses.length;
final int targetProcesses = nProcesses + extra;
if (targetProcesses > processes.length)
{
final CSProcess[] tmp = processes;
processes = new CSProcess[2 * targetProcesses];
System.arraycopy(tmp, 0, processes, 0, nProcesses);
}
System.arraycopy(newProcesses, 0, processes, nProcesses, extra);
nProcesses = targetProcesses;
}
}
/**
* Remove a process from the Sequence object. The cut-down network
* will be executed the next time run() is invoked.
*
* @param process the process to be removed
*/
public synchronized void removeProcess(CSProcess process)
{
for (int i = 0; i < nProcesses; i++)
{
if (processes[i] == process)
{
if (i < nProcesses - 1)
System.arraycopy(processes, i + 1, processes, i, nProcesses - (i + 1));
nProcesses--;
processes[nProcesses] = null;
return;
}
}
}
/**
* Remove all processes from the Sequence object. The cut-down network
* will not be executed until the next time run() is invoked.
*/
public synchronized void removeAllProcesses()
{
for (int i = 0; i < nProcesses; i++)
processes[i] = null;
nProcesses = 0;
}
/**
* Run the sequential composition of the processes registered with this
* Sequence object.
*/
public void run()
{
for (int i = 0; i < nProcesses; i++)
processes[i].run();
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Any2AnyChannelIntImpl.java 0000644 0000000 0000000 00000005010 11105701167 020770 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This implements an any-to-any integer channel,
* safe for use by many writers and many readers. Refer to the {@link Any2AnyChannelInt} interface
* for more details.
*
* @see org.jcsp.lang.One2OneChannelImpl
* @see org.jcsp.lang.Any2OneChannelImpl
* @see org.jcsp.lang.One2AnyChannelImpl
*
* @author P.D. Austin and P.H. Welch
*/
class Any2AnyChannelIntImpl extends Any2AnyIntImpl
{
Any2AnyChannelIntImpl() {
super(new One2OneChannelIntImpl());
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/BufferedOne2AnyChannelIntImpl.java 0000644 0000000 0000000 00000011610 11105701167 022430 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.ints.*;
/**
* This implements a one-to-any integer channel with user-definable buffering,
* safe for use by many writers and many readers.
* Description
* BufferedOne2AnyChannelIntImpl implements a one-to-any integer channel with
* user-definable buffering. It is safe for use by any number of reading
* processes but ony one writer. Reading processes compete with each other
* to use the channel. Only one reader and the writer will actually be using
* the channel at any one time. This is taken care of by
* BufferedOne2AnyChannelIntImpl -- user processes just read from or write to it.
* Implementation Note and Caution
* Fair servicing of readers to this channel depends on the fair
* servicing of requests to enter a synchronized block (or method) by
* the underlying Java Virtual Machine (JVM). Java does not specify how threads
* waiting to synchronize should be handled. Currently, Sun's standard JDKs queue
* these requests - which is fair. However, there is at least one JVM
* that puts such competing requests on a stack - which is legal but unfair
* and can lead to infinite starvation. This is a problem for any Java system
* relying on good behaviour from synchronized, not just for these
* 1-any channels.
*
* @see org.jcsp.lang.BufferedOne2OneChannelIntImpl
* @see org.jcsp.lang.BufferedOne2AnyChannelIntImpl
* @see org.jcsp.lang.BufferedAny2AnyChannelIntImpl
* @see org.jcsp.util.ints.ChannelDataStoreInt
*
* @author P.D. Austin
* @author P.H. Welch
*/
class BufferedOne2AnyChannelIntImpl extends One2AnyIntImpl
{
public BufferedOne2AnyChannelIntImpl(ChannelDataStoreInt data)
{
super(new BufferedOne2OneChannelIntImpl(data));
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Poisonable.java 0000644 0000000 0000000 00000011436 11113671251 017024 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* All channel-ends implement this inteface.
* Description
* BufferedOne2OneChannel implements a one-to-one object channel with
* user-definable buffering. Multiple readers or multiple writers are
* not allowed -- these are catered for by {@link BufferedAny2OneChannel},
* {@link BufferedOne2AnyChannel} or {@link BufferedAny2AnyChannel}.
*
* if (c.pending ()) {
* Object x = c.read ();
* ... do something with x
* } else (
* ... do something else
* }
*
* is equivalent to:
*
* if (c_pending.priSelect () == 0) {
* Object x = c.read ();
* ... do something with x
* } else (
* ... do something else
* }
*
* where earlier would have had to have been declared:
*
* final Alternative c_pending =
* new Alternative (new Guard[] {c, new Skip ()});
*
*
* @return state of the channel.
*/
public boolean readerPending () {
synchronized (rwMonitor) {
return (data.getState () != ChannelDataStore.EMPTY) || isPoisoned();
}
}
/**
* Returns the AltingChannelInput to use for this channel.
* As BufferedOne2OneChannel implements
* AltingChannelInput itself, this method simply returns
* a reference to the object that it is called on.
*
* @return the AltingChannelInput object to use for this
* channel.
*/
public AltingChannelInput in()
{
return new AltingChannelInputImpl(this,immunity);
}
/**
* Returns the ChannelOutput object to use for this channel.
* As BufferedOne2OneChannel implements
* ChannelOutput itself, this method simply returns
* a reference to the object that it is called on.
*
* @return the ChannelOutput object to use for this
* channel.
*/
public ChannelOutput out()
{
return new ChannelOutputImpl(this,immunity);
}
public void writerPoison(int strength) {
if (strength > 0) {
synchronized (rwMonitor) {
this.poisonStrength = strength;
//Poison by writer does *NOT* clear the buffer
rwMonitor.notifyAll();
if (null != alt) {
alt.schedule();
}
}
}
}
public void readerPoison(int strength) {
if (strength > 0) {
synchronized (rwMonitor) {
this.poisonStrength = strength;
//Poison by reader clears the buffer:
data.removeAll();
rwMonitor.notifyAll();
}
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Any2AnyChannelImpl.java 0000644 0000000 0000000 00000004770 11105701167 020331 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This implements an any-to-any object channel,
* safe for use by many writers and many readers. Refer to the {@link Any2AnyChannel} interface
* for more details.
*
* @see org.jcsp.lang.One2OneChannelImpl
* @see org.jcsp.lang.Any2OneChannelImpl
* @see org.jcsp.lang.One2AnyChannelImpl
*
* @author P.D. Austin and P.H. Welch
*/
class Any2AnyChannelImpl extends Any2AnyImpl
{
Any2AnyChannelImpl() {
super(new One2OneChannelImpl());
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/ProcessInterruptedException.java 0000644 0000000 0000000 00000006140 11105701167 022451 0 ustar
/*************************************************************************
* *
* JCSP ("CSP for Java") libraries *
* Copyright (C) 1996-2008 Peter Welch and Paul Austin. *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Lesser General Public *
* License as published by the Free Software Foundation; either *
* version 2.1 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the Free Software *
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, *
* USA. *
* *
* Author contact: P.H.Welch@kent.ac.uk *
* *
*************************************************************************/
package org.jcsp.lang;
//{{{ javadoc
/**
* This is thrown if a process is interrupted whilst blocked during synchronisation
* - processes should never be interrupted.
*
* Description
* This is caused by accessing the Java thread executing a JCSP process and invoking its
* java.lang.Thread.interrupt() method.
* If this is done to a process blocked on a JCSP synchronisation primitive (such as
* a channel communication or timeout), the process will wake up prematurely
* -- invalidating the semantics of that primitive.
* The wake up is intercepted and this {@link java.lang.Error} is thrown.
* read) or
* reject data offered by the writer.
*
* @author Quickstone Technologies Limited
*
* @deprecated This channel is superceded by the poison mechanisms, please see {@link PoisonException}. It remains only because it is used by some of the networking features.
*/
public interface RejectableChannel
{
public RejectableChannelInput in();
public RejectableChannelOutput out();
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/One2AnyConnection.java 0000644 0000000 0000000 00000005025 11105701167 020222 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* An interface for a connection which can be used by only one client but which can be used by multiple
* concurrent servers.
*
* @author Quickstone Technologies Limited
*/
public interface One2AnyConnection extends ConnectionWithSharedAltingServer
{
/**
* Returns the client part of the connection.
*/
public AltingConnectionClient client();
/**
* Returns the server part of the connection.
*/
public SharedConnectionServer server();
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Alternative.java 0000644 0000000 0000000 00000136153 11113671251 017213 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
//{{{ javadoc
/**
* This enables a process to wait passively for and choose
* between a number of {@link Guard} events.
* Description
* The Alternative class enables a CSProcess to wait passively for and
* choose between a number of {@link Guard} events. This is known as
* ALTing.
* ALT and
* PRI ALT constructs, extended with a built-in implementation
* of the classical FAIR ALT.
* Alternative constructor takes an array of guards. Processes
* that need to Alt over more than one set of guards will need a separate
* Alternative instance for each set.
* Guard are provided in jcsp.lang:
*
*
* Alternative object
* to become ready. The methods differ in the way they choose which guard
* to select in the case when two or more guards are ready:
*
*
* select} waits for one or more of the guards
* to become ready. If more than one become ready, it makes an
* arbitrary choice between them (and corresponds to the
* occam ALT).
* priSelect} also waits for one or more of
* the guards to become ready. However, if more than one becomes ready,
* it chooses the first one listed (and corresponds to the
* occam PRI ALT). Note: the use of
* priSelect between channel inputs and a skip guard (at lowest
* priority) gives us a polling operation on the readiness
* of those channels.
* fairSelect} also waits for one or more
* of the guards to become ready. If more than one become ready, it
* prioritises its choice so that the guard it chose the last time
* it was invoked has lowest priority this time. This corresponds
* to a common occam idiom used for real-time applications.
* If fairSelect is used
* in a loop, a ready guard has the guarantee that no other guard will be
* serviced twice before it will be serviced. This enables
* an upper bound on service times to be calculated and ensures that no
* ready guard can be indefinitely starved.
* Examples
* A Fair Multiplexor
* This example demonstrates a process that fairly multiplexes traffic
* from its array of input channels to its single output channel. No input
* channel will be starved, regardless of the eagerness of its competitors.
*
* import org.jcsp.lang.*;
*
* public class FairPlex implements CSProcess {
*
* private final AltingChannelInput[] in;
* private final ChannelOutput out;
*
* public FairPlex (final AltingChannelInput[] in, final ChannelOutput out) {
* this.in = in;
* this.out = out;
* }
*
* public void run () {
*
* final Alternative alt = new Alternative (in);
*
* while (true) {
* final int index = alt.fairSelect ();
* out.write (in[index].read ());
* }
*
* }
*
* }
*
* Note that if priSelect were used above, higher-indexed channels would be
* starved if lower-indexed channels were continually demanding service.
* If select were used, no starvation analysis is possible.
* The select mechanism should only be used when starvation is not an issue.
*
* A Fair Multiplexor with a Timeout and Poisoning
* This example demonstrates a process that fairly multiplexes traffic
* from its input channels to its single output channel, but which timeouts
* after a user-settable time. Whilst running, no input channel
* will be starved, regardless of the eagerness of its competitors.
* The process also illustrates the poisoning of channels, following the timeout.
*
* import org.jcsp.lang.*;
*
* public class FairPlexTime implements CSProcess {
*
* private final AltingChannelInput[] in;
* private final ChannelOutput out;
* private final long timeout;
*
* public FairPlexTime (final AltingChannelInput[] in, final ChannelOutput out,
* final long timeout) {
* this.in = in;
* this.out = out;
* this.timeout = timeout;
* }
*
* public void run () {
*
* final Guard[] guards = new Guard[in.length + 1];
* System.arraycopy (in, 0, guards, 0, in.length);
*
* final CSTimer tim = new CSTimer ();
* final int timerIndex = in.length;
* guards[timerIndex] = tim;
*
* final Alternative alt = new Alternative (guards);
*
* boolean running = true;
* tim.setAlarm (tim.read () + timeout);
* while (running) {
* final int index = alt.fairSelect ();
* if (index == timerIndex) {
* running = false;
* } else {
* out.write (in[index].read ());
* }
* }
* System.out.println ("\n\r\tFairPlexTime: timed out ... poisoning all channels ...");
* for (int i = 0; i < in.length; i++) {
* in[i].poison (42); // assume: channel immunity < 42
* }
* out.poison (42); // assume: channel immunity < 42
*
* }
*
* }
*
* Note that if priSelect were used above, higher-indexed guards would be
* starved if lower-indexed guards were continually demanding service -- and
* the timeout would never be noticed.
* If select were used, no starvation analysis is possible.
* priSelect to impose a specific
* (as opposed to fair) choice that overcomes the external scheduling of events.
* For example, if we were concerned that the timeout above should
* be responded to immediately and unconcerned about the fair servicing of its
* channels, we should put its CSTimer as the first element of its Guard
* array and use priSelect.
* FairPlexTime, consider:
*
* import org.jcsp.lang.*;
* import org.jcsp.plugNplay.*;
*
* class FairPlexTimeTest {
*
* public static void main (String[] args) {
*
* final One2OneChannel[] a = Channel.one2OneArray (5, 0); // poisonable channels (zero immunity)
* final One2OneChannel b = Channel.one2One (0); // poisonable channels (zero immunity)
*
* final long timeout = 5000; // 5 seconds
*
* new Parallel (
* new CSProcess[] {
* new Generate (a[0].out (), 0),
* new Generate (a[1].out (), 1),
* new Generate (a[2].out (), 2),
* new Generate (a[3].out (), 3),
* new Generate (a[4].out (), 4),
* new FairPlexTime (Channel.getInputArray (a), b.out (), timeout),
* new Printer (b.in (), "FairPlexTimeTest ==> ", "\n")
* }
* ).run ();
*
* }
*
* }
*
* where {@link org.jcsp.plugNplay.Generate} sends its given Integer down its output channel
* as often as it can.
* This results in continuous demands on FairPlexTime by all its clients
* and demonstrates its fair servicing of those demands.
*
* public void run() {
* try {
* while (true) {
* out.write (N);
* }
* } catch (PoisonException p) {
* // the 'out' channel must have been posioned ... nothing left to do!
* }
* }
*
* In general, there will be things to do – especially if there is more
* than one channel.
* For example, here is the catch block at the end of the run()
* method for {@link org.jcsp.plugNplay.Delta} (which has a single input channel-end,
* in, and an array of output channel-ends, out):
*
* } catch (PoisonException p) {
* // don't know which channel was posioned ... so, poison them all!
* int strength = p.getStrength (); // use same strength of poison
* in.poison (strength);
* for (int i = 0; i < out.length; i++) {
* out[i].poison (strength);
* }
* }
*
*
* A Simple Traffic Flow Regulator
* The Regulate process controls the rate of flow of traffic from its input
* to output channels. It produces a constant rate of output flow, regardless of
* the rate of its input. At the end of each timeslice defined by the required output
* rate, it outputs the last object input during that timeslice. If nothing has come
* in during a timeslice, the previous output will be repeated (note: this will be a
* null if nothing has ever arrived). If the input flow is greater than
* the required output flow, data will be discarded.
* Long)
* down the reset channel.
* java.awt.Component.repaint.
*
* package org.jcsp.plugNplay;
*
* import org.jcsp.lang.*;
*
* public class Regulate implements CSProcess {
*
* private final AltingChannelInput in, reset;
* private final ChannelOutput out;
* private final long initialInterval;
*
* public Regulate (final AltingChannelInput in, final AltingChannelInput reset,
* final ChannelOutput out, final long initialInterval) {
* this.in = in;
* this.reset = reset;
* this.out = out;
* this.initialInterval = initialInterval;
* }
*
* public void run () {
*
* final CSTimer tim = new CSTimer ();
*
* final Guard[] guards = {reset, tim, in}; // prioritised order
* final int RESET = 0; // index into guards
* final int TIM = 1; // index into guards
* final int IN = 2; // index into guards
*
* final Alternative alt = new Alternative (guards);
*
* Object x = null; // holding object
*
* long interval = initialInterval;
*
* long timeout = tim.read () + interval;
* tim.setAlarm (timeout);
*
* while (true) {
* switch (alt.priSelect ()) {
* case RESET:
* interval = ((Long) reset.read ()).longValue ();
* timeout = tim.read (); // fall through
* case TIM:
* out.write (x);
* timeout += interval;
* tim.setAlarm (timeout);
* break;
* case IN:
* x = in.read ();
* break;
* }
* }
*
* }
*
* }
*
* Regulate, consider:
*
* class RegulateTest {
*
* public static void main (String[] args) {
*
* final One2OneChannel a = Channel.one2One ();
* final One2OneChannel b = Channel.one2One ();
* final One2OneChannel c = Channel.one2One ();
*
* final One2OneChannel reset = Channel.one2one (new OverWriteOldestBuffer (1));
*
* new Parallel (
* new CSProcess[] {
* new Numbers (a.out ()), // generate numbers
* new FixedDelay (250, a.in (), b.out ()), // let them through every quarter second
* new Regulate (b.in (), reset.in (), c.out (), 1000), // initially sample every second
* new CSProcess () {
* public void run () {
* Long[] sample = {new Long (1000), new Long (250), new Long (100)};
* int[] count = {10, 40, 100};
* while (true) {
* for (int cycle = 0; cycle < sample.length; cycle++) {
* reset.write (sample[cycle]);
* System.out.println ("\nSampling every " + sample[cycle] + " ms ...\n");
* for (int i = 0; i < count[cycle]; i++) {
* Integer n = (Integer) c.read ();
* System.out.println ("\t==> " + n);
* }
* }
* }
* }
* }
* }
* ).run ();
* }
*
* }
*
* The reader may like to consider the danger of deadlock in the above system if
* the reset channel were not an overwriting one.
*
*
* Polling
* Sometimes, we want to handle incoming channel data if it's there, but get on with
* something else if all is quiet. This can be done by PRI ALTing
* the channels we wish to poll against a SKIP guard:
*
* import org.jcsp.lang.*;
*
* public class Polling implements CSProcess {
*
* private final AltingChannelInput in0;
* private final AltingChannelInput in1;
* private final AltingChannelInput in2;
* private final ChannelOutput out;
*
* public Polling (final AltingChannelInput in0, final AltingChannelInput in1,
* final AltingChannelInput in2, final ChannelOutput out) {
* this.in0 = in0;
* this.in1 = in1;
* this.in2 = in2;
* this.out = out;
* }
*
* public void run() {
*
* final Skip skip = new Skip ();
* final Guard[] guards = {in0, in1, in2, skip};
* final Alternative alt = new Alternative (guards);
*
* while (true) {
* switch (alt.priSelect ()) {
* case 0:
* ... process data pending on channel in0 ...
* break;
* case 1:
* ... process data pending on channel in1 ...
* break;
* case 2:
* ... process data pending on channel in2 ...
* break;
* case 3:
* ... nothing available for the above ...
* ... so get on with something else for a while ...
* ... then loop around and poll again ...
* break;
* }
* }
*
* }
*
* }
*
* The above technique lets us poll any {@link Guard} events, including
* timeouts. If we just want to poll channels for input events, see
* the {@link AltingChannelInput#pending pending} methods of the various
* ``...2One...'' channels for a more direct and efficient way.
* The `Wot-no-Chickens?' Canteen
* This examples demonstrates the use of pre-conditions on the ALT
* guards. The Canteen process buffers a supply of chickens. It can
* hold a maximum of 20 chickens. Chickens are supplied on the supply
* line in batches of, at most, 4. Chickens are requested by hungry philosophers
* who share the request line to the Canteen. In response to
* such requests, one chicken is delivered down the deliver line.
* Canteen refuses further supplies if it has no room for the maximum
* (4) batch supply. The Canteen refuses requests from the philosophers
* if it has no chickens.
*
* import org.jcsp.lang.*;
*
* public class Canteen implements CSProcess {
*
* private final AltingChannelInput supply; // from the cook
* private final AltingChannelInput request; // from a philosopher
* private final ChannelOutput deliver; // to a philosopher
*
* public Canteen (final AltingChannelInput supply,
* final AltingChannelInput request,
* final ChannelOutput deliver) {
* this.supply = supply;
* this.request = request;
* this.deliver = deliver;
* }
*
* public void run() {
*
* final Guard[] guard = {supply, request};
* final boolean[] preCondition = new boolean[guard.length];
* final int SUPPLY = 0;
* final int REQUEST = 1;
*
* final Alternative alt = new Alternative (guard);
*
* final int maxChickens = 20;
* final int maxSupply = 4;
* final int limitChickens = maxChickens - maxSupply;
*
* final Integer oneChicken = new Integer (1);
* // ready to go!
*
* int nChickens = 0;
* // invariant : 0 <= nChickens <= maxChickens
*
* while (true) {
* preCondition[SUPPLY] = (nChickens <= limitChickens);
* preCondition[REQUEST] = (nChickens > 0);
* switch (alt.priSelect (preCondition)) {
* case SUPPLY:
* nChickens += ((Integer) supply.read ()).intValue (); // <= maxSupply
* break;
* case REQUEST:
* Object dummy = request.read ();
* // we have to still input the signal
* deliver.write (oneChicken);
* // preCondition ==> (nChickens > 0)
* nChickens--;
* break;
* }
* }
*
* }
*
* }
*
* supply
* method would have to cope with its being called when there is no room to take the supply.
* A request method would have to be dealt with even though there may be no chickens
* to deliver. Monitors manage such problems by putting their callers on hold
* (wait), but that means that their methods have to rely on each other to get
* out of any resulting embarassment (using notify).
* And that means that the logic of those methods has to be tightly coupled, which
* makes reasoning about them hard. This gets worse the more interdependent methods
* the monitor has.
* Canteen process simply refuses service on
* its supply and request channels if it can't cope, leaving
* the supplying or requesting processes waiting harmlessly on those channels.
* The service responses can assume their run-time set pre-conditions and have
* independent -- and trivial -- logic. When circumstances permit,
* the blocked processes are serviced in the normal way.
* Implementation Footnote
* This Alternative class and the various channel classes
* (e.g. {@link One2OneChannel}) are mutually dependent monitors -- they see instances
* of each other and invoke each others' strongly interdependent methods. This logic
* is inspired by the published algorithms and data structures burnt into the microcode
* of the transputer some 15 years ago (1984). Getting this logic `right'
* in the context of Java monitors is something we have done (n + 1) times,
* only to find it flawed n times with an unsuspected race-hazard months
* (sometimes years) later. Hopefully, we have it right now ... but a proof
* of correctness is really needed!
* synchronized keyword and the wait, notify and
* notifyAll methods of the Object class) has been built.
* This has been used for the formal verification of the JCSP implementation
* of channel read and write, along with the correctness of
* 2-way channel input Alternatives.
* Details and references are listed under
* `A CSP Model
* for Java Threads' on the JCSP web-site.
* [The proof uses the FDR
* model checker. Model checkers do not easily allow verification of results containing
* free variables - such as the correctness of the n-way Alternative.
* An investigation of this using formal transformation of one system of CSP equations
* into another, rather than model checking is being considered.]
* Alternative object operating on the {@link Guard}
* array of events. Supported guard events are channel inputs
* ({@link AltingChannelInput} and {@link AltingChannelInputInt}),
* CALL channel accepts ({@link AltingChannelAccept}),
* barriers ({@link AltingBarrier}),
* timeouts ({@link CSTimer}) and skips ({@link Skip}).
* preCondition
* index is true. The method will block until one of these guards becomes
* ready. If more than one is ready, an arbitrary choice is made.
* preCondition array must be the
* same as that of the array of guards with which this object was constructed.
* preCondition
* index is true. The method will block until one of these guards becomes
* ready. If more than one is ready, the one with the lowest index is selected.
* preCondition array must be the
* same as that of the array of guards with which this object was constructed.
* preCondition index
* is true. The method will block until one of these guards becomes ready.
* Consequetive invocations will service the guards `fairly' in the case
* when many guards are always ready. Implementation note: the last
* guard serviced has the lowest priority next time around.
* preCondition array must be the
* same as that of the array of guards with which this object was constructed.
* Description
* AltingChannelInputInt extends {@link Guard} and {@link ChannelInputInt}
* to enable a process
* to choose between many integer input (and other) events. The methods inherited from
* Guard are of no concern to users of this package.
*
Example
*
* import org.jcsp.lang.*;
*
* public class AltingIntExample implements CSProcess {
*
* private final AltingChannelInputInt in0, in1;
*
* public AltingIntExample (final AltingChannelInputInt in0,
* final AltingChannelInputInt in1) {
* this.in0 = in0;
* this.in1 = in1;
* }
*
* public void run () {
*
* final Guard[] altChans = {in0, in1};
* final Alternative alt = new Alternative (altChans);
*
* while (true) {
* switch (alt.select ()) {
* case 0:
* System.out.println ("in0 read " + in0.read ());
* break;
* case 1:
* System.out.println ("in1 read " + in1.read ());
* break;
* }
* }
*
* }
*
* }
*
*
* @see org.jcsp.lang.Guard
* @see org.jcsp.lang.Alternative
* @author P.D. Austin and P.H. Welch
*/
public abstract class AltingChannelInputInt extends Guard implements ChannelInputInt
{
/**
* Returns whether there is data pending on this channel.
*
* Note: if there is, it won't go away until you read it. But if there
* isn't, there may be some by the time you check the result of this method.
*
* @return state of the channel.
*/
public abstract boolean pending();
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/PoisonableBufferedOne2AnyChannel.java 0000644 0000000 0000000 00000004322 11113671251 023150 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.ChannelDataStore;
class PoisonableBufferedOne2AnyChannel extends One2AnyImpl
{
PoisonableBufferedOne2AnyChannel(ChannelDataStore _data, int _immunity) {
super(new PoisonableBufferedOne2OneChannel(_data,_immunity));
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/SharedChannelOutputImpl.java 0000644 0000000 0000000 00000004617 11113671251 021476 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
class SharedChannelOutputImpl implements SharedChannelOutput {
private ChannelInternals channel;
private int immunity;
SharedChannelOutputImpl(ChannelInternals _channel, int _immunity) {
channel = _channel;
immunity = _immunity;
}
public void write(Object object) {
channel.write(object);
}
public void poison(int strength) {
if (strength > immunity) {
channel.writerPoison(strength);
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/AltingConnectionServerImpl.java 0000644 0000000 0000000 00000020260 11105701167 022174 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This class does not need to be used by standard JCSP users. It is exposed so that the connection
* mechanism can be extended for custom connections.
*
* @author Quickstone Technologies Limited
*/
public class AltingConnectionServerImpl extends AltingConnectionServer
{
/**
* Server state. The server is initially CLOSED the first request will take it to the
* RECEIVED state. A reply will take it back to OPEN or CLOSED depending
* on the mode of reply. From the OPEN or CLOSED state a further request can
* occur.
*/
protected static final int SERVER_STATE_CLOSED = 1;
/**
* Server state. The server is initially CLOSED the first request will take it to the
* RECEIVED state. A reply will take it back to OPEN or CLOSED depending
* on the mode of reply. From the OPEN or CLOSED state a further request can
* occur.
*/
protected static final int SERVER_STATE_OPEN = 2;
/**
* Server state. The server is initially CLOSED the first request will take it to the
* RECEIVED state. A reply will take it back to OPEN or CLOSED depending
* on the mode of reply. From the OPEN or CLOSED state a further request can
* occur.
*/
protected static final int SERVER_STATE_RECEIVED = 3;
private int currentServerState;
private AltingChannelInput openIn;
private AltingChannelInput furtherRequestIn;
private ChannelInput currentInputChannel;
private ChannelOutput toClient = null;
private ConnectionServerMessage msg = null;
/**
* Constructs a new server instance. This must be called by a subclass which is responsible for
* creating the channels.
*/
protected AltingConnectionServerImpl(AltingChannelInput openIn,
AltingChannelInput furtherRequestIn)
{
super(openIn);
this.openIn = openIn;
this.furtherRequestIn = furtherRequestIn;
this.currentInputChannel = openIn;
currentServerState = SERVER_STATE_CLOSED;
}
/**
* Receives some data from a client once a connection
* has been established. This will block until the client
* calls request(Object) but by establishing
* a connection.
*
* @return the Object sent by the client.
*/
public Object request() throws IllegalStateException
{
if (currentServerState == SERVER_STATE_RECEIVED)
throw new IllegalStateException
("Cannot call request() twice on ConnectionServer without replying to the client first.");
ConnectionClientMessage msg = (ConnectionClientMessage)currentInputChannel.read();
if (currentServerState == SERVER_STATE_CLOSED)
{
if (msg instanceof ConnectionClientOpenMessage)
{
//channel to use to reply to client
toClient = ((ConnectionClientOpenMessage) msg).replyChannel;
setAltingChannel(furtherRequestIn);
currentInputChannel = furtherRequestIn;
//create a new msg for connection established
//don't know if client implementation will have finished with
//message after connection closed
this.msg = new ConnectionServerMessage();
}
else
throw new IllegalStateException("Invalid message received from client");
}
currentServerState = SERVER_STATE_RECEIVED;
return msg.data;
}
/**
* Sends some data back to the client after a request
* has been received but keeps the connection open. After calling
* this method, the server should call recieve()
* to receive a further request.
*
* @param data the data to send to the client.
*/
public void reply(Object data) throws IllegalStateException
{
reply(data, false);
}
/**
* Sends some data back to the client after a request
* has been received. The closed parameter indicates whether or not
* the connection should be closed. The connection will be closed
* iff close is true.
*
* @param data the data to send to the client.
* @param close boolean indicating whether or not the
* connection should be closed.
*/
public void reply(Object data, boolean close) throws IllegalStateException
{
if (currentServerState != SERVER_STATE_RECEIVED)
throw new IllegalStateException
("Cannot call reply(Object, boolean) on a ConnectionServer that has not received an unacknowledge request.");
//set open to true before replying
msg.data = data;
msg.open = !close;
toClient.write(msg);
if (close)
{
currentServerState = SERVER_STATE_CLOSED;
toClient = null;
setAltingChannel(openIn);
currentInputChannel = openIn;
}
else
currentServerState = SERVER_STATE_OPEN;
}
/**
* Sends some data back to the client and closes the connection.
* This method will not block. After calling this method, the
* server may call accept() in order to allow another
* connection to this server to be established.
*
* If this method did not take any data to send back to the client,
* and the server was meant to call reply(Object) followed
* by a close(), then there would be a race hazard at the
* client as it would not know whether the connection had
* remained open or not.
*
* @param data the data to send back to client.
*/
public void replyAndClose(Object data) throws IllegalStateException
{
reply(data, true);
}
protected int getServerState()
{
return currentServerState;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/SharedConnectionClient.java 0000644 0000000 0000000 00000005675 11105701167 021327 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
*
* Defines an interface for a client end of a connection that * can be shared by multiple clients. *
*
* This object cannot itself be shared between concurrent processes
* but duplicate objects can be generated that can be used by
* multiple concurrent processes. This can be achieved using
* the {@link #duplicate()} method.
*
* See {@link ConnectionClient} for a fuller explanation
* of how to use connection client objects.
*
SharedConnectionClient object
* which may be used by another process to this instance.
*
* @return a duplicate SharedConnectionClient object.
*/
public SharedConnectionClient duplicate();
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/RejectableChannelOutput.java 0000644 0000000 0000000 00000005524 11105701167 021505 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* Defines an interface for a channel output end which may reject data if the reader is not prepared
* to receive it and calls reject instead of read on the input channel end.
*
* @author Quickstone Technologies Limited
*
* @deprecated This channel is superceded by the poison mechanisms, please see {@link PoisonException}. It remains only because it is used by some of the networking features.
*/
public interface RejectableChannelOutput extends ChannelOutput
{
/**
* Writes data over the channel.
*
* @param o an object to write over the channel.
* @throws ChannelDataRejectedException if the reader rejects the data instead of reading it from the channel.
*/
public void write(Object o) throws ChannelDataRejectedException;
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Any2AnyConnection.java 0000644 0000000 0000000 00000005174 11105701167 020235 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* Defines an interface for a connection shared by multiple clients and multiple servers.
*
* @author Quickstone Technologies Limited
*/
public interface Any2AnyConnection extends ConnectionWithSharedAltingClient,
ConnectionWithSharedAltingServer
{
/**
* Returns a reference to the client end of the connection for use by the client processes.
*/
public SharedAltingConnectionClient client();
/**
* Returns a reference to the server end of the connection for use by the server processes.
*/
public SharedConnectionServer server();
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Any2AnyConnectionImpl.java 0000644 0000000 0000000 00000011220 11105701167 021044 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.Buffer;
/**
* This class is an implementation of Any2AnyConnection.
* Each end is safe to be used by one thread at a time.
*
* @author Quickstone Technologies Limited
*/
class Any2AnyConnectionImpl extends AbstractConnectionImpl implements Any2AnyConnection
{
private One2OneChannel chanToServer;
private One2OneChannel chanFromServer;
private Any2OneChannel chanClientSynch;
private Any2OneChannel chanServerSynch;
/**
* Initializes all the attributes to necessary values.
* Channels are created using the static factory in the
* ChannelServer inteface.
*
* Constructor for One2OneConnectionImpl.
*/
public Any2AnyConnectionImpl()
{
super();
chanToServer = ConnectionServer.FACTORY.createOne2One(new Buffer(1));
chanFromServer = ConnectionServer.FACTORY.createOne2One(new Buffer(1));
chanClientSynch = ConnectionServer.FACTORY.createAny2One(new Buffer(1));
chanServerSynch = ConnectionServer.FACTORY.createAny2One(new Buffer(1));
}
/**
* Returns a SharedAltingConnectionClient object for this
* connection. This method can be called multiple times to return a new
* SharedAltingConnectionClient object each time. Any object
* created can only be used by one process at a time but the set of
* objects constructed can be used concurrently.
*
* @return a new SharedAltingConnectionClient object.
*/
public SharedAltingConnectionClient client()
{
return new SharedAltingConnectionClient(
chanFromServer.in(),
chanClientSynch.in(),
chanToServer.out(),
chanToServer.out(),
chanClientSynch.out(),
chanFromServer.out(),
this);
}
/**
* Returns a SharedConnectionServer object for this
* connection. This method can be called multiple times to return a new
* SharedConnectionServer object each time. Any object
* created can only be used by one process at a time but the set of
* objects constructed can be used concurrently.
*
* @return a new SharedConnectionServer object.
*/
public SharedConnectionServer server()
{
return new SharedConnectionServerImpl(
chanToServer.in(),
chanToServer.in(),
chanServerSynch.in(),
chanServerSynch.out(),
this);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/BufferedAny2OneChannel.java 0000644 0000000 0000000 00000011303 11105701167 021132 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.*;
/**
* This implements an any-to-one object channel with user-definable buffering,
* safe for use by many writers and one reader.
* Description
* BufferedAny2OneChannel implements an any-to-one object channel with * user-definable buffering. It is safe for use by many writing processes * but only one reader. Writing processes compete with each other to use * the channel. Only the reader and one writer will * actually be using the channel at any one time. This is taken care of by * BufferedAny2OneChannel -- user processes just read from or write to it. ** The reading process may {@link Alternative ALT} on this channel. * The writing process is committed (i.e. it may not back off). *
* The constructor requires the user to provide * the channel with a plug-in driver conforming to the * {@link org.jcsp.util.ChannelDataStore ChannelDataStore} * interface. This allows a variety of different channel semantics to be * introduced -- including buffered channels of user-defined capacity * (including infinite), overwriting channels (with various overwriting * policies) etc.. * Standard examples are given in the org.jcsp.util package, but * careful users may write their own. * *
Implementation Note and Caution
* Fair servicing of writers to this channel depends on the fair * servicing of requests to enter a synchronized block (or method) by * the underlying Java Virtual Machine (JVM). Java does not specify how threads * waiting to synchronize should be handled. Currently, Sun's standard JDKs queue * these requests - which is fair. However, there is at least one JVM * that puts such competing requests on a stack - which is legal but unfair * and can lead to infinite starvation. This is a problem for any Java system * relying on good behaviour from synchronized, not just for these * any-1 channels. * * @see org.jcsp.lang.Alternative * @see org.jcsp.lang.BufferedOne2OneChannel * @see org.jcsp.lang.BufferedOne2AnyChannel * @see org.jcsp.lang.BufferedAny2AnyChannel * @see org.jcsp.util.ChannelDataStore * * @author P.D. Austin * @author P.H. Welch */ class BufferedAny2OneChannel extends Any2OneImpl { /** * Constructs a new BufferedAny2OneChannel with the specified ChannelDataStore. * * @param data The ChannelDataStore used to store the data for the channel */ public BufferedAny2OneChannel(ChannelDataStore data) { super(new BufferedOne2OneChannel(data)); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/StandardChannelFactory.java 0000644 0000000 0000000 00000031610 11105701167 021307 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; import org.jcsp.util.ChannelDataStore; /** *This class acts as a Factory for creating * channels. It can create non-buffered and buffered channels * and also arrays of non-buffered and buffered channels.
* *The Channel objects created by this Factory are formed of
* separate objects for the read and write ends. Therefore the
* ChannelInput object cannot be cast into the
* ChannelOutput object and vice-versa.
The current implementation uses an instance of the
* RiskyChannelFactory to construct the underlying
* raw channels.
One2OneChannel object.
*
* @return the channel object.
*
* @see org.jcsp.lang.ChannelFactory#createOne2One()
*/
public One2OneChannel createOne2One()
{
return new One2OneChannelImpl();
}
/**
* Constructs and returns an Any2OneChannel object.
*
* @return the channel object.
*
* @see org.jcsp.lang.ChannelFactory#createAny2One()
*/
public Any2OneChannel createAny2One()
{
return new Any2OneChannelImpl();
}
/**
* Constructs and returns a One2AnyChannel object.
*
* @return the channel object.
*
* @see org.jcsp.lang.ChannelFactory#createOne2Any()
*/
public One2AnyChannel createOne2Any()
{
return new One2AnyChannelImpl();
}
/**
* Constructs and returns an Any2AnyChannel object.
*
* @return the channel object.
*
* @see org.jcsp.lang.ChannelFactory#createAny2Any()
*/
public Any2AnyChannel createAny2Any()
{
return new Any2AnyChannelImpl();
}
/**
* Constructs and returns an array of One2OneChannel
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createOne2One(int)
*/
public One2OneChannel[] createOne2One(int n)
{
One2OneChannel[] toReturn = new One2OneChannel[n];
for (int i = 0; i < n; i++)
toReturn[i] = createOne2One();
return toReturn;
}
/**
* Constructs and returns an array of Any2OneChannel
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createAny2One(int)
*/
public Any2OneChannel[] createAny2One(int n)
{
Any2OneChannel[] toReturn = new Any2OneChannel[n];
for (int i = 0; i < n; i++)
toReturn[i] = createAny2One();
return toReturn;
}
/**
* Constructs and returns an array of One2AnyChannel
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createOne2Any(int)
*/
public One2AnyChannel[] createOne2Any(int n)
{
One2AnyChannel[] toReturn = new One2AnyChannel[n];
for (int i = 0; i < n; i++)
toReturn[i] = createOne2Any();
return toReturn;
}
/**
* Constructs and returns an array of Any2AnyChannel
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelArrayFactory#createAny2Any(int)
*/
public Any2AnyChannel[] createAny2Any(int n)
{
Any2AnyChannel[] toReturn = new Any2AnyChannel[n];
for (int i = 0; i < n; i++)
toReturn[i] = createAny2Any();
return toReturn;
}
/**
* Constructs and returns a One2OneChannel object which
* uses the specified ChannelDataStore object as a buffer.
*
The buffer supplied to this method is cloned before it is inserted into * the channel. *
* * @param buffer theChannelDataStore to use.
* @return the buffered channel.
*
* @see org.jcsp.lang.BufferedChannelFactory#createOne2One(org.jcsp.util.ChannelDataStore)
* @see org.jcsp.util.ChannelDataStore
*/
public One2OneChannel createOne2One(ChannelDataStore buffer)
{
return new BufferedOne2OneChannel(buffer);
}
/**
* Constructs and returns a Any2OneChannel object which
* uses the specified ChannelDataStore object as a buffer.
*
The buffer supplied to this method is cloned before it is inserted into * the channel. *
* * @param buffer theChannelDataStore to use.
* @return the buffered channel.
*
* @see org.jcsp.lang.BufferedChannelFactory#createAny2One(org.jcsp.util.ChannelDataStore)
* @see org.jcsp.util.ChannelDataStore
*/
public Any2OneChannel createAny2One(ChannelDataStore buffer)
{
return new BufferedAny2OneChannel(buffer);
}
/**
* Constructs and returns a One2AnyChannel object which
* uses the specified ChannelDataStore object as a buffer.
*
The buffer supplied to this method is cloned before it is inserted into * the channel. *
* * @param buffer theChannelDataStore to use.
* @return the buffered channel.
*
* @see org.jcsp.lang.BufferedChannelFactory#createOne2Any(org.jcsp.util.ChannelDataStore)
* @see org.jcsp.util.ChannelDataStore
*/
public One2AnyChannel createOne2Any(ChannelDataStore buffer)
{
return new BufferedOne2AnyChannel(buffer);
}
/**
* Constructs and returns a Any2AnyChannel object which
* uses the specified ChannelDataStore object as a buffer.
*
The buffer supplied to this method is cloned before it is inserted into * the channel. *
* * @param buffer theChannelDataStore to use.
* @return the buffered channel.
*
* @see org.jcsp.lang.BufferedChannelFactory#createAny2Any(org.jcsp.util.ChannelDataStore)
* @see org.jcsp.util.ChannelDataStore
*/
public Any2AnyChannel createAny2Any(ChannelDataStore buffer)
{
return new BufferedAny2AnyChannel(buffer);
}
/**
* Constructs and returns an array of One2OneChannel objects
* which use the specified ChannelDataStore object as a
* buffer.
*
The buffer supplied to this method is cloned before it is inserted into * the channel. This is why an array of buffers is not required. *
* * @param buffer theChannelDataStore to use.
* @param n the size of the array of channels.
* @return the array of buffered channels.
*
* @see org.jcsp.lang.BufferedChannelArrayFactory#createOne2One(org.jcsp.util.ChannelDataStore,int)
* @see org.jcsp.util.ChannelDataStore
*/
public One2OneChannel[] createOne2One(ChannelDataStore buffer, int n)
{
One2OneChannel[] toReturn = new One2OneChannel[n];
for (int i = 0; i < n; i++)
toReturn[i] = createOne2One(buffer);
return toReturn;
}
/**
* Constructs and returns an array of Any2OneChannel objects
* which use the specified ChannelDataStore object as a
* buffer.
*
The buffer supplied to this method is cloned before it is inserted into * the channel. This is why an array of buffers is not required. *
* * @param buffer theChannelDataStore to use.
* @param n the size of the array of channels.
* @return the array of buffered channels.
*
* @see org.jcsp.lang.BufferedChannelArrayFactory#createAny2One(org.jcsp.util.ChannelDataStore,int)
* @see org.jcsp.util.ChannelDataStore
*/
public Any2OneChannel[] createAny2One(ChannelDataStore buffer, int n)
{
Any2OneChannel[] toReturn = new Any2OneChannel[n];
for (int i = 0; i < n; i++)
toReturn[i] = createAny2One(buffer);
return toReturn;
}
/**
* Constructs and returns an array of One2AnyChannel objects
* which use the specified ChannelDataStore object as a
* buffer.
*
The buffer supplied to this method is cloned before it is inserted into * the channel. This is why an array of buffers is not required. *
* * @param buffer theChannelDataStore to use.
* @param n the size of the array of channels.
* @return the array of buffered channels.
*
* @see org.jcsp.lang.BufferedChannelArrayFactory#createOne2Any(org.jcsp.util.ChannelDataStore,int)
* @see org.jcsp.util.ChannelDataStore
*/
public One2AnyChannel[] createOne2Any(ChannelDataStore buffer, int n)
{
One2AnyChannel[] toReturn = new One2AnyChannel[n];
for (int i = 0; i < n; i++)
toReturn[i] = createOne2Any(buffer);
return toReturn;
}
/**
* Constructs and returns an array of Any2AnyChannel objects
* which use the specified ChannelDataStore object as a
* buffer.
*
The buffer supplied to this method is cloned before it is inserted into * the channel. This is why an array of buffers is not required. *
* * @param buffer theChannelDataStore to use.
* @param n the size of the array of channels.
* @return the array of buffered channels.
*
* @see org.jcsp.lang.BufferedChannelArrayFactory#createAny2Any(org.jcsp.util.ChannelDataStore,int)
* @see org.jcsp.util.ChannelDataStore
*/
public Any2AnyChannel[] createAny2Any(ChannelDataStore buffer, int n)
{
Any2AnyChannel[] toReturn = new Any2AnyChannel[n];
for (int i = 0; i < n; i++)
toReturn[i] = createAny2Any(buffer);
return toReturn;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/BufferedAny2AnyChannelIntImpl.java 0000644 0000000 0000000 00000011677 11105701167 022453 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.ints.*;
/**
* This implements an any-to-any integer channel with user-definable buffering,
* safe for use by many writers and many readers.
* Description
* BufferedAny2AnyChannelIntImpl implements an any-to-any integer channel with * user-definable buffering. It is safe for use by any number of reading or * writing processes. Reading processes compete with each other to use * the channel. Writing processes compete with each other to use the channel. * Only the reader and one writer will * actually be using the channel at any one time. This is taken care of by * BufferedAny2AnyChannelIntImpl -- user processes just read from or write to it. ** Please note that this is a sefely shared channel and not * a multicaster. Currently, multicasting has to be managed by * writing active processes (see {@link org.jcsp.plugNplay.DynamicDelta} * for an example of broadcasting). *
* All reading processes and writing processes commit to the channel * (i.e. may not back off). This means that the reading processes * may not {@link Alternative ALT} on this channel. *
* The constructor requires the user to provide * the channel with a plug-in driver conforming to the * {@link org.jcsp.util.ints.ChannelDataStoreInt ChannelDataStoreInt} * interface. This allows a variety of different channel semantics to be * introduced -- including buffered channels of user-defined capacity * (including infinite), overwriting channels (with various overwriting * policies) etc.. * Standard examples are given in the org.jcsp.util package, but * careful users may write their own. * *
Implementation Note and Caution
* Fair servicing of readers and writers to this channel depends on the fair * servicing of requests to enter a synchronized block (or method) by * the underlying Java Virtual Machine (JVM). Java does not specify how threads * waiting to synchronize should be handled. Currently, Sun's standard JDKs queue * these requests - which is fair. However, there is at least one JVM * that puts such competing requests on a stack - which is legal but unfair * and can lead to infinite starvation. This is a problem for any Java system * relying on good behaviour from synchronized, not just for these * any-any channels. * * @see org.jcsp.lang.BufferedOne2OneChannel * @see org.jcsp.lang.BufferedOne2AnyChannel * @see org.jcsp.lang.BufferedAny2AnyChannel * @see org.jcsp.util.ints.ChannelDataStoreInt * * @author P.D. Austin * @author P.H. Welch */ class BufferedAny2AnyChannelIntImpl extends Any2AnyIntImpl { public BufferedAny2AnyChannelIntImpl(ChannelDataStoreInt data) { super(new BufferedOne2OneChannelIntImpl(data)); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelOutputInt.java 0000644 0000000 0000000 00000007623 11113671251 020200 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * This defines the interface for writing to integer channels. ** A writing-end, conforming to this interface, * is obtained from a channel by invoking its out() method. *
Description
* ChannelOutputInt defines the interface for writing to integer channels. * The interface contains only one method - write(int o). * This method will block the calling process until the int has * been accepted by the channel. In the (default) case of a zero-buffered * synchronising CSP channel, this happens only when a process at the other * end of the channel invokes (or has already invoked) a read(). ** ChannelOutputInt variables are used to hold integer channels * that are going to be used only for output by the declaring process. * This is a security matter -- by declaring a ChannelOutputInt * interface, any attempt to input from the channel will generate * a compile-time error. For example, the following code fragment will * not compile: * *
* int doRead (ChannelOutputInt c) {
* return c.read (); // illegal
* }
*
*
* When configuring a CSProcess with output integer channels, they should
* be declared as ChannelOutputInt variables. The actual channel passed,
* of course, may belong to any channel class that implements
* ChannelOutputInt.
*
* Example
*
* void doWrite (ChannelOutputInt c, int i) {
* c.write (i);
* }
*
*
* @see org.jcsp.lang.SharedChannelOutputInt
* @see org.jcsp.lang.ChannelInputInt
* @author P.D. Austin
*/
public interface ChannelOutputInt extends Poisonable
{
/**
* Write an int to the channel.
*
* @param i the integer to write to the channel
*/
public void write(int i);
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/SharedConnectionServer.java 0000644 0000000 0000000 00000005155 11105701167 021350 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* * Defines an interface for a server end of a connection that * can be shared by multiple concurrent processes. *
*
* SharedConnectionServer objects cannot have
* their requests ALTed over.
*
* Creates a duplicate copy of the connection end. *
* * @return the duplicateSharedConnectionServer
* object.
*
*/
public SharedConnectionServer duplicate();
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/PoisonableBufferedAny2AnyChannel.java 0000644 0000000 0000000 00000004322 11113671251 023156 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.ChannelDataStore;
class PoisonableBufferedAny2AnyChannel extends Any2AnyImpl
{
PoisonableBufferedAny2AnyChannel(ChannelDataStore _data, int _immunity) {
super(new PoisonableBufferedOne2OneChannel(_data,_immunity));
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/PoisonableBufferedAny2OneChannel.java 0000644 0000000 0000000 00000004322 11113671251 023150 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.ChannelDataStore;
class PoisonableBufferedAny2OneChannel extends Any2OneImpl
{
PoisonableBufferedAny2OneChannel(ChannelDataStore _data, int _immunity) {
super(new PoisonableBufferedOne2OneChannel(_data,_immunity));
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/BarrierError.java 0000644 0000000 0000000 00000004516 11105701167 017333 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
//{{{ javadoc
/**
* This is thrown for an illegal operation on an Barrier.
*
* Description
* Currently, there is only one cause: more processes have resigned than were * enrolled. * * @author P.H. Welch */ //}}} public class BarrierError extends Error { public BarrierError (String s) { super (s); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/One2AnyChannelInt.java 0000644 0000000 0000000 00000013441 11113671251 020146 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * This defines the interface for a one-to-any integer channel, * safe for use by one writer and many readers. ** The only methods provided are to obtain the ends of the channel, * through which all reading and writing operations are done. * Only an appropriate channel-end should be plugged into a process * – not the whole channel. * A process may use its external channels in one direction only * – either for writing or reading. *
*Actual channels conforming to this interface are made using the relevant * static construction methods from {@link Channel}. * Channels may be {@link Channel#one2anyInt() synchronising}, * {@link Channel#one2anyInt(org.jcsp.util.ints.ChannelDataStoreInt) buffered}, * {@link Channel#one2anyInt(int) poisonable} * or {@link Channel#one2anyInt(org.jcsp.util.ints.ChannelDataStoreInt,int) both} * (i.e. buffered and poisonable). *
*Description
* One2AnyChannelInt is an interface for a channel which is safe * for use by many reading processes but only one writer. Reading processes * compete with each other to use the channel. Only one reader and the writer will * actually be using the channel at any one time. This is managed by the * channel – user processes just read from or write to it. ** Please note that this is a safely shared channel and not * a broadcaster. Currently, broadcasting has to be managed by * writing an active process (see {@link org.jcsp.plugNplay.DynamicDelta} * for an example). *
** All reading processes and the writing process commit to the channel * (i.e. may not back off). This means that the reading processes * may not {@link Alternative ALT} on this channel. *
** The default semantics of the channel is that of CSP – i.e. it is * zero-buffered and fully synchronised. A reading process must wait * for the matching writer and vice-versa. *
** The static methods of {@link Channel} construct channels with * either the default semantics or with buffering to user-specified capacity * and a range of blocking/overwriting policies. * Various buffering plugins are given in the org.jcsp.util package, but * careful users may write their own. *
** The {@link Channel} methods also provide for the construction of * {@link Poisonable} channels and for arrays of channels. * *
Implementation Note and Caution
* Fair servicing of readers to this channel depends on the fair * servicing of requests to enter a synchronized block (or method) by * the underlying Java Virtual Machine (JVM). Java does not specify how threads * waiting to synchronize should be handled. Currently, Sun's standard JDKs queue * these requests - which is fair. However, there is at least one JVM * that puts such competing requests on a stack - which is legal but unfair * and can lead to infinite starvation. This is a problem for any Java system * relying on good behaviour from synchronized, not just for these * 1-any channels. * * @see org.jcsp.lang.Channel * @see org.jcsp.lang.One2OneChannelInt * @see org.jcsp.lang.Any2OneChannelInt * @see org.jcsp.lang.Any2AnyChannelInt * @see org.jcsp.util.ints.ChannelDataStoreInt * * @author P.D. Austin and P.H. Welch */ public interface One2AnyChannelInt { /** * Returns the input end of the channel. */ public SharedChannelInputInt in(); /** * Returns the output end of the channel. */ public ChannelOutputInt out(); } jcsp-1.1-rc4.orig/src/org/jcsp/lang/PoisonableOne2AnyChannelIntImpl.java 0000644 0000000 0000000 00000004212 11113671251 023000 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; class PoisonableOne2AnyChannelIntImpl extends One2AnyIntImpl { PoisonableOne2AnyChannelIntImpl(int _immunity) { super(new PoisonableOne2OneChannelIntImpl(_immunity)); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/BasicOne2OneChannelSymmetricInt.java 0000644 0000000 0000000 00000004265 11105701167 023004 0 ustar /************************************************************************* * * * JCSP ("CSP for Java") libraries * * Copyright (C) 1996-2001 Peter Welch and Paul Austin. * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This library is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, * * USA. * * * * Author contact: P.H.Welch@kent.ac.uk * * * *************************************************************************/ package org.jcsp.lang; class BasicOne2OneChannelSymmetricInt implements One2OneChannelSymmetricInt { private final AltingBarrier[] ab = AltingBarrier.create (2); private final One2OneChannelInt c = Channel.one2oneInt(); public AltingChannelInputInt in () { return new AltingChannelInputIntSymmetricImpl (ab[0], c.in()); } public AltingChannelOutputInt out (){ return new AltingChannelOutputIntSymmetricImpl (ab[1], c.out()); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/AltingChannelOutput.java 0000644 0000000 0000000 00000007573 11113671251 020670 0 ustar /************************************************************************* * * * JCSP ("CSP for Java") libraries * * Copyright (C) 1996-2001 Peter Welch and Paul Austin. * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This library is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, * * USA. * * * * Author contact: P.H.Welch@kent.ac.uk * * * *************************************************************************/ package org.jcsp.lang; //{{{ javadoc /** * This extends {@link Guard} and {@link ChannelOutput} * to enable a process * to choose between many integer output (and other) events. ** A writing-end, obtained only from a {@link One2OneChannelSymmetric symmetric} * channel by invoking its out() method, will implement this interface. *
Description
* AltingChannelOutput extends {@link Guard} and {@link ChannelOutput} * to enable a process * to choose between many integer output (and other) events. The methods inherited from * Guard are of no concern to users of this package. * *Example
*
* import org.jcsp.lang.*;
*
* public class AltingOutputExample implements CSProcess {
*
* private final AltingChannelOutput out0, out1;
*
* public AltingOutputExample (final AltingChannelOutput out0,
* final AltingChannelOutput out1) {
* this.out0 = out0;
* this.out1 = out1;
* }
*
* public void run () {
*
* final Guard[] altChans = {out0, out1};
* final Alternative alt = new Alternative (altChans);
*
* while (true) {
* switch (alt.select ()) {
* case 0:
* out0.write (new Integer (0));
* System.out.println ("out0 written");
* break;
* case 1:
* out1.write (new Integer (1));
* System.out.println ("out1 written");
* break;
* }
* }
*
* }
*
* }
*
*
* @see org.jcsp.lang.Guard
* @see org.jcsp.lang.Alternative
* @see org.jcsp.lang.One2OneChannelSymmetric
* @see org.jcsp.lang.AltingChannelOutputInt
* @author P.H. Welch
*/
//}}}
public abstract class AltingChannelOutput extends Guard implements ChannelOutput {
// nothing alse to add
/**
* Returns whether the receiver is committed to read from this channel.
* * Note: if this returns true, you must commit to write down this channel. * * @return state of the channel. */ public abstract boolean pending (); } jcsp-1.1-rc4.orig/src/org/jcsp/lang/Bucket.java 0000644 0000000 0000000 00000041625 11105701167 016152 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // 2006 Neil Brown // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; import java.io.Serializable; /** * This enables bucket synchronisation between a set of processes. *
* Shortcut to the Constructor and Method Summaries. * *
Description
* A bucket is a non-deterministic cousin of a {@link Barrier}. A bucket is * somewhere to {@link #fallInto fallInto} when a process needs somewhere to park * itself. There is no limit on the number of processes that can fallInto * a bucket - and all are blocked when they do. * Release happens when a process (and it will have * to be another process) chooses to {@link #flush flush} that bucket. * When that happens, all processes in the bucket (which may be none) are * rescheduled for execution. ** Buckets are a non-deterministic primitive, since the decision to flush * is a free (internal) choice of the process concerned and the scheduling * of that flush impacts on the semantics. * Usually, only one process is given responsibility for flushing a bucket * (or set of buckets). * Flushing a bucket does not block the flusher. *
* Note: this notion of bucket corresponds to * the BUCKET * synchronisation primitive added to * the KRoC * occam language system. * *
Implementation Note
* The {@link #fallInto fallInto} and {@link #flush flush} * methods of Bucket are just a re-badging of the * {@link java.lang.Object#wait() wait} and * {@link java.lang.Object#notifyAll() notifyAll} methods of * {@link java.lang.Object} - but without the need to gain a monitor lock and * without the need to look out for the wait being interrupted. ** Currently, though, this is how they are implemented. * Beware that a notifyAll carries an O(n) overhead (where n is * the number of processes being notified), since each notified process must regain * the monitor lock before it can exit the synchronized region. * Future JCSP implementations of Bucket will look to follow occam kernels * and reduce the overheads of both fallInto and flush to O(1). * *
A Simple Example
* This consists of 10 workers, one bucket and one flusher: *
* import org.jcsp.lang.*;
*
* public class BucketExample1 {
*
* public static void main (String[] args) {
*
* final int nWorkers = 10;
*
* final int second = 1000;
* // JCSP timer units are milliseconds
* final int interval = 5*second;
* final int maxWork = 10*second;
*
* final long seed = new CSTimer ().read ();
* // for the random number generators
*
* final Bucket bucket = new Bucket ();
*
* final Flusher flusher = new Flusher (interval, bucket);
*
* final Worker[] workers = new Worker[nWorkers];
* for (int i = 0; i < workers.length; i++) {
* workers[i] = new Worker (i, i + seed, maxWork, bucket);
* }
*
* System.out.println ("*** Flusher: interval = " + interval
* + " milliseconds");
*
* new Parallel (
* new CSProcess[] {
* flusher,
* new Parallel (workers)
* }
* ).run ();
*
* }
*
* }
*
* A Worker cycle consists of one shift (which takes a random amount of time)
* and, then, falling into the bucket:
*
* import org.jcsp.lang.*;
* import java.util.*;
*
* public class Worker implements CSProcess {
*
* private final int id;
* private final long seed;
* private final int maxWork;
* private final Bucket bucket;
*
* public Worker (int id, long seed, int maxWork, Bucket bucket) {
* this.id = id;
* this.seed = seed;
* this.maxWork = maxWork;
* this.bucket = bucket;
* }
*
* public void run () {
*
* final Random random = new Random (seed);
* // each process gets a different seed
*
* final CSTimer tim = new CSTimer ();
* final int second = 1000;
* // JCSP timer units are milliseconds
*
* final String working = "\t... Worker " + id
* + " working ...";
* final String falling = "\t\t\t ... Worker " + id
* + " falling ...";
* final String flushed = "\t\t\t\t\t\t ... Worker "
* + id + " flushed ...";
*
* while (true) {
* System.out.println (working);
* tim.sleep (random.nextInt (maxWork));
* //These lines represent one unit of work
*
* System.out.println (falling);
* bucket.fallInto ();
* System.out.println (flushed);
* }
* }
*
* }
*
* The Flusher just flushes the bucket at preset time intervals:
* import org.jcsp.lang.*;
* import java.util.*;
*
* public class Flusher implements CSProcess {
*
* private final int interval;
* private final Bucket bucket;
*
* public Flusher (int interval, Bucket bucket) {
* this.interval = interval;
* this.bucket = bucket;
* }
*
* public void run () {
*
* final CSTimer tim = new CSTimer ();
* long timeout = tim.read () + interval;
*
* while (true) {
* tim.after (timeout);
* System.out.println ("*** Flusher: about to flush ...");
* final int n = bucket.flush ();
* System.out.println ("*** Flusher: number flushed = " + n);
* timeout += interval;
* }
* }
*
* }
*
*
*
* The Flying Dingbats
* This consists of many buckets, a single bucket keeper (responsible for * flushing the buckets) and flock of Dingbats (who regularly fall into various * buckets). Here is the system diagram: *
* import org.jcsp.lang.*;
*
* public class BucketExample2 {
*
* public static void main (String[] args) {
*
* final int minDingbat = 2;
* final int maxDingbat = 10;
* final int nDingbats = (maxDingbat - minDingbat) + 1;
*
* final int nBuckets = 2*maxDingbat;
*
* final Bucket[] bucket = Bucket.create (nBuckets);
*
* final int second = 1000;
* // JCSP timer units are milliseconds
* final int tick = second;
* final BucketKeeper bucketKeeper = new BucketKeeper (tick, bucket);
*
* final Dingbat[] dingbats = new Dingbat[nDingbats];
* for (int i = 0; i < dingbats.length; i++) {
* dingbats[i] = new Dingbat (i + minDingbat, bucket);
* }
*
* new Parallel (
* new CSProcess[] {
* bucketKeeper,
* new Parallel (dingbats)
* }
* ).run ();
*
* }
*
* }
*
* The BucketKeeper keeps time, flushing buckets in sequence at a steady rate.
* When the last one has been flushed, it starts again with the first:
*
* import org.jcsp.lang.*;
*
* class BucketKeeper implements CSProcess {
*
* private final long interval;
* private final Bucket[] bucket;
*
* public BucketKeeper (long interval, Bucket[] bucket) {
* this.interval = interval;
* this.bucket = bucket;
* }
*
* public void run () {
*
* String[] spacer = new String[bucket.length];
* spacer[0] = "";
* for (int i = 1; i < spacer.length; i++) {
* spacer[i] = spacer[i - 1] + " ";
* }
*
* final CSTimer tim = new CSTimer ();
* long timeout = tim.read ();
* int index = 0;
*
* while (true) {
* final int n = bucket[index].flush ();
* if (n == 0) {
* System.out.println (spacer[index] + "*** bucket " +
* index + " was empty ...");
* }
* index = (index + 1) % bucket.length;
* timeout += interval;
* tim.after (timeout);
* }
* }
*
* }
*
* So the buckets represent time values. A process falling into one of them will sleep
* until the prescribed time when the BucketKeeper next flushes it.
* * Dingbats live the following cycle. First, they do some work (rather brief * in the following code). Then, they work out which bucket to fall into and fall into it * - that is all. In this case, Dingbats just fly on id buckets * from whence they were just flushed (where id is the Dingbat number * indicated in the above network diagram): *
* import org.jcsp.lang.*;
*
* public class Dingbat implements CSProcess {
*
* private final int id;
* private final Bucket[] bucket;
*
* public Dingbat (int id, Bucket[] bucket) {
* this.id = id;
* this.bucket = bucket;
* }
*
* public void run () {
*
* int logicalTime = 0;
*
* String[] spacer = new String[bucket.length];
* spacer[0] = "";
* for (int i = 1; i < spacer.length; i++) {
* spacer[i] = spacer[i - 1] + " ";
* }
*
* String message = "Hello world from " + id + " ==> time = ";
*
* while (true) {
* logicalTime += id;
* final int slot = logicalTime % bucket.length;
* // assume: id <= bucket.length
* bucket[slot].fallInto ();
* System.out.println (spacer[slot] + message + logicalTime);
* // one unit of work
* }
* }
*
* }
*
*
* Danger - Race Hazard
* This example contains a race hazard whose elimination is left as an exercise * for the reader. The problem is to ensure that all flushed Dingbats have settled * in their next chosen buckets before the BucketKeeper next flushes it. * If a Dingbat is a bit slow, it may fall into its chosen bucket too late - * the BucketKeeper has already flushed it and the creature will have to remain * there until the next cycle. ** With the rate of flushing used in the above system, this is unlikely to happen. * But it is just possible - if something suspended execution of the system for * a few seconds immediately following a flush, then the BucketKeeper could * be rescheduled before the flying Dingbats. * *
Acknowledgement
* This example is from a discrete event modelling approach due to Jon Kerridge (Napier * University, Scotland). The Dingbats could easilly model their own timeouts * for themselves. However, setting a timeout is an O(n) operation * (where n is the number of processes setting them). Here, there is only one * process setting timeouts (the BucketKeeper) and the bucket operations * fallInto and flush have O(1) costs (at least, that is * the case for occam). ** Of course, removal of the above race hazard means that the timeout by * the BucketKeeper can also be eliminated. The buckets can be flushed just as * soon as it knows that the previously flushed Dingbats have settled. * In this way, the event model can proceed at full speed, maintaining correct * simulated time - each bucket representing one time unit - without needing any * timeouts in the simulation itself. *
* * @see org.jcsp.lang.Barrier * * @author P.H. Welch */ public class Bucket implements Serializable { /** * The number of processes currently enrolled on this bucket. */ private int nHolding = 0; /** * The monitor lock used for synchronization */ private final Object bucketLock = new Object(); /** * Barrier uses an even/odd flag because the barrier cannot sync without every process * Bucket can happily keep working while old processes are waiting around, so a flag is not enough * Instead, a count must be used. Theoretically this is unsafe, but the likelihood of the bucket * completing 4 *billion* cycles before the process wakes up is somewhat slim. */ private int bucketCycle = 0; /** * Fall into the bucket. * The process doing this will be blocked until the next {@link #flush}. */ public void fallInto() { synchronized (bucketLock) { nHolding++; // System.out.println ("Bucket.fallInto : " + nHolding); try { int spuriousCycle = bucketCycle; bucketLock.wait (); while (spuriousCycle == bucketCycle) { if (Spurious.logging) { SpuriousLog.record (SpuriousLog.BucketFallInto); } bucketLock.wait (); } } catch (InterruptedException e) { throw new ProcessInterruptedException ("*** Thrown from Bucket.fallInto ()\n" + e.toString ()); } } } /** * Flush the bucket. All held processes will be released. * It returns the number that were released. ** @return the number of processes flushed. */ public int flush () { synchronized (bucketLock) { // System.out.println ("Bucket.flush : " + nHolding); final int tmp = nHolding; nHolding = 0; bucketCycle += 1; bucketLock.notifyAll (); return tmp; } } /** * This returns the number of processes currently held in the bucket. * Note that this number is volatile - for information only! * By the time the invoker of this method receives it, it might have changed (because * of further processes falling into the bucket or someone flushing it). *
* @return the number of processes currently held in the bucket. */ public int holding () { synchronized (bucketLock) { return nHolding; } } /** * Creates an array of Buckets. *
* * @param n the number of Buckets to create in the array * @return the array of Buckets */ public static Bucket[] create (int n) { Bucket[] buckets = new Bucket[n]; for (int i = 0; i < n; i++) { buckets[i] = new Bucket (); } return buckets; } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/RejectableOne2OneChannel.java 0000644 0000000 0000000 00000006737 11105701167 021461 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** *
This implements a one-to-one object channel * for use by a single writer and single reader. Refer to {@link One2OneChannel} for a * description of this behaviour.
* *Additionally, this channel supports a reject operation. The reader may call
* the reject method to force any current writer to abort with a
* ChannelDataRejectedException. Subsequent read and write attempts will immediately cause a
* ChannelDataRejectedException.
Note that the reject operation cannot be called concurrently to a read.
* Implements a client end of a Connection which can have multiple * client processes. *
*
* This object cannot itself be shared between concurrent processes
* but duplicate objects can be generated that can be used by
* multiple concurrent processes. This can be achieved using
* the {@link #duplicate()} method.
*
* The reply from the server can be ALTed over. *
* * @author Quickstone Technologies Limited */ public class SharedAltingConnectionClient extends AltingConnectionClientImpl implements SharedConnectionClient { private ChannelInput synchIn; private ChannelOutput synchOut; private ConnectionWithSharedAltingClient parent; protected SharedAltingConnectionClient(AltingChannelInput fromServer, ChannelInput synchIn, ChannelOutput openToServer, ChannelOutput reqToServer, SharedChannelOutput synchOut, ChannelOutput backToClient, ConnectionWithSharedAltingClient parent) { super(fromServer, openToServer, reqToServer, backToClient); this.synchIn = synchIn; this.synchOut = synchOut; this.parent = parent; } protected final void claim() { synchOut.write(null); } protected final void release() { synchIn.read(); } /** *
* Returns a SharedConnectionClient object that is
* a duplicate of the object on which this method is called.
*
* This allows a process using a SharedAltingConnectionClient
* object to pass references to the connection client to multiple
* processes.
*
* The object returned can be cast into a
* SharedConnectionClient object.
*
SharedAltingConnectionClient object.
*/
public SharedConnectionClient duplicate()
{
return parent.client();
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelOutput.java 0000644 0000000 0000000 00000007676 11113671251 017535 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This defines the interface for writing to object channels.
* * A writing-end, conforming to this interface, * is obtained from a channel by invoking its out() method. *
Description
* ChannelOutput defines the interface for writing to object channels. * The interface contains only one method - write(Object o). * This method will block the calling process until the Object has * been accepted by the channel. In the (default) case of a zero-buffered * synchronising CSP channel, this happens only when a process at the other * end of the channel invokes (or has already invoked) a read(). ** ChannelOutput variables are used to hold channels * that are going to be used only for output by the declaring process. * This is a security matter -- by declaring a ChannelOutput * interface, any attempt to input from the channel will generate * a compile-time error. For example, the following code fragment will * not compile: * *
* Object doRead (ChannelOutput c) {
* return c.read (); // illegal
* }
*
*
* When configuring a CSProcess with output channels, they should
* be declared as ChannelOutput variables. The actual channel passed,
* of course, may belong to any channel class that implements
* ChannelOutput.
* * Instances of any class may be written to a channel. * *
Example
*
* void doWrite (ChannelOutput c, Object o) {
* c.write (o);
* }
*
*
* @see org.jcsp.lang.SharedChannelOutput
* @see org.jcsp.lang.ChannelInput
* @author P.D. Austin
*/
public interface ChannelOutput extends Poisonable
{
/**
* Write an Object to the channel.
*
* @param object the object to write to the channel
*/
public void write(Object object);
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/ConnectionArrayFactory.java 0000644 0000000 0000000 00000007432 11105701167 021361 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* Defines an interface for a factory that can create arrays of connections.
*
* @author Quickstone Technologies Limited
*/
public interface ConnectionArrayFactory
{
/**
* Constructs and returns an array of instances of an implementation of
* One2OneConnection.
*
* @param n the number of One2OneConnection objects
* to construct.
*
* @return the constructed array of One2OneConnection
* objects.
*/
public One2OneConnection[] createOne2One(int n);
/**
* Constructs and returns an array of instances of an implementation of
* Any2OneConnection.
*
* @param n the number of Any2OneConnection objects
* to construct.
*
* @return the constructed array of Any2OneConnection
* objects.
*/
public Any2OneConnection[] createAny2One(int n);
/**
* Constructs and returns an array of instances of an implementation of
* One2AnyConnection.
*
* @param n the number of One2AnyConnection objects
* to construct.
*
* @return the constructed array of One2AnyConnection
* objects.
*/
public One2AnyConnection[] createOne2Any(int n);
/**
* Constructs and returns an array of instances of an implementation of
* Any2AnyConnection.
*
* @param n the number of Any2AnyConnection objects
* to construct.
*
* @return the constructed array of Any2AnyConnection
* objects.
*/
public Any2AnyConnection[] createAny2Any(int n);
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/PoisonableOne2OneChannelIntImpl.java 0000644 0000000 0000000 00000025210 11113671251 022773 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
class PoisonableOne2OneChannelIntImpl implements One2OneChannelInt, ChannelInternalsInt
{
/** The monitor synchronising reader and writer on this channel */
private Object rwMonitor = new Object ();
/** The (invisible-to-users) buffer used to store the data for the channel */
private int hold;
/** The synchronisation flag */
private boolean empty = true;
/**
* This flag indicates that the last transfer went OK. The purpose is to not
* throw a PoisonException to the writer side when the last transfer went
* OK, but the reader side injected poison before the writer side finished
* processing of the last write transfer.
*/
private boolean done = false;
/**
* 0 means unpoisoned
*/
private int poisonStrength = 0;
/**
* Immunity is passed to the channel-ends, and is not used directly by the channel algorithms
*/
private int immunity;
/** The Alternative class that controls the selection */
private Alternative alt;
/** Flag to deal with a spurious wakeup during a write */
private boolean spuriousWakeUp = true;
private boolean isPoisoned() {
return poisonStrength > 0;
}
PoisonableOne2OneChannelIntImpl(int _immunity) {
immunity = _immunity;
}
/*************Methods from One2OneChannel******************************/
/**
* Returns the AltingChannelInput to use for this channel.
* As One2OneChannelImpl implements
* AltingChannelInput itself, this method simply returns
* a reference to the object that it is called on.
*
* @return the AltingChannelInput object to use for this
* channel.
*/
public AltingChannelInputInt in()
{
return new AltingChannelInputIntImpl(this,immunity);
}
/**
* Returns the ChannelOutput object to use for this channel.
* As One2OneChannelImpl implements
* ChannelOutput itself, this method simply returns
* a reference to the object that it is called on.
*
* @return the ChannelOutput object to use for this
* channel.
*/
public ChannelOutputInt out()
{
return new ChannelOutputIntImpl(this,immunity);
}
/*************Methods from ChannelOutput*******************************/
/**
* Writes an Object to the channel.
*
* @param value the object to write to the channel.
*/
public void write(int value) {
synchronized (rwMonitor) {
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
hold = value;
if (empty) {
empty = false;
if (alt != null) {
alt.schedule();
}
} else {
empty = true;
rwMonitor.notify();
}
try {
rwMonitor.wait();
while (spuriousWakeUp && !isPoisoned()) {
if (Spurious.logging) {
SpuriousLog.record(SpuriousLog.One2OneChannelWrite);
}
rwMonitor.wait();
}
spuriousWakeUp = true;
} catch (InterruptedException e) {
throw new ProcessInterruptedException(
"*** Thrown from One2OneChannel.write (Object)\n" + e.toString());
}
if (done) {
done = false;
} else if (isPoisoned()) {
throw new PoisonException(poisonStrength);
} else {
done = true;
}
}
}
/** ***********Methods from AltingChannelInput************************* */
/**
* Reads an Object from the channel.
*
* @return the object read from the channel.
*/
public int read () {
synchronized (rwMonitor) {
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
if (empty) {
empty = false;
try {
rwMonitor.wait ();
while (!empty && !isPoisoned()) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.One2OneChannelRead);
}
rwMonitor.wait ();
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException ("*** Thrown from One2OneChannel.read ()\n"
+ e.toString ());
}
} else {
empty = true;
}
spuriousWakeUp = false;
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
} else {
done = true;
rwMonitor.notify();
return hold;
}
}
}
public int startRead() {
synchronized (rwMonitor) {
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
if (empty) {
empty = false;
try {
rwMonitor.wait ();
while (!empty && !isPoisoned()) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.One2OneChannelRead);
}
rwMonitor.wait ();
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException ("*** Thrown from One2OneChannel.read ()\n"
+ e.toString ());
}
} else {
empty = true;
}
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
return hold;
}
}
public void endRead() {
synchronized (rwMonitor) {
spuriousWakeUp = false;
rwMonitor.notify ();
}
}
/**
* turns on Alternative selection for the channel. Returns true if the
* channel has data that can be read immediately.
* * Note: this method should only be called by the Alternative class * * @param alt the Alternative class which will control the selection * @return true if the channel has data that can be read, else false */ public boolean readerEnable (Alternative alt) { synchronized (rwMonitor) { if (isPoisoned()) { return true; } if (empty) { this.alt = alt; return false; } else { return true; } } } /** * turns off Alternative selection for the channel. Returns true if the * channel contained data that can be read. *
* Note: this method should only be called by the Alternative class * * @return true if the channel has data that can be read, else false */ public boolean readerDisable () { synchronized (rwMonitor) { alt = null; return !empty || isPoisoned(); } } /** * Returns whether there is data pending on this channel. *
* Note: if there is, it won't go away until you read it. But if there * isn't, there may be some by the time you check the result of this method. *
* This method is provided for convenience. Its functionality can be provided * by Pri Alting the channel against a SKIP guard, although * at greater run-time and syntactic cost. For example, the following code * fragment: *
* if (c.pending ()) {
* Object x = c.read ();
* ... do something with x
* } else (
* ... do something else
* }
*
* is equivalent to:
*
* if (c_pending.priSelect () == 0) {
* Object x = c.read ();
* ... do something with x
* } else (
* ... do something else
* }
*
* where earlier would have had to have been declared:
*
* final Alternative c_pending =
* new Alternative (new Guard[] {c, new Skip ()});
*
*
* @return state of the channel.
*/
public boolean readerPending () {
synchronized (rwMonitor) {
return !empty || isPoisoned();
}
}
public void writerPoison(int strength) {
if (strength > 0) {
synchronized (rwMonitor) {
this.poisonStrength = strength;
rwMonitor.notifyAll();
if (null != alt) {
alt.schedule();
}
}
}
}
public void readerPoison(int strength) {
if (strength > 0) {
synchronized (rwMonitor) {
this.poisonStrength = strength;
rwMonitor.notifyAll();
}
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelInternalsInt.java 0000644 0000000 0000000 00000004726 11113671251 020640 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
interface ChannelInternalsInt {
public int read();
public void write(int obj);
public int startRead();
public void endRead();
public boolean readerEnable(Alternative alt);
public boolean readerDisable();
public boolean readerPending();
/*//For Symmetric channel, later:
public boolean writerEnable(Alternative alt);
public boolean writerDisable();
public boolean writerPending();
*/
public void readerPoison(int strength);
public void writerPoison(int strength);
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/SharedChannelOutputInt.java 0000644 0000000 0000000 00000004742 11113671251 021326 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This is the same as {@link ChannelOutputInt} except that it is guaranteed
* safe to pass on to more than one internal process for parallel writing.
* * A writing-end, obtained from an any-one or any-any * channel by invoking its in() method, will implement this interface. * * @author Quickstone Technologies Limited */ public interface SharedChannelOutputInt extends ChannelOutputInt { } jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelInputIntImpl.java 0000644 0000000 0000000 00000004760 11113671251 020620 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; class ChannelInputIntImpl implements ChannelInputInt { private ChannelInternalsInt channel; private int immunity; ChannelInputIntImpl(ChannelInternalsInt _channel, int _immunity) { channel = _channel; immunity = _immunity; } public void endRead() { channel.endRead(); } public int read() { return channel.read(); } public int startRead() { return channel.startRead(); } public void poison(int strength) { if (strength > immunity) { channel.readerPoison(strength); } } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/CSTimer.java 0000644 0000000 0000000 00000022321 11105701167 016233 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * This is a {@link Guard} for setting timeouts in an {@link Alternative}. *
Description
* CSTimer is a {@link Guard} for setting timeouts in an * {@link Alternative}. It also provides the current system time * and can set straight (i.e. committed) timeouts. The timeouts * are in terms of absolute time values - not relative delays. ** Note: for those familiar with the occam multiprocessing * language, CSTimer gives the semantics of the * TIMER type (including its use as a guard in an * ALT construct). *
* Warning: a CSTimer records the timeout value for use by an * {@link Alternative}. Therefore, different CSTimers * must be used by different processes - the same CSTimer * must not be shared. *
* Implementation note: all CSTimers currently * use the same System.currentTimeMillis time. *
*Examples
* The use of a CSTimer for setting timeouts on channel input is documented * in the {@link Alternative} class (see the examples * A Fair Multiplexor with a Timeout * and A Simple Traffic Flow Regulator). ** Here, we just show its use for setting committed timeouts. Regular * generates a regular stream of output on its out channel. The rate * of output is determined by its interval parameter. Recall that timeouts * implemented by CSTimer are in terms of absolute time values. * Notice that the sequence of output times maintains * an arithmetic progression. Any delays in completing each cycle (e.g. caused by * the process scheduler or the lateness of the process synchronising with us to accept * our data) will be compensated for automatically - the output sequence always returns * to its planned schedule whenever it can. *
* import org.jcsp.lang.*;
*
* public class Regular implements CSProcess {
*
* final private ChannelOutput out;
* final private Integer N;
* final private long interval;
*
* public Regular (final ChannelOutput out, final int n, final long interval) {
* this.out = out;
* this.N = new Integer (n);
* this.interval = interval;
* }
*
* public void run () {
*
* final CSTimer tim = new CSTimer ();
* long timeout = tim.read (); // read the (absolute) time once only
*
* while (true) {
* out.write (N);
* timeout += interval; // set the next (absolute) timeout
* tim.after (timeout); // wait until that (absolute) timeout
* }
* }
*
* }
*
*
* For convenience, a {@link #sleep sleep} method that blocks for a specified
* time period (in milliseconds) is also provided. This has the same semantics as
* {@link java.lang.Thread#sleep(long) java.lang.Thread.sleep}.
* [Note: programming a regular sequence of events is a little easier using
* {@link #after after} (as in the above) rather than {@link #sleep sleep}.]
*
* @see org.jcsp.lang.Alternative
* @see org.jcsp.lang.Guard
*
* @author P.D. Austin
* @author P.H. Welch
*/
public class CSTimer extends Guard
{
/**
* The absolute timeout value set for the Alternative.
*
* If this is used without setAlarm(msecs) ever having been invoked,
* the wake-up call is set at time zero, which will always be in
* the past. So, the Alternative will see the timeout
* as having occurred.
*
*/
private long msecs = 0;
/**
* Sets the absolute timeout value that will trigger an Alternative
* select operation (when this CSTimer is one of the guards
* with which that Alternative was constructed).
*
* @param msecs the absolute timeout value.
*/
public void setAlarm(final long msecs)
{
this.msecs = msecs;
}
/**
* Returns the alarm value that has been set by the previous call to
* {@link #setAlarm(long)}.
*/
public long getAlarm()
{
return msecs;
}
/**
* Sets the absolute timeout value that will trigger an Alternative
* select operation (when this CSTimer is one of the guards
* with which that Alternative was constructed).
*
* @param msecs the absolute timeout value.
*
* @deprecated Use {@link #setAlarm(long)} - this name caused confusion with
* the idea of setting the current time (a concept that is not supported).
*/
public void set(final long msecs)
{
this.msecs = msecs;
}
/**
* Returns the current system time in msecs.
*
* @return the current system time in msecs
*/
public long read()
{
return System.currentTimeMillis();
}
/**
* Puts the process to sleep until an absolute time is reached.
*
* @param msecs the absolute time awaited. Note: if this time has already been reached, this returns straight away.
*/
public void after(final long msecs)
{
final long delay = msecs - System.currentTimeMillis();
if (delay > 0)
try
{
Thread.sleep(delay);
}
catch (InterruptedException e)
{
throw new ProcessInterruptedException
("*** Thrown from CSTimer.after (long)\n" + e.toString());
}
}
/**
* Puts the process to sleep for a specified time (milliseconds).
*
* @param msecs the length of the sleep period. Note: if this is negative, this returns straight away.
*/
public void sleep(final long msecs)
{
if (msecs > 0)
try
{
Thread.sleep(msecs);
}
catch (InterruptedException e)
{
throw new ProcessInterruptedException
("*** Thrown from CSTimer.sleep (long)\n" + e.toString());
}
}
/**
* Enables this guard.
*
* @param alt the Alternative doing the enabling.
*/
boolean enable (Alternative alt) {
if ((msecs - System.currentTimeMillis ()) <= Spurious.earlyTimeout) {
return true;
} else {
alt.setTimeout (msecs);
return false;
}
}
/**
* Disables this guard.
*/
boolean disable () {
// final long now = System.currentTimeMillis ();
// System.out.println ("*** CSTimer.disable: " + msecs + ", " + now);
// return (msecs <= now);
return ((msecs - System.currentTimeMillis ()) <= Spurious.earlyTimeout);
// WARNING: the above is an insufficient test to see if the timeout
// has expired ... since Java wait-with-timeouts sometimes return
// early! See the implementation of Alternative for a work-around.
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Any2AnyCallChannel.java 0000644 0000000 0000000 00000057522 11113671251 020305 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import java.io.Serializable;
/**
* This is the super-class for any-to-any interface-specific CALL channels,
* safe for use by many clients and many servers.
* * Shortcut to the Constructor and Method Summaries. * *
Description
* Please see {@link One2OneCallChannel} for general information about CALL channels. * Documented here is information specific to this any-any version. * *Converting a Method Interface into a Variant CALL Channel
* Constructing a any-any CALL channel for a specific interface * follows exactly the same pattern as in the 1-1 case. Of course, it must * extend Any2AnyCallChannel rather than One2OneCallChannel. ** For example, using the same Foo * interface as before, we derive: *
* import org.jcsp.lang.*;
*
* public class Any2AnyFooChannel extends Any2AnyCallChannel implements Foo {
*
* ... same body as One2OneFooChannel
*
* }
*
*
* Calling a CALL Channel
* All the client needs to see is the method interface * implemented by the CALL channel. So far as the client is concerned, therefore, * there is no difference between any of the varieties of CALL channel * - it just makes the call. * *Accepting a CALL Channel
* The mechanics of accepting a CALL channel are the same for all varieties. * However, the server should declare which kind (or kinds) it allows * to be attached: *
* import org.jcsp.lang.*;
*
* class B implements CSProcess, Foo {
*
* private final ChannelAccept in;
*
* public B (final One2OneFooChannel in) { // original constructor
* this.in = in;
* }
*
* public B (final Any2AnyFooChannel in) { // additional constructor
* this.in = in;
* }
*
* ... rest as before
*
* }
*
* When wrapping the above to hide its raw method interface, don't forget to include
* the extra constructor(s):
*
* import org.jcsp.lang.*;
*
* public class B2 implements CSProcess { // no Foo interface
*
* private final B b;
*
* public B2 (final One2OneFooChannel in) { // original constructor
* b = new B (in);
* }
*
* public B2 (final Any2AnyFooChannel in) { // additional constructor
* b = new B (in);
* }
*
* public void run () {
* b.run ();
* }
*
* }
*
*
* ALTing on a CALL Channel
* As for ordinary channels, ALTing over 1-any or any-any versions * is not supported. Hence, a server can only choose to {@link #accept accept} * or not to accept a Any2AnyFooChannel - it cannot back off because * of some other event. * *Building a CALL Channel Network
* Network building with CALL channels is the same as building with ordinary * channels. First construct the channels and, then, construct the processes * - plugging in the channels as required and running them in {@link Parallel}. ** For example, the network consisting of several clients and several servers: *
* Any2AnyFooChannel c = new Any2AnyFooChannel ();
*
* final A[] aClients = new A[n_aClients];
* for (int i = 0; i < aClients.length; i++) {
* aClients[i] = new A (c);
* }
*
* final B2[] bServers = new B2[n_bClients];
* for (int i = 0; i < bServers.length; i++) {
* bServers[i] = new B2 (c);
* }
*
* new Parallel (
* new CSProcess[] {
* new Parallel (aClients),
* new Parallel (bServers)
* }
* ).run ();
*
* The clients compete with each other to find a server and the servers
* compete with each other to find a client. A client must not care which
* server it gets and vice-versa. The any-any CALL channel strictly
* serialises client-server transactions - only one at a time can actually take place.
*
* * It is a good idea, therefore, to restrict the duration of the CALL to as short a period * as possible, so that other clients and servers are not unnecessarilly delayed. * For instance, the any-any CALL can be used just to enable a client and server * find one another. During the CALL, the client could give the server * a private direct line (e.g. a 1-1 CALL channel) on which it promises to call back * after hanging up on the shared one. The server could reply with special * information (such as how long it is prepared to wait for that call back). In this way, * multiple client-server transactions could proceed concurrently. An example is * given below. * *
Example
* This further develops the CALL channel version of * the Wot-no-Chickens example, introduced in Any2OneCallChannel. ** The college authorities have decided to charge its philosophers for all the chickens they are * consuming. Unfortunately, getting the canteen to collect money from the customers would mean * that its serviceTime would have to be increased from its present zero to one second. * Since the canteen can only do one thing at a time, a new form of delay would be introduced into * the system. Since the philosophers only think for a maximum of three seconds in between * trying to eat, having them wait around (possibly for several seconds) while their colleagues * make their purchases is deemed unacceptable. *
* The college has decided, therefore, to make some new investments. Students are to be employed * to sell the chickens from the canteen. Each student is equipped with a hot-plate on which can * be (indefinitely) stored one hot chicken, straight from the canteen. The student can get a chicken * from the canteen (if the canteen has some available) still with the same zero serviceTime * as before - the canteen has not changed. Students that have chickens compete with each other * to service any customers. Servicing a customer means collecting some money and giving change, * which takes one second, as well as handing over the chicken. *
* Hungry philosophers compete with each other to find any student who is ready for * a customer. Students and philosophers find each other through a any-any CALL * channel. However, if the full transaction (which includes a delay of one second) were * to take place over that shared channel, the college would be no better off! * The canteen-students system would still only be dealing with one customer at a time. *
* Therefore, the good idea mentioned at the end of * the previous section is employed to enable student-philosopher transactions to proceed * in parallel. The any-any shared channel is used only for a philosopher * to pass over a private direct 1-1 line to a student and to exchange names * (out of politeness). The bulk of all transactions takes place in parallel * over unshared lines. *
* Here is the fixed part of the network diagram for the new college. The 1-1 * channels for private communication between a philosopher (Prof) and * a student (Student) are dynamically connected, continually changing and, * therefore, not shown: *
The Student
* Each student process is a server on its studentService channel and * a client on its canteenService. * As with the Canteen server, * we have chosen to define the Student service interface and associated CALL * channel class as inner declarations: *
* import org.jcsp.lang.*;
*
* class Student implements CSProcess {
*
* public static interface Service {
* public String hello (String profId,
* Canteen.One2OneServiceChannel service);
* }
*
* public static class Any2AnyServiceChannel
* extends Any2AnyCallChannel implements Service {
* public String hello (String profId,
* Canteen.One2OneServiceChannel service) {
* join ();
* String n = ((Service) server).hello (profId, service);
* fork ();
* return n;
* }
* }
*
* Note that the hello CALL offers the caller's name and private 1-1 channel.
* These will be saved and the student's name returned when the student accepts the CALL.
* Notice also that that private channel instances the 1-1 Service channel
* exported by the Canteen.
* This is not surprising since the student, who will accept the CALL on that line, will be
* acting on behalf of the canteen - one of many proxies set up by the college to reduce
* the service bottleneck caused by the newly introduced charges.
* * Following the same pattern as for the Canteen, we next set up the constructor * and the local fields for saving its parameters: *
* private final String id;
* private final ChannelAccept studentService;
* // provide service on this line
* private final Canteen.Service canteenService;
* // act as a client on this line
* private final int serviceTime;
*
* public Student (String id, Any2AnyServiceChannel studentService,
* Canteen.Service canteenService, int serviceTime) {
* this.id = id;
* this.studentService = studentService;
* this.canteenService = canteenService;
* this.serviceTime = serviceTime;
* }
*
* Now, we need to combine the exported interfaces into a single one so that the inner process
* can be created (anonymously) by this wrapper's run method:
*
* private interface inner extends CSProcess, Service, Canteen.Service {};
*
* public void run () {
*
* new inner () {
*
* private AltingChannelAccept service;
* // place holder for the private line
* private int nServed = 0;
*
* private final CSTimer tim = new CSTimer ();
*
* Impementations of the required CALL interfaces (including the one for the channel
* privately supplied) come next:
*
* public String hello (String profId,
* Canteen.One2OneServiceChannel service) {
* this.service = service;
* System.out.println (" Student " + id + " -> Prof " +
* profId + " : hello ... ");
* return id;
* }
*
* public int takeChicken (String profId) {
* System.out.println (" Student " + id + " -> Prof +"
* profId + " : that'll be 1-95 please ... ");
* tim.sleep (serviceTime); // take the money and give any change
* nServed++;
* System.out.println (" Student " + id + " -> Prof "
* + profId + " : thank you - have a nice day ["
* + nServed + " served]");
* return 1;
* }
*
* and the run method that conducts everything:
*
* public void run () {
* System.out.println (" Student " + id + " : starting ... ");
* while (true) {
* canteenService.takeChicken (id);
* // make a client CALL on the canteen
* System.out.println (" Student " + id +
* " : got chicken ... ready to serve ...");
* studentService.accept (this); // customer makes contact
* service.accept (this); // deal with customer
* }
* }
*
* Finally, don't forget to run this inner process:
* * }.run (); * } * } ** *
The Professor
* Professors behave in pretty much the same way as * philosophers. * The only difference is that they communicate with * the student proxies, rather than directly with * the canteen. For this, * each needs to keep a private channel up its sleeve: *
* import org.jcsp.lang.*;
*
* class Prof implements CSProcess {
*
* private final String id;
* private final Student.Service studentService;
* private final int thinkTime;
* private final int eatTime;
* private final boolean greedy;
*
* public Prof (String id, Student.Service studentService,
* int thinkTime, int eatTime, boolean greedy) {
* this.id = id;
* this.studentService = studentService;
* this.thinkTime = thinkTime;
* this.eatTime = eatTime;
* this.greedy = greedy;
* }
*
* public void run () {
* final CSTimer tim = new CSTimer ();
* final Canteen.One2OneServiceChannel service =
* new Canteen.One2OneServiceChannel ();
* // This is the private channel for
* // direct communication with a student
* int nEaten = 0;
* while (true) {
* if (! greedy) {
* System.out.println (" Prof " + id + " : thinking ...");
* tim.sleep (thinkTime); // thinking
* }
* System.out.println (" Prof " + id + " : gotta eat ...");
* String student = studentService.hello (id, service);
* // find a student
* System.out.println (" Prof " + id + " -> Student "
* + student +
* " : hi, can I have a chicken please?");
* int chicken = service.takeChicken (id);
* // and pay up ...
* nEaten++;
* System.out.println (" Prof " + id +
* " : mmm ... that's good [" +
* nEaten + " so far]");
* tim.sleep (eatTime); // eating
* }
* }
*
* }
*
*
* The New College
* The new charges slow down the speed with which the professors can get their chickens * (although not their eating of them). Most affected are the greedy ones who can * no longer consume at a rate approaching 10 per second (whilst supplies hold out) but * now have to wait a whole second simply to make a purchase. Bill, therefore, * should not get quite so sick. Notice that, so long as supplies hold out and there * are enough students, philosophers are not delayed by each other - their purchases * will be made in parallel. ** For convenience, the college network diagram is reproduced here - naming some more * of the characters. The new college seems to have attracted some good students: *
* import org.jcsp.lang.*;
*
* class NewCollege implements CSProcess {
*
* public void run () {
*
* final String[] profId = {"Bill", "Hilary", "Gennifer",
* "Paula", "Monica"};
* final String[] studentId = {"Occam", "Babbage",
* "Einstein", "Turing"};
*
* final int thinkTime = 3000; // 3 seconds
* final int eatTime = 100; // 100 milliseconds
*
* final int studentServiceTime = 1000; // 1 second
*
* final int canteenServiceTime = 0; // 0 seconds
* final int canteenSupplyTime = 3000; // 3 seconds
* final int maxChickens = 50;
*
* final Student.Any2AnyServiceChannel studentService
* = new Student.Any2AnyServiceChannel ();
* final Canteen.Any2OneServiceChannel canteenService
* = new Canteen.Any2OneServiceChannel ();
* final Canteen.Any2OneSupplyChannel supply
* = new Canteen.Any2OneSupplyChannel ();
*
* final Student[] students = new Student[studentId.length];
* for (int i = 0; i < students.length; i++) {
* students[i] = new Student (studentId[i], studentService,
* canteenService, studentServiceTime);
* }
*
* final Prof[] profs = new Prof[profId.length];
* for (int i = 0; i < profs.length; i++) {
* profs[i] = new Prof (profId[i], studentService,
* thinkTime, eatTime, i == 0);
* }
*
* new Parallel (
* new CSProcess[] {
* new Clock (),
* new Canteen (canteenService, supply,
* canteenServiceTime, canteenSupplyTime, maxChickens),
* new Parallel (students),
* new Parallel (profs),
* new Chef ("Pierre", 4, 2000, supply),
* // chefId, batchSize, batchTime
* new Chef ("Henri", 10, 20000, supply),
* new Chef ("Sid", 100, 150000, supply)
* }
* ).run ();
*
* }
* public static void main (String argv[]) {
* new NewCollege ().run ();
* }
* }
*
*
* @see org.jcsp.lang.One2OneCallChannel
* @see org.jcsp.lang.Any2OneCallChannel
* @see org.jcsp.lang.One2AnyCallChannel
* @see org.jcsp.lang.Alternative
*
* @author P.H. Welch
*/
public abstract class Any2AnyCallChannel implements ChannelAccept, Serializable
{
/**
* This is used to synchronise the calling and accepting process.
*/
final private Any2OneChannelImpl c = new Any2OneChannelImpl();
/**
* This is used to synchronise the calling and accepting process.
*/
final private One2OneChannelImpl d = new One2OneChannelImpl();
/**
* This holds a reference to a server process so that a client may
* make the call. The reference is only valid between the {@link #join join}
* and {@link #fork fork} elements of the standard
* calling sequence.
* As shown in that sequence, it will need casting up to the relevant interface
* supported by the specific CALL channel derived from this class.
*/
protected CSProcess server;
/**
* This may be set during the standard
* calling sequence to record
* which method was invoked by a client. It is only safe to do this between
* the {@link #join join} and {@link #fork fork} elements of
* that sequence. Either all the CALL
* channel methods should do this or none - in the latter case, its default
* value remains as zero. Its value is returned to a server as the result
* the server's invocation of {@link #accept accept}.
*/
protected int selected = 0;
/**
* This is invoked by a server when it commits to accepting a CALL
* from a client. The parameter supplied must be a reference to this server
* - see the example from {@link One2OneCallChannel}.
* It will not complete until a CALL has been made. If the derived CALL channel has set
* the {@link #selected} field in the way defined by the standard
* calling sequence,
* the value returned by this method will indicate which method was called.
*
* @param server the server process receiving the CALL.
*/
public synchronized int accept(CSProcess server)
{
this.server = server;
c.read(); // ready to ACCEPT the CALL
d.read(); // wait until the CALL is complete
return selected;
}
/**
* This is invoked by a client during the standard
* calling
* sequence. It will not complete until a server invokes
* an {@link #accept accept} on this channel. In turn, that accept
* will not complete until the client invokes a {@link #fork fork},
* after having made its CALL on the server.
*/
protected void join()
{
c.write(null);
}
/**
* This is invoked by a client during the standard
* calling
* sequence. A server must have invoked an {@link #accept accept}
* for the client to have got this far in the sequence - see
* the {@link #join join}. This call unblocks that accept,
* releasing the server and client to resume separate lives.
*/
protected void fork()
{
d.write(null);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Any2AnyIntImpl.java 0000644 0000000 0000000 00000007071 11113671251 017507 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
class Any2AnyIntImpl implements Any2AnyChannelInt, ChannelInternalsInt {
private ChannelInternalsInt channel;
/** The mutex on which readers must synchronize */
private final Mutex readMutex = new Mutex();
private final Object writeMonitor = new Object();
Any2AnyIntImpl(ChannelInternalsInt _channel) {
channel = _channel;
}
public SharedChannelInputInt in() {
return new SharedChannelInputIntImpl(this,0);
}
public SharedChannelOutputInt out() {
return new SharedChannelOutputIntImpl(this,0);
}
public void endRead() {
channel.endRead();
readMutex.release();
}
public int read() {
readMutex.claim();
// A poison exception might be thrown, hence the try/finally:
try
{
return channel.read();
}
finally
{
readMutex.release();
}
}
//begin never used:
public boolean readerDisable() {
return false;
}
public boolean readerEnable(Alternative alt) {
return false;
}
public boolean readerPending() {
return false;
}
//end never used
public void readerPoison(int strength) {
readMutex.claim();
channel.readerPoison(strength);
readMutex.release();
}
public int startRead() {
readMutex.claim();
try
{
return channel.startRead();
}
catch (RuntimeException e)
{
channel.endRead();
readMutex.release();
throw e;
}
}
public void write(int n) {
synchronized (writeMonitor) {
channel.write(n);
}
}
public void writerPoison(int strength) {
synchronized (writeMonitor) {
channel.writerPoison(strength);
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/PoisonableBufferedOne2AnyChannelInt.java 0000644 0000000 0000000 00000004351 11113671251 023625 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.ints.ChannelDataStoreInt;
class PoisonableBufferedOne2AnyChannelInt extends One2AnyIntImpl
{
PoisonableBufferedOne2AnyChannelInt(ChannelDataStoreInt _data, int _immunity) {
super(new PoisonableBufferedOne2OneChannelInt(_data,_immunity));
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Any2AnyChannelInt.java 0000644 0000000 0000000 00000013631 11113671251 020155 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This defines an interface for an any-to-any integer channel,
* safe for use by many writers and many readers.
* * The only methods provided are to obtain the ends of the channel, * through which all reading and writing operations are done. * Only an appropriate channel-end should be plugged into a process * – not the whole channel. * A process may use its external channels in one direction only * – either for writing or reading. *
*Actual channels conforming to this interface are made using the relevant * static construction methods from {@link Channel}. * Channels may be {@link Channel#any2anyInt() synchronising}, * {@link Channel#any2anyInt(org.jcsp.util.ints.ChannelDataStoreInt) buffered}, * {@link Channel#any2anyInt(int) poisonable} * or {@link Channel#any2anyInt(org.jcsp.util.ints.ChannelDataStoreInt,int) both} * (i.e. buffered and poisonable). *
*Description
* Any2AnyChannelInt is an interface for a channel which * is safe for use by many reading and writing processes. Reading processes * compete with each other to use the channel. Writing processes compete * with each other to use the channel. Only one reader and one writer will * actually be using the channel at any one time. This is managed by the * channel – user processes just read from or write to it. * ** Please note that this is a safely shared channel and not * a broadcaster or message gatherer. Currently, broadcasting or gathering has to be managed by * writing active processes (see {@link org.jcsp.plugNplay.DynamicDelta} * for an example of broadcasting). *
** All reading processes and writing processes commit to the channel * (i.e. may not back off). This means that the reading processes * may not {@link Alternative ALT} on this channel. *
** The default semantics of the channel is that of CSP – i.e. it is * zero-buffered and fully synchronised. A reading process must wait * for a matching writer and vice-versa. *
** The static methods of {@link Channel} construct channels with * either the default semantics or with buffering to user-specified capacity * and a range of blocking/overwriting policies. * Various buffering plugins are given in the org.jcsp.util package, but * careful users may write their own. *
** The {@link Channel} methods also provide for the construction of * {@link Poisonable} channels and for arrays of channels. * *
Implementation Note and Caution
* Fair servicing of readers and writers to this channel depends on the fair * servicing of requests to enter a synchronized block (or method) by * the underlying Java Virtual Machine (JVM). Java does not specify how threads * waiting to synchronize should be handled. Currently, Sun's standard JDKs queue * these requests - which is fair. However, there is at least one JVM * that puts such competing requests on a stack - which is legal but unfair * and can lead to infinite starvation. This is a problem for any Java system * relying on good behaviour from synchronized, not just for these * any-any channels. * * @see org.jcsp.lang.Channel * @see org.jcsp.lang.One2OneChannelInt * @see org.jcsp.lang.Any2OneChannelInt * @see org.jcsp.lang.One2AnyChannelInt * @see org.jcsp.util.ints.ChannelDataStoreInt * * @author P.D. Austin and P.H. Welch */ public interface Any2AnyChannelInt { /** * Returns the input channel end. */ public SharedChannelInputInt in(); /** * Returns the output channel end. */ public SharedChannelOutputInt out(); } jcsp-1.1-rc4.orig/src/org/jcsp/lang/Barrier.java 0000644 0000000 0000000 00000056504 11113671251 016324 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; import java.io.Serializable; /** * This enables barrier synchronisation between a set of processes. ** Shortcut to the Constructor and Method Summaries. * *
Description
* A channel is a CSP event in which only two processes (the reader and * the writer) synchronise. A barrier is a CSP event in which any number of * processes may synchronise. Any process synchronising on a barrier will be * blocked until all processes associated with that barrier have synchronised. * A process may not back off an attempted synchronisation - i.e. barriers cannot be * used as guards in an {@link Alternative}. * Applications needing that capability should use an {@link AltingBarrier}. ** A process network may contain many barriers - each being associated with a different * subset of processes. These subsets may overlap and change at run-time. JCSP does not * currently provide a checked way of associating a process with a particular barrier. * That could be done, but would carry a syntactic and run-time overhead currently not * thought worthwhile. Associating a barrier with its correct set of processes is * a design issue and it is left to the designer to ensure correct useage. *
* Note: this notion of barrier corresponds to the * BARRIER * synchronisation primitive added to the * KRoC * occam-pi language system. * *
Deterministic Barriers
* If the set of processes associated with a barrier remains fixed, barrier synchronisation * introduces no non-determinism. So, a parallel system made up of processes, * barriers (with fixed barrier sets) and 1-1 channels (with no ALTing on the channels and * an exclusive read/write access discipline for all communicated objects) is deterministic * - its semantics are independent of scheduling. *
* For fixed barrier sets, {@link #Barrier(int)
* For example, here is a fixed set of 10 processes synchronising on a shared barrier: *
* import org.jcsp.lang.*;
*
* public class BarrierExample1 {
*
* public static void main (String[] args) {
*
* final int nPlayers = 10;
*
* final Barrier barrier = new Barrier (nPlayers);
*
* final Player[] players = new Player[nPlayers];
* for (int i = 0; i < players.length; i++) {
* players[i] = new Player (i, nPlayers, barrier);
* }
*
* new Parallel (players).run ();
*
* }
*
* }
*
* To synchronise on a barrier, a process just needs to invoke its {@link #sync sync}
* method. For example:
*
* import org.jcsp.lang.*;
*
* public class Player implements CSProcess {
*
* private final int id, nPlayers;
* private final Barrier barrier;
*
* public Player (int id, int nPlayers, Barrier barrier) {
* this.id = id;
* this.nPlayers = nPlayers;
* this.barrier = barrier;
* }
*
* public void run () {
* final CSTimer tim = new CSTimer ();
* final long second = 1000; // JCSP timer units are milliseconds
* int busy = id + 1;
* while (true) {
* tim.sleep (busy*second); // application specific work
* System.out.println ("Player " + id + " at the barrier ...");
* barrier.sync ();
* System.out.println ("\t\t\t... Player " + id + " over the barrier");
* busy = (nPlayers + 1) - busy; // just to make it more interesting
* }
* }
*
* }
*
* The sleep period above represents some work carried out by each Player.
* This work takes a different amount of time in each cycle and varies from player to player.
* At the end of each piece of work, each player waits for all its colleagues before continuing
* its next cycle.
*
* Non-Deterministic Barriers
* A process may choose at any time to {@link #enroll enroll} or {@link #resign resign} from * any barrier it can see. It should not, of course, enroll on a barrier with which * it is already associated - nor resign from a barrier with which it isn't! Because * these operations are internal choices of individual processes and because they have an impact on * the synchronisation properties of their environment, the resulting system is non-deterministic. * *
* The TimeKeeper synchronises on the barrier at a regular rate (once per second) * and, thus, coordinates the activities of all working Workers. * A work unit can only start at the beginning of one of the TimeKeeper's * time slots and each Worker can only perform one work unit per time slot. * Should any work unit overrun a time slot, subsequent units (for all Workers) * will have a late start. * However, the system is stable - so long as there is some slack in the system * (i.e. units do not generally overrun), the original schedule will be recovered. *
* Here is the code for the complete system. * The barrier is initialised to just 1, since only the TimeKeeper * is permanently associated with it. * The barrier is passed to all Workers as well as to the TimeKeeper: *
* import org.jcsp.lang.*;
*
* public class BarrierExample2 {
*
* public static void main (String[] args) {
*
* final int nWorkers = 10;
* final int rogue = 5;
*
* final int second = 1000;
* // JCSP timer units are milliseconds
* final int tick = 1*second;
* final int maxWork = tick;
* // raise this to allow workers to overrun
*
* final long seed = new CSTimer ().read ();
*
* final Barrier barrier = new Barrier (1);
*
* final TimeKeeper timeKeeper = new TimeKeeper (tick, barrier);
*
* final Worker[] workers = new Worker[nWorkers];
* for (int i = 0; i < workers.length; i++) {
* workers[i] = new Worker (i, i + seed, maxWork, i == rogue, barrier);
* }
*
* new Parallel (
* new CSProcess[] {
* timeKeeper,
* new Parallel (workers)
* }
* ).run ();
* }
* }
*
* As well as the barrier, each Worker is given its id, a (unique)
* seed for its random number generator, its maximum work unit time and whether it is
* a rogue. A rogue worker deliberately overruns its last unit of work for each
* working session to test out the stability of the system:
*
* import org.jcsp.lang.*;
* import java.util.*;
*
* public class Worker implements CSProcess {
*
* private final int id;
* private final long seed;
* private final int maxWork;
* private final boolean rogue;
* private final Barrier barrier;
*
* public Worker (int id, long seed, int maxWork,
* boolean rogue, Barrier barrier) {
* this.id = id;
* this.seed = seed;
* this.maxWork = maxWork;
* this.rogue = rogue;
* this.barrier = barrier;
* }
*
* public void run () {
*
* final Random random = new Random (seed);
* // each process gets a different seed
*
* final CSTimer tim = new CSTimer ();
* final int second = 1000;
* // JCSP timer units are milliseconds
*
* final int minRest = 3*second;
* final int maxRest = (id + 10)*second;
* final int nWorkUnits = id + 1;
*
* final String starting = "\tWorker " + id
* + " starting ...";
* final String working = "\t\t\t ... Worker " + id
* + " working ...";
* final String resting = "\t\t\t\t\t ... Worker "
* + id + " resting ...";
*
* while (true) {
* barrier.enroll ();
* System.out.println (starting);
* for (int i = 0; i < nWorkUnits; i++) {
* barrier.sync ();
* System.out.println (working);
* tim.sleep (random.nextInt (maxWork));
* //these lines represent one unit of work
* }
* if (rogue) tim.sleep (maxWork);
* // try to throw the timekeeper
* barrier.resign ();
* System.out.println (resting);
* tim.sleep (minRest + random.nextInt (maxRest));
* }
* }
*
* }
*
* Note that the {@link #resign resign} method also performs a (non-blocking) synchronisation
* on the barrier as well as the resignation. This is crucial since, if the resigner were
* the last process associated with a barrier not to have invoked a {@link #sync sync},
* its resignation must complete the barrier (as though it had invoked a sync)
* and release all the remaining associated processes.
* * The TimeKeeper is passed its tick interval and the Barrier. * It is pre-enrolled with the Barrier and remains permanently associated: *
* import org.jcsp.lang.*;
*
* public class TimeKeeper implements CSProcess {
*
* private final long interval;
* private final Barrier barrier;
*
* public TimeKeeper (long interval, Barrier barrier) {
* this.interval = interval;
* this.barrier = barrier;
* }
*
* public void run () {
*
* final CSTimer tim = new CSTimer ();
* long timeout = tim.read () + interval;
*
* while (true) {
* tim.after (timeout);
* barrier.sync ();
* System.out.println ("[" + (tim.read () - timeout) + "]");
* timeout += interval;
* }
* }
*
* }
*
* The print statement from the TimeKeeper gives an upper bound on how far each
* timeslot strays from its schedule. JCSP {@link CSTimer CSTimer}s are currently implemented
* on top of standard Java APIs (Thread.sleep and Object.wait).
* Depending on the underlying JVM, this should stay close to zero (milliseconds) - except
* when the rogue Worker deliberately overruns a work unit.
* Other events may also disturb the schedule - e.g. a Ctl-S/Ctl-Q from
* the user to pause/resume output or some transient fit of activity from
* the operating system. Some JVMs also return early from some timeouts - i.e. the timeslot
* starts early, which gives rise to an occasional negative report from the TimeKeeper.
* * Bear also in mind that the TimeKeeper's print statement has to compete with * the print statements from all working Workers. All are scheduled to execute * at the start of each timeslot and may be arbitrarilly interleaved. * This may be confusing when interpreting the output from the system. *
* To clarify what's happening, we can arrange for the TimeKeeper's message * to be printed first for each timeslot, before any from the Workers. * To do this, we need to stall those Workers temporarilly until we know that * the TimeKeeper has reported. A simple way to do that is to double up on * the barrier synchronisation. For the Worker, modify its working loop: *
* for (int i = 0; i < nWorkUnits; i++) {
* barrier.sync (); // wait for everyone
* barrier.sync (); // wait for the Timekeeper to report
* System.out.println (working);
* tim.sleep (random.nextInt (maxWork));
* }
*
* For the TimeKeeper, modify its run loop:
*
* while (true) {
* tim.after (timeout);
* barrier.sync (); // wait for everyone
* System.out.println ("[" + (tim.read () - timeout) + "]");
* barrier.sync (); // let the Workers get going
* timeout += interval;
* }
*
*
* Overheads
* Free use of additional synchronisations to gain special control (such as in the above) * depends on the overheads being not so great as to render that control pointless. ** Going back to the original example, the entire barrier * synchronisation could be discarded by dropping the TimeKeeper and making each * Worker responsible for its own time schedule. * However, setting n timeouts (where each setting has O(n) overheads) * needs to be compared against setting 1 timeout (by the TimeKeeper) * together with a (n+1)-way barrier synchronisation. *
* For the current implementation, the {@link #enroll enroll} and {@link #resign resign} * operations - together with most of the {@link #sync sync}s - have unit time * costs. The final sync, which releases all the other (n) * processes blocked on the barrier, takes O(n) time. The unit time costs * for this implementation are comparable with those of a synchronized method * invocation followed by an Object.wait. *
* [Note: CSP synchronisation primitives can be implemented with much lighter * overheads. For example, * the KRoC * occam equivalent to this Barrier * (its EVENT) * has (sub-microsecond) unit time costs for all its operations, including * the final sync. Future work on JCSP may look towards this standard.] * * @see org.jcsp.lang.AltingBarrier * @see org.jcsp.lang.Bucket * @see org.jcsp.lang.Alternative * * @author P.H. Welch */ public class Barrier implements Serializable { /** * The number of processes currently enrolled on this barrier. */ private int nEnrolled = 0; /** * The number of processes currently enrolled on this barrier and who have not yet * synchronised in this cycle. */ private int countDown = 0; /** * The monitor lock used for synchronisation. */ private Object barrierLock = new Object (); /** * The even/odd flag used to detect spurious wakeups. */ private boolean evenOddCycle = true; // could be initialised to false ... /** * Construct a barrier initially associated with no processes. */ public Barrier() { } /** * Construct a barrier (initially) associated with nEnrolled processes. * It is the responsibility of the constructing process to pass this * (by constructor or set method) to each process that will be * synchronising on the barrier, before firing up those processes. *
* * @param nEnrolled the number of processes (initially) associated with this barrier. *
* * @throws IllegalArgumentException if nEnrolled < 0. */ public Barrier (final int nEnrolled) { if (nEnrolled < 0) { throw new IllegalArgumentException ( "*** Attempt to set a negative enrollment on a barrier\n" ); } this.nEnrolled = nEnrolled; countDown = nEnrolled; //System.out.println ("Barrier.constructor : " + nEnrolled + ", " + countDown); } /** * Reset this barrier to be associated with nEnrolled processes. * This must only be done at a time when no processes are active on the barrier. * It is the responsibility of the invoking process to pass this barrier * (by constructor or set method) to each process that will be * synchronising on the barrier, before firing up those processes. *
* * @param nEnrolled the number of processes reset to this barrier. *
* * @throws IllegalArgumentException if nEnrolled < 0. */ public void reset (final int nEnrolled) { if (nEnrolled < 0) { throw new IllegalArgumentException ( "*** Attempt to set a negative enrollment on a barrier\n" ); } synchronized (barrierLock) { this.nEnrolled = nEnrolled; countDown = nEnrolled; } //System.out.println ("Barrier.reset : " + nEnrolled + ", " + countDown); } /** * Synchronise the invoking process on this barrier. * Any process synchronising on this barrier will be blocked until all * processes associated with the barrier have synchronised (or resigned). */ public void sync () { synchronized (barrierLock) { countDown--; //System.out.println ("Barrier.sync : " + nEnrolled + ", " + countDown); if (countDown > 0) { try { boolean spuriousCycle = evenOddCycle; barrierLock.wait (); while (spuriousCycle == evenOddCycle) { if (Spurious.logging) { SpuriousLog.record (SpuriousLog.BarrierSync); } barrierLock.wait (); } } catch (InterruptedException e) { throw new ProcessInterruptedException ( "*** Thrown from Barrier.sync ()\n" + e.toString () ); } } else { countDown = nEnrolled; evenOddCycle = !evenOddCycle; // to detect spurious wakeups :( //System.out.println ("Barrier.sync : " + nEnrolled + ", " + countDown); barrierLock.notifyAll (); } } } /** * A process may enroll only if it is resigned. * A re-enrolled process may resume offering to synchronise on this barrier * (until a subsequent {@link #resign resign}). * Other processes cannot complete the barrier (represented by this front-end) * without participation by the re-enrolled process. *
* Note: timing re-enrollment on a barrier usually needs some care. * If the barrier is being used for synchronising phases of execution between * a set of processes, it is crucial that re-enrollment occurs in * an appropriate (not arbitrary) phase. * If the trigger for re-enrollment comes from another enrolled process, * that process should be in such an appropriate phase. * The resigned process should re-enroll and, then, acknowledge the trigger. * The triggering process should wait for that acknowledgement. * If the decision to re-enroll is internal (e.g. following a timeout), * a buddy process, enrolled on the barrier, should be asked to provide * that trigger when in an appropriate phase. * The buddy process, perhaps specially built just for this purpose, polls * a service channel for that question when in that phase. *
** Warning: the rule in the first sentence above is * the responsibility of the designer -- it is not checked by * implementation. * If not honoured, things will go wrong. */ public void enroll () { synchronized (barrierLock) { nEnrolled++; countDown++; } //System.out.println ("Barrier.enroll : " + nEnrolled + ", " + countDown); } /** * A process may resign only if it is enrolled. * A resigned process may not offer to synchronise on this barrier * (until a subsequent {@link #enroll enroll}). * Other processes can complete the barrier (represented by this front-end) * without participation by the resigned process. *
* Unless all processes synchronising on this barrier terminate in * the same phase, it is usually appropriate for a terminating process * to resign first. Otherwise, its sibling processes will never be * able to complete another synchronisation. *
** Warning: the rules in the first two sentences above are * the responsibility of the designer -- they are not checked by * implementation. * If not honoured, things will go wrong. *
** * @throws BarrierError if not enrolled (but this is not always detected). * */ public void resign () { synchronized (barrierLock) { nEnrolled--; countDown--; //System.out.println ("Barrier.resign : " + nEnrolled + ", " + countDown); if (countDown == 0) { countDown = nEnrolled; evenOddCycle = !evenOddCycle; // to detect spurious wakeups :( //System.out.println ("Barrier.resign : " + nEnrolled + ", " + countDown); barrierLock.notifyAll (); } else if (countDown < 0) { throw new BarrierError ( "*** A process has resigned on a barrier without first enrolling\n" ); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelOutputIntImpl.java 0000644 0000000 0000000 00000004611 11113671251 021014 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; class ChannelOutputIntImpl implements ChannelOutputInt { private ChannelInternalsInt channel; private int immunity; ChannelOutputIntImpl(ChannelInternalsInt _channel, int _immunity) { channel = _channel; immunity = _immunity; } public void write(int object) { channel.write(object); } public void poison(int strength) { if (strength > immunity) { channel.writerPoison(strength); } } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/Mutex.java 0000644 0000000 0000000 00000005204 11113671251 016027 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * A package-visible class that implements a straightforward mutex, for use by * One2AnyChannel and Any2AnyChannel * * @author N.C.C. Brown * */ class Mutex { private boolean claimed = false; public void claim() { synchronized (this) { while (claimed) { try { wait(); } catch (InterruptedException e) { throw new ProcessInterruptedException ( "*** Thrown from Mutex.claim()\n" + e.toString () ); } } claimed = true; } } public void release() { synchronized (this) { claimed = false; notify(); } } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/AltingChannelInputSymmetricImpl.java 0000644 0000000 0000000 00000005240 11105701167 023174 0 ustar /************************************************************************* * * * JCSP ("CSP for Java") libraries * * Copyright (C) 1996-2001 Peter Welch and Paul Austin. * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This library is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, * * USA. * * * * Author contact: P.H.Welch@kent.ac.uk * * * *************************************************************************/ package org.jcsp.lang; class AltingChannelInputSymmetricImpl extends AltingChannelInput implements MultiwaySynchronisation { private final AltingBarrier ab; private final ChannelInput in; private boolean syncDone = false; public AltingChannelInputSymmetricImpl ( AltingBarrier ab, ChannelInput in) { this.ab = ab; this.in = in; } boolean enable (Alternative alt) { syncDone = ab.enable (alt); return syncDone; } boolean disable () { syncDone = ab.disable (); return syncDone; } public Object read () { if (!syncDone) ab.sync (); syncDone = false; return in.read (); } public boolean pending () { syncDone = ab.poll (10); return syncDone; } public void poison(int strength) { in.poison(strength); } public void endRead() { in.endRead(); } public Object startRead() { if (!syncDone) ab.sync(); syncDone = false; return in.read(); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/JCSP_InternalError.java 0000644 0000000 0000000 00000004271 11105701167 020336 0 ustar /************************************************************************* * * * JCSP ("CSP for Java") libraries * * Copyright (C) 1996-2008 Peter Welch and Paul Austin. * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This library is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, * * USA. * * * * Author contact: P.H.Welch@kent.ac.uk * * * *************************************************************************/ package org.jcsp.lang; //{{{ javadoc /** * This is thrown by an inconsistency detected in the internal structures of JCSP. * *
Description
* Please report the circumstances to jcsp-team@kent.ac.uk - thanks! * * @author P.H. Welch */ //}}} public class JCSP_InternalError extends Error { public JCSP_InternalError (String s) { super ( s + "\n*** Please report the circumstances to jcsp-team@kent.ac.uk - thanks!" ); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/ConnectionClientOpenMessage.java 0000644 0000000 0000000 00000004301 11105701167 022310 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * @author Quickstone Technologies Limited */ class ConnectionClientOpenMessage extends ConnectionClientMessage { ChannelOutput replyChannel; } jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelInt.java 0000644 0000000 0000000 00000041214 11105701167 016752 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; import org.jcsp.util.ints.ChannelDataStoreInt; /** * This class provides static factory methods for constructing * various different types of int channel objects. There are also methods * for constructing arrays of identical int channels. * * The current implementation constructs "safe" channels which have separate * delegate objects for their read and write ends. This stops a *ChannelInputInt from being cast into a ChannelOutputInt
* object. The SafeChannelIntFactory class is used to construct the
* channels.
*
* Non-safe channels can be constructed by using an instance of the
* StandardChannelIntFactory class. The channels produced by this
* factory have read and write ends implemented by the same object. This is
* is more efficient (there are two extra objects and delegate method calls)
* but could lead to errors if users make incorrect casts.
*
* @deprecated To create integer channels, use the methods in the Channel class.
*
* @author Quickstone Technologies Limited
*/
public class ChannelInt
{
/**
* Private constructor to stop users from instantiating this class.
*/
private ChannelInt()
{
//this class should not be instantiated
}
/**
* The factory to be used by this class. The class should implement
* ChannelIntFactory, ChannelIntArrayFactory, BufferedChannelIntFactory and BufferedChannelIntArrayFactory.
*/
private static final StandardChannelIntFactory factory = new StandardChannelIntFactory();
/* Methods that are the same as the Factory Methods */
/**
* Constructs and returns a One2OneChannelInt object.
*
* @return the channel object.
*
* @see org.jcsp.lang.ChannelIntFactory#createOne2One()
*/
public static One2OneChannelInt createOne2One()
{
return factory.createOne2One();
}
/**
* Constructs and returns an Any2OneChannelInt object.
*
* @return the channel object.
*
* @see org.jcsp.lang.ChannelIntFactory#createAny2One()
*/
public static Any2OneChannelInt createAny2One()
{
return factory.createAny2One();
}
/**
* Constructs and returns a One2AnyChannelInt object.
*
* @return the channel object.
*
* @see org.jcsp.lang.ChannelIntFactory#createOne2Any()
*/
public static One2AnyChannelInt createOne2Any()
{
return factory.createOne2Any();
}
/**
* Constructs and returns an Any2AnyChannelInt object.
*
* @return the channel object.
*
* @see org.jcsp.lang.ChannelIntFactory#createAny2Any()
*/
public static Any2AnyChannelInt createAny2Any()
{
return factory.createAny2Any();
}
/**
* Constructs and returns an array of One2OneChannelInt
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelIntArrayFactory#createOne2One(int)
*/
public static One2OneChannelInt[] createOne2One(int n)
{
return factory.createOne2One(n);
}
/**
* Constructs and returns an array of Any2OneChannelInt
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelIntArrayFactory#createAny2One(int)
*/
public static Any2OneChannelInt[] any2oneArray(int n)
{
return factory.createAny2One(n);
}
/**
* Constructs and returns an array of One2AnyChannelInt
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelIntArrayFactory#createOne2Any(int)
*/
public static One2AnyChannelInt[] createOne2Any(int n)
{
return factory.createOne2Any(n);
}
/**
* Constructs and returns an array of Any2AnyChannelInt
* objects.
*
* @param n the size of the array of channels.
* @return the array of channels.
*
* @see org.jcsp.lang.ChannelIntArrayFactory#createAny2Any(int)
*/
public static Any2AnyChannelInt[] createAny2Any(int n)
{
return factory.createAny2Any(n);
}
/**
* Constructs and returns a One2OneChannelInt object which
* uses the specified ChannelDataStoreInt object as a buffer.
*
* @param buffer the ChannelDataStoreInt to use.
* @return the buffered channel.
*
* @see org.jcsp.lang.BufferedChannelIntFactory#createOne2One(ChannelDataStoreInt)
* @see org.jcsp.util.ints.ChannelDataStoreInt
*/
public static One2OneChannelInt createOne2One(ChannelDataStoreInt buffer)
{
return factory.createOne2One(buffer);
}
/**
* Constructs and returns a Any2OneChannelInt object which
* uses the specified ChannelDataStoreInt object as a buffer.
*
* @param buffer the ChannelDataStoreInt to use.
* @return the buffered channel.
*
* @see org.jcsp.lang.BufferedChannelIntFactory#createAny2One(ChannelDataStoreInt)
* @see org.jcsp.util.ints.ChannelDataStoreInt
*/
public static Any2OneChannelInt createAny2One(ChannelDataStoreInt buffer)
{
return factory.createAny2One(buffer);
}
/**
* Constructs and returns a One2AnyChannelInt object which
* uses the specified ChannelDataStoreInt object as a buffer.
*
* @param buffer the ChannelDataStoreInt to use.
* @return the buffered channel.
*
* @see org.jcsp.lang.BufferedChannelIntFactory#createOne2Any(ChannelDataStoreInt)
* @see org.jcsp.util.ints.ChannelDataStoreInt
*/
public static One2AnyChannelInt createOne2Any(ChannelDataStoreInt buffer)
{
return factory.createOne2Any(buffer);
}
/**
* Constructs and returns a Any2AnyChannelInt object which
* uses the specified ChannelDataStoreInt object as a buffer.
*
* @param buffer the ChannelDataStoreInt to use.
* @return the buffered channel.
*
* @see org.jcsp.lang.BufferedChannelIntFactory#createAny2Any(ChannelDataStoreInt)
* @see org.jcsp.util.ints.ChannelDataStoreInt
*/
public static Any2AnyChannelInt createAny2Any(ChannelDataStoreInt buffer)
{
return factory.createAny2Any(buffer);
}
/**
* Constructs and returns an array of One2OneChannelInt objects
* which use the specified ChannelDataStoreInt object as a
* buffer.
*
* @param buffer the ChannelDataStoreInt to use.
* @param n the size of the array of channels.
* @return the array of buffered channels.
*
* @see org.jcsp.lang.BufferedChannelIntArrayFactory#createOne2One(ChannelDataStoreInt, int)
* @see org.jcsp.util.ints.ChannelDataStoreInt
*/
public static One2OneChannelInt[] createOne2One(ChannelDataStoreInt buffer, int n)
{
return factory.createOne2One(buffer, n);
}
/**
* Constructs and returns an array of Any2OneChannelInt objects
* which use the specified ChannelDataStoreInt object as a
* buffer.
*
* @param buffer the ChannelDataStoreInt to use.
* @param n the size of the array of channels.
* @return the array of buffered channels.
*
* @see org.jcsp.lang.BufferedChannelIntArrayFactory#createAny2One(ChannelDataStoreInt, int)
* @see org.jcsp.util.ints.ChannelDataStoreInt
*/
public static Any2OneChannelInt[] any2oneArray(ChannelDataStoreInt buffer, int n)
{
return factory.createAny2One(buffer, n);
}
/**
* Constructs and returns an array of One2AnyChannelInt objects
* which use the specified ChannelDataStoreInt object as a
* buffer.
*
* @param buffer the ChannelDataStoreInt to use.
* @param n the size of the array of channels.
* @return the array of buffered channels.
*
* @see org.jcsp.lang.BufferedChannelIntArrayFactory#createOne2Any(ChannelDataStoreInt, int)
* @see org.jcsp.util.ints.ChannelDataStoreInt
*/
public static One2AnyChannelInt[] createOne2Any(ChannelDataStoreInt buffer, int n)
{
return factory.createOne2Any(buffer, n);
}
/**
* Constructs and returns an array of Any2AnyChannelInt objects
* which use the specified ChannelDataStoreInt object as a
* buffer.
*
* @param buffer the ChannelDataStoreInt to use.
* @param n the size of the array of channels.
* @return the array of buffered channels.
*
* @see org.jcsp.lang.BufferedChannelIntArrayFactory#createAny2Any(ChannelDataStoreInt, int)
* @see org.jcsp.util.ints.ChannelDataStoreInt
*/
public static Any2AnyChannelInt[] createAny2Any(ChannelDataStoreInt buffer, int n)
{
return factory.createAny2Any(buffer, n);
}
/**
* Constructs and returns an array of input channel ends, each of which can be shared by multiple
* concurrent readers. The returned array, r, is constructed such that
* r[i] = c[i].in () for 0 <= i < c.length.
*
* @param c the array of channel to obtain input ends from.
* @return the array of channel input ends.
*/
public static SharedChannelInputInt[] getInputArray(Any2AnyChannelInt[] c)
{
SharedChannelInputInt[] in = new SharedChannelInputInt[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].in();
return in;
}
/**
* Constructs and returns an array of input channel ends, each of which can be used as guards
* in an Alternative. The returned array, r, is constructed such that
* r[i] = c[i].in () for 0 <= i < c.length.
*
* @param c the array of channel to obtain input ends from.
* @return the array of channel input ends.
*/
public static AltingChannelInputInt[] getInputArray(Any2OneChannelInt[] c)
{
AltingChannelInputInt[] in = new AltingChannelInputInt[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].in();
return in;
}
/**
* Constructs and returns an array of input channel ends, each of which can be shared by multiple
* concurrent readers. The returned array, r, is constructed such that
* r[i] = c[i].in () for 0 <= i < c.length.
*
* @param c the array of channel to obtain input ends from.
* @return the array of channel input ends.
*/
public static SharedChannelInputInt[] getInputArray(One2AnyChannelInt[] c)
{
SharedChannelInputInt[] in = new SharedChannelInputInt[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].in();
return in;
}
/**
* Constructs and returns an array of input channel ends, each of which can be used as guards
* in an Alternative. The returned array, r, is constructed such that
* r[i] = c[i].in () for 0 <= i < c.length.
*
* @param c the array of channel to obtain input ends from.
* @return the array of channel input ends.
*/
public static AltingChannelInputInt[] getInputArray(One2OneChannelInt[] c)
{
AltingChannelInputInt[] in = new AltingChannelInputInt[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].in();
return in;
}
/**
* Constructs and returns an array of output channel ends, each of which can be shared by multiple
* concurrent writers. The returned array, r, is constructed such that
* r[i] = c[i].out () for 0 <= i < c.length.
*
* @param c the array of channel to obtain output ends from.
* @return the array of output input ends.
*/
public static SharedChannelOutputInt[] getOutputArray(Any2AnyChannelInt[] c)
{
SharedChannelOutputInt[] in = new SharedChannelOutputInt[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].out();
return in;
}
/**
* Constructs and returns an array of output channel ends, each of which can be shared by multiple
* concurrent writers. The returned array, r, is constructed such that
* r[i] = c[i].out () for 0 <= i < c.length.
*
* @param c the array of channel to obtain output ends from.
* @return the array of output input ends.
*/
public static SharedChannelOutputInt[] getOutputArray(Any2OneChannelInt[] c)
{
SharedChannelOutputInt[] in = new SharedChannelOutputInt[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].out();
return in;
}
/**
* Constructs and returns an array of output channel ends, each of which can only be used by a
* single writer. The returned array, r, is constructed such that
* r[i] = c[i].out () for 0 <= i < c.length.
*
* @param c the array of channel to obtain output ends from.
* @return the array of output input ends.
*/
public static ChannelOutputInt[] getOutputArray(One2AnyChannelInt[] c)
{
ChannelOutputInt[] in = new ChannelOutputInt[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].out();
return in;
}
/**
* Constructs and returns an array of output channel ends, each of which can only be used by a
* single writer. The returned array, r, is constructed such that
* r[i] = c[i].out () for 0 <= i < c.length.
*
* @param c the array of channel to obtain output ends from.
* @return the array of output input ends.
*/
public static ChannelOutputInt[] getOutputArray(One2OneChannelInt[] c)
{
ChannelOutputInt[] in = new ChannelOutputInt[c.length];
for (int i = 0; i < c.length; i++)
in[i] = c[i].out();
return in;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelArrayFactory.java 0000644 0000000 0000000 00000006455 11105701167 020636 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* Defines an interface for a factory that can create arrays of channels.
*
* @author Quickstone Technologies Limited
*
* @deprecated These channel factories are deprecated in favour of the new one2one() methods in the Channel class.
*/
public interface ChannelArrayFactory
{
/**
* Creates a populated array of n One2One channels.
*
* @param n the size of the array.
* @return the created array of channels.
*/
public One2OneChannel[] createOne2One(int n);
/**
* Creates a populated array of n Any2One channels.
*
* @param n the size of the array.
* @return the created array of channels.
*/
public Any2OneChannel[] createAny2One(int n);
/**
* Creates a populated array of n One2Any channels.
*
* @param n the size of the array.
* @return the created array of channels.
*/
public One2AnyChannel[] createOne2Any(int n);
/**
* Creates a populated array of n Any2Any channels.
*
* @param n the size of the array.
* @return the created array of channels.
*/
public Any2AnyChannel[] createAny2Any(int n);
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/RejectableAltingChannelInput.java 0000644 0000000 0000000 00000005104 11113671251 022434 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* Defines an interface for an input channel end that gives the reader the ability to reject instead
* of accepting pending data.
*
* @author Quickstone Technologies Limited
*
* @deprecated This channel is superceded by the poison mechanisms, please see {@link PoisonException}
*/
public abstract class RejectableAltingChannelInput extends AltingChannelInput implements RejectableChannelInput
{
/**
* Reject any data pending instead of reading it. The currently blocked writer will receive a
* ChannelDataRejectedException.
*/
public abstract void reject();
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/PoisonableAny2OneChannelImpl.java 0000644 0000000 0000000 00000004176 11113671251 022336 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
class PoisonableAny2OneChannelImpl extends Any2OneImpl
{
PoisonableAny2OneChannelImpl(int _immunity) {
super(new PoisonableOne2OneChannelImpl(_immunity));
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/PriParallel.java 0000644 0000000 0000000 00000013244 11105701167 017140 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This is an extension of the {@link Parallel} class that prioritises
* the processes given to its control.
* Description
* PriParallel is an extension of the {@link Parallel} class that prioritises * the processes given to its control. * The ordering of the processes in * the array passed to the constructor (or added/inserted later) is significant, * with earlier processes having higher priority. The last process in the * array inherits the priority of the constructing process. That priority may * be set explicitly by {@link #setPriority setPriority}. ** Implementation Note: these priorities are currently implemented * using the underlying threads priority mechanism. If there are more * priorities required than the maximum allowed for the threadgroup of * the spawning process, the higher requested priorities will be truncated * to that maximum. Also, the semantics of priority will be that implemented * by the JVM being used. * * @author P.D. Austin */ public class PriParallel extends Parallel { /** * Construct a new PriParallel object initially without any processes. * Processes may be added later using the inherited addProcess methods. * The order of their adding is significant, with ealier processes * having higher priority. */ public PriParallel() { super(null, true); } /** * Construct a new PriParallel object with the processes specified. * The ordering of the processes in the array is significant, with * ealier processes having higher priority. The last process in the * array inherits the priority of the constructing process. * * @param processes The processes to be executed in parallel */ public PriParallel(CSProcess[] processes) { super(processes, true); } /** * Insert another process to the pri-parallel object at the specifed * index. The point of insertion is significant because the ordering of * process components determines the priorities. The extended network * will be executed the next time run() is invoked. *
* @param process the process to be inserted * @param index the index at which to insert the process */ public void insertProcessAt(CSProcess process, int index) { super.insertProcessAt(process, index); } /** * This returns the current priority of this process. *
* @return the current priority of this process. */ public static int getPriority() { return Thread.currentThread().getPriority(); } /** * This changes the priority of this process. Note that JCSP only provides * this method for changing the priority of the invoking process. * Changing the process of another process is not considered wise. *
* Implementation Note: these priorities are currently implemented * using the underlying threads priority mechanism - hence run time * exceptions corresponding to the {@link java.lang.Thread}.getPriority() * may be thrown. *
* @throws java.lang.IllegalArgumentException if the priority is not
* in the range supported by the underlying threads implementation.
* @throws java.lang.SecurityException if the security manager of
* the underlying threads implementation will not allow this modification.
*/
public static void setPriority(int newPriority)
{
Thread.currentThread().setPriority(newPriority);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/BufferedChannelFactory.java 0000644 0000000 0000000 00000006740 11105701167 021277 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.ChannelDataStore;
/**
* Defines an interface for a factory that can create channels with user-definable buffering semantics.
*
* @author Quickstone Technologies Limited
*
* @deprecated These channel factories are deprecated in favour of the new one2one() methods in the Channel class.
*/
public interface BufferedChannelFactory
{
/**
* Creates a new One2One channel with the given buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @return the created channel.
*/
public One2OneChannel createOne2One(ChannelDataStore buffer);
/**
* Creates a new Any2One channel with the given buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @return the created channel.
*/
public Any2OneChannel createAny2One(ChannelDataStore buffer);
/**
* Creates a new One2Any channel with the given buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @return the created channel.
*/
public One2AnyChannel createOne2Any(ChannelDataStore buffer);
/**
* Creates a new Any2Any channel with the given buffering behaviour.
*
* @param buffer the buffer implementation to use.
* @return the created channel.
*/
public Any2AnyChannel createAny2Any(ChannelDataStore buffer);
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Guard.java 0000644 0000000 0000000 00000010111 11105701167 015761 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This is the super-class for all {@link Alternative} events selectable by a process.
*
Description
* Guard defines an abstract interface to be implemented by events competing * for selection by a process executing an {@link Alternative}. Its methods have * only package visibility within org.jcsp.lang and are of no concern to * users of this package. Currently, JCSP supports channel inputs, accepts, * timeouts and skips as guards. ** Note: for those familiar with the occam multiprocessing * language, classes implementing Guard correspond to process * guards for use within ALT constructs. * * @see org.jcsp.lang.CSTimer * @see org.jcsp.lang.Skip * @see org.jcsp.lang.AltingChannelInput * @see org.jcsp.lang.AltingChannelInputInt * @see org.jcsp.lang.Alternative * @author P.D. Austin * @author P.H. Welch */ public abstract class Guard { /** * Returns true if the event is ready. Otherwise, this enables the guard * for selection and returns false. *
* Note: this method should only be called by the Alternative class * * @param alt the Alternative class that is controlling the selection * @return true if and only if the event is ready */ abstract boolean enable(Alternative alt); /** * Disables the guard for selection. Returns true if the event was ready. *
* Note: this method should only be called by the Alternative class * * @return true if and only if the event was ready */ abstract boolean disable(); /** * Schedules the process performing the given Alternative to run again. * This is intended for use by advanced users of the library who want to * create their own Guards that are not in the org.jcsp.lang package. * * @param alt The Alternative to schedule */ protected void schedule (Alternative alt) { alt.schedule(); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/BufferedAny2OneChannelIntImpl.java 0000644 0000000 0000000 00000011151 11105701167 022430 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; import org.jcsp.util.ints.*; /** * This implements an any-to-one integer channel with user-definable buffering, * safe for use by many writers and one reader. *
Description
* BufferedAny2OneChannelIntImpl implements an any-to-one integer channel with * user-definable buffering. It is safe for use by many writing processes * but only one reader. Writing processes compete with each other to use * the channel. Only the reader and one writer will * actually be using the channel at any one time. This is taken care of by * BufferedAny2OneChannelIntImpl -- user processes just read from or write to it. ** The reading process may {@link Alternative ALT} on this channel. * The writing process is committed (i.e. it may not back off). *
* The constructor requires the user to provide * the channel with a plug-in driver conforming to the * {@link org.jcsp.util.ints.ChannelDataStoreInt ChannelDataStoreInt} * interface. This allows a variety of different channel semantics to be * introduced -- including buffered channels of user-defined capacity * (including infinite), overwriting channels (with various overwriting * policies) etc.. * Standard examples are given in the org.jcsp.util package, but * careful users may write their own. * *
Implementation Note and Caution
* Fair servicing of writers to this channel depends on the fair * servicing of requests to enter a synchronized block (or method) by * the underlying Java Virtual Machine (JVM). Java does not specify how threads * waiting to synchronize should be handled. Currently, Sun's standard JDKs queue * these requests - which is fair. However, there is at least one JVM * that puts such competing requests on a stack - which is legal but unfair * and can lead to infinite starvation. This is a problem for any Java system * relying on good behaviour from synchronized, not just for these * any-1 channels. * * @see org.jcsp.lang.Alternative * @see org.jcsp.lang.BufferedOne2OneChannelIntImpl * @see org.jcsp.lang.BufferedOne2AnyChannelIntImpl * @see org.jcsp.lang.BufferedAny2AnyChannelIntImpl * @see org.jcsp.util.ints.ChannelDataStoreInt * * @author P.D. Austin * @author P.H. Welch */ class BufferedAny2OneChannelIntImpl extends Any2OneIntImpl { public BufferedAny2OneChannelIntImpl(ChannelDataStoreInt data) { super(new BufferedOne2OneChannelIntImpl(data)); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/One2OneChannelIntImpl.java 0000644 0000000 0000000 00000027501 11113402355 020761 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; import org.jcsp.util.ints.ChannelDataStoreInt; /** * This implements a one-to-one integer channel. *Description
* One2OneChannelIntImpl implements a one-to-one integer channel. Multiple * readers or multiple writers are not allowed -- these are catered for * by {@link Any2OneChannelIntImpl}, * {@link One2AnyChannelIntImpl} or * {@link Any2AnyChannelIntImpl}. ** The reading process may {@link Alternative ALT} on this channel. * The writing process is committed (i.e. it may not back off). *
* The default semantics of the channel is that of CSP -- i.e. it is * zero-buffered and fully synchronised. The reading process must wait * for a matching writer and vice-versa. *
* However, the static methods of {@link Channel} allow the creation of
* a channel with a plug-in driver conforming to the
* {@link org.jcsp.util.ints.ChannelDataStoreInt ChannelDataStoreInt}
* interface. This allows a variety of different channel semantics to be
* introduced -- including buffered channels of user-defined capacity
* (including infinite), overwriting channels (with various overwriting
* policies) etc..
* Standard examples are given in the org.jcsp.util.ints package, but
* careful users may write their own.
*
* @see org.jcsp.lang.Alternative
* @see org.jcsp.lang.Any2OneChannelIntImpl
* @see org.jcsp.lang.One2AnyChannelIntImpl
* @see org.jcsp.lang.Any2AnyChannelIntImpl
* @see org.jcsp.util.ints.ChannelDataStoreInt
*
* @author P.D. Austin
* @author P.H. Welch
*/
class One2OneChannelIntImpl implements ChannelInternalsInt, One2OneChannelInt
{
/** The monitor synchronising reader and writer on this channel */
private Object rwMonitor = new Object();
/** The (invisible-to-users) buffer used to store the data for the channel */
private int hold;
/** The synchronisation flag */
private boolean empty = true;
/** The Alternative class that controls the selection */
private Alternative alt;
/** Flag to deal with a spurious wakeup during a write */
private boolean spuriousWakeUp = true;
/*************Methods from One2OneChannelInt******************************/
/**
* Returns the AltingChannelInputInt object to use for this
* channel. As One2OneChannelIntImpl implements
* AltingChannelInputInt itself, this method simply returns
* a reference to the object that it is called on.
*
* @return the AltingChannelInputInt object to use for this
* channel.
*/
public AltingChannelInputInt in()
{
return new AltingChannelInputIntImpl(this,0);
}
/**
* Returns the ChannelOutputInt object to use for this
* channel. As One2OneChannelIntImpl implements
* ChannelOutputInt itself, this method simply returns
* a reference to the object that it is called on.
*
* @return the ChannelOutputInt object to use for this
* channel.
*/
public ChannelOutputInt out()
{
return new ChannelOutputIntImpl(this,0);
}
/**********************************************************************/
/**
* Reads an int from the channel.
*
* @return the integer read from the channel.
*/
public int read () {
synchronized (rwMonitor) {
if (empty) {
empty = false;
try {
rwMonitor.wait ();
while (!empty) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.One2OneChannelIntRead);
}
rwMonitor.wait ();
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException (
"*** Thrown from One2OneChannelInt.read ()\n" + e.toString ()
);
}
} else {
empty = true;
}
spuriousWakeUp = false;
rwMonitor.notify ();
return hold;
}
}
public int startRead() {
synchronized (rwMonitor) {
if (empty) {
empty = false;
try {
rwMonitor.wait ();
while (!empty) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.One2OneChannelRead);
}
rwMonitor.wait ();
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException ("*** Thrown from One2OneChannel.read ()\n"
+ e.toString ());
}
} else {
empty = true;
}
return hold;
}
}
public void endRead() {
synchronized (rwMonitor) {
spuriousWakeUp = false;
rwMonitor.notify ();
}
}
/**
* Writes an int to the channel.
*
* @param value the integer to write to the channel.
*/
public void write (int value) {
synchronized (rwMonitor) {
hold = value;
if (empty) {
empty = false;
if (alt != null) {
alt.schedule ();
}
} else {
empty = true;
rwMonitor.notify ();
}
try {
rwMonitor.wait ();
while (spuriousWakeUp) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.One2OneChannelIntWrite);
}
rwMonitor.wait ();
}
spuriousWakeUp = true;
}
catch (InterruptedException e) {
throw new ProcessInterruptedException (
"*** Thrown from One2OneChannelInt.write (int)\n" + e.toString ()
);
}
}
}
/**
* turns on Alternative selection for the channel. Returns true if the
* channel has data that can be read immediately.
*
* Note: this method should only be called by the Alternative class * * @param alt the Alternative class which will control the selection * @return true if the channel has data that can be read, else false */ public boolean readerEnable(Alternative alt) { synchronized (rwMonitor) { if (empty) { this.alt = alt; return false; } else return true; } } /** * turns off Alternative selection for the channel. Returns true if the * channel contained data that can be read. *
* Note: this method should only be called by the Alternative class * * @return true if the channel has data that can be read, else false */ public boolean readerDisable() { synchronized (rwMonitor) { alt = null; return!empty; } } /** * Returns whether there is data pending on this channel. *
* Note: if there is, it won't go away until you read it. But if there * isn't, there may be some by the time you check the result of this method. *
* This method is provided for convenience. Its functionality can be provided * by Pri Alting the channel against a SKIP guard, although * at greater run-time and syntactic cost. For example, the following code * fragment: *
* if (c.pending ()) {
* int x = c.read ();
* ... do something with x
* } else (
* ... do something else
* }
*
* is equivalent to:
*
* if (c_pending.priSelect () == 0) {
* int x = c.read ();
* ... do something with x
* } else (
* ... do something else
* }
*
* where earlier would have had to have been declared:
*
* final Alternative c_pending =
* new Alternative (new Guard[] {c, new Skip ()});
*
*
* @return state of the channel.
*/
public boolean readerPending()
{
synchronized (rwMonitor)
{
return !empty;
}
}
/**
* Creates an array of One2OneChannelInts.
*
* @param n the number of channels to create in the array
* @return the array of One2OneChannelIntImpl
*/
public static One2OneChannelInt[] create(int n)
{
One2OneChannelInt[] channels = new One2OneChannelIntImpl[n];
for (int i = 0; i < n; i++)
channels[i] = new One2OneChannelIntImpl();
return channels;
}
/**
* Creates a One2OneChannelIntImpl using the specified ChannelDataStoreInt.
*
* @return the One2OneChannelIntImpl
*/
public static One2OneChannelInt create(ChannelDataStoreInt store)
{
return new BufferedOne2OneChannelIntImpl(store);
}
/**
* Creates an array of One2OneChannelInts using the specified ChannelDataStoreInt.
*
* @param n the number of channels to create in the array
* @return the array of One2OneChannelIntImpl
*/
public static One2OneChannelInt[] create(int n, ChannelDataStoreInt store)
{
One2OneChannelInt[] channels = new One2OneChannelIntImpl[n];
for (int i = 0; i < n; i++)
channels[i] = new BufferedOne2OneChannelIntImpl(store);
return channels;
}
// No poison on these channels:
public void readerPoison(int strength) {
}
public void writerPoison(int strength) {
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/AltingChannelOutputInt.java 0000644 0000000 0000000 00000007603 11113671251 021335 0 ustar
/*************************************************************************
* *
* JCSP ("CSP for Java") libraries *
* Copyright (C) 1996-2001 Peter Welch and Paul Austin. *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Lesser General Public *
* License as published by the Free Software Foundation; either *
* version 2.1 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the Free Software *
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, *
* USA. *
* *
* Author contact: P.H.Welch@kent.ac.uk *
* *
*************************************************************************/
package org.jcsp.lang;
//{{{ javadoc
/**
* This extends {@link Guard} and {@link ChannelOutputInt}
* to enable a process
* to choose between many integer output (and other) events.
* * A writing-end, obtained only from a {@link One2OneChannelSymmetricInt symmetric} * channel by invoking its out() method, will implement this interface. *
Description
* AltingChannelOutputInt extends {@link Guard} and {@link ChannelOutputInt} * to enable a process * to choose between many integer output (and other) events. The methods inherited from * Guard are of no concern to users of this package. * *Example
*
* import org.jcsp.lang.*;
*
* public class AltingOutputIntExample implements CSProcess {
*
* private final AltingChannelOutputInt out0, out1;
*
* public AltingOutputIntExample (final AltingChannelOutputInt out0,
* final AltingChannelOutputInt out1) {
* this.out0 = out0;
* this.out1 = out1;
* }
*
* public void run () {
*
* final Guard[] altChans = {out0, out1};
* final Alternative alt = new Alternative (altChans);
*
* while (true) {
* switch (alt.select ()) {
* case 0:
* out0.write (0);
* System.out.println ("out0 written");
* break;
* case 1:
* out1.write (1);
* System.out.println ("out1 written");
* break;
* }
* }
*
* }
*
* }
*
*
* @see org.jcsp.lang.Guard
* @see org.jcsp.lang.Alternative
* @see org.jcsp.lang.One2OneChannelSymmetricInt
* @see org.jcsp.lang.AltingChannelOutput
* @author P.H. Welch
*/
//}}}
public abstract class AltingChannelOutputInt extends Guard implements ChannelOutputInt {
// nothing alse to add
/**
* Returns whether the receiver is committed to read from this channel.
*
* Note: if this returns true, you must commit to write down this channel.
*
* @return state of the channel.
*/
public abstract boolean pending ();
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/AltingConnectionServer.java 0000644 0000000 0000000 00000012356 11105701167 021361 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* An interface to connection. This is used by servers which wish to
* {@link Alternative ALT} over a connection. Note that you cannot have
* more than one server serving an AltingConnectionServer.
*
* @see ConnectionServer
* @see ConnectionClient
* @see Connection
*
* @author Quickstone Technologies Limited
*/
public abstract class AltingConnectionServer extends Guard implements ConnectionServer
{
/**
* The channel used to ALT over.
*/
private AltingChannelInput altingChannel;
/**
* Constructor.
*
* Note that this is only intended for use by JCSP, and should
* not be called by user processes. Users should use one of the
* subclasses.
*
* @param altingChannel The channel used to implement the Guard
*/
protected AltingConnectionServer(AltingChannelInput altingChannel)
{
this.altingChannel = altingChannel;
}
/**
* Returns the channel used to implement the Guard.
*
* Note that this method is only intended for use by
* JCSP, and should not be called by user processes.
*
* Concrete subclasses should override this method to
* return null, to ensure that the alting channel is
* kept private.
*
* @return The channel passed to the constructor.
*/
protected AltingChannelInput getAltingChannel()
{
return altingChannel;
}
/**
* ConnectionServer implementations are likely to be
* implemented over channels. Multiple channels from the client
* to server may be used; one could be used for the initial
* connection while another one could be used for data requests.
*
* This method allows sub-classes to specify which channel should
* be the next one to be alted over.
*
* @param chan the channel to be ALTed over.
*/
protected void setAltingChannel(AltingChannelInput chan)
{
altingChannel = chan;
}
/**
* Returns true if the event is ready. Otherwise, this enables the guard
* for selection and returns false.
*
* Note: this method should only be called by the Alternative class * * @param alt the Alternative class that is controlling the selection * @return true if and only if the event is ready */ boolean enable(Alternative alt) { return altingChannel.enable(alt); } /** * Disables the guard for selection. Returns true if the event was ready. *
* Note: this method should only be called by the Alternative class * * @return true if and only if the event was ready */ boolean disable() { return altingChannel.disable(); } /** * Returns whether there is an open() pending on this connection.
* * Note: if there is, it won't go away until you accept it. But if * there isn't, there may be one by the time you check the result of * this method. * * @return true only if open() will complete without blocking. */ public boolean pending() { return altingChannel.pending(); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/ConnectionServer.java 0000644 0000000 0000000 00000012661 11105701167 020221 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** *
This interface should be implemented by classes that wish to
* act as connection servers and to accept requests from
* ConnectionClient objects.
The server can call request() to allow a client
* to establish a connection to the server and to obtain the client's
* initial request. This should block until a client establishes a
* connection.
Once a request has been received, the server should reply to the client.
* If the server wants to close the connection then the server should call
* replyAndClose(Object) or alternatively
* reply(Object, boolean) with the boolean set to
* true. If the server wants to keep the connection open, then it
* should call reply(Object) or alternatively
* reply(Object, boolean) with the boolean set to
* false. The reply(Object, boolean) method is
* provided for convenience in closing connections programatically.
Receives a request from a client. This will block until the client
* calls its request(Object) method. Implementations may
* make this ALTable.
After this method has returned, the server should call one of the * reply methods. Performing any external process synchronization * between these method calls could be potentially hazardous and could * lead to deadlock.
* * @return theObject sent by the client.
*/
public Object request() throws IllegalStateException;
/**
* Sends some data back to the client after a request
* has been received but keeps the connection open. After calling
* this method, the server should call recieve()
* to receive a further request.
A call to this method is equivalent to a call to
* reply(Object, boolean) with the boolean set to
* false.
Sends some data back to the client after a request
* has been received. The boolean close parameter
* indicates whether the connection should be closed after this
* reply has been sent.
This method should not block.
* * @param data the data to send back to client. * @param closeboolean that should be true
* iff the connection should be dropped after the reply
* has been sent.
*/
public void reply(Object data, boolean close);
/**
* Sends some data back to the client and closes the connection.
* *A call to this method is equivalent to a call to
* reply(Object, boolean) with the boolean set to
* true.
Description
* BlackHoleChannelInt is an implementation of {@link ChannelOutputInt} that yields * black hole semantics for a channel. Writers may always write but there can be * no readers. Any number of writers may share the same black hole. ** Note: BlackHoleChannelInts are used for masking off unwanted outputs * from processes. They are useful when we want to reuse an existing process component * intact, but don't need some of its output channels (i.e. we don't want to redesign * and reimplement the component to remove the redundant channels). Normal channels cannot * be plugged in and left dangling as this may deadlock (parts of) the component being * reused. *
* * @see org.jcsp.lang.ChannelOutputInt * @see org.jcsp.lang.One2OneChannelInt * @see org.jcsp.lang.Any2OneChannelInt * @see org.jcsp.lang.One2AnyChannelInt * @see org.jcsp.lang.Any2AnyChannelInt * * @author P.H. Welch */ public class BlackHoleChannelInt implements ChannelOutputInt { /** * Write an integer to the channel and loose it. * * @param n the integer to write to the channel. */ public void write(int n) { } public void poison(int strength) { } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/One2OneChannelImpl.java 0000644 0000000 0000000 00000024310 11113402355 020301 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * This implements a one-to-one object channel. *
Description
* One2OneChannelImpl implements a one-to-one object channel. Multiple * readers or multiple writers are not allowed -- these are catered for * by {@link Any2OneChannelImpl}, * {@link One2AnyChannelImpl} or * {@link Any2AnyChannelImpl}. ** The reading process may {@link Alternative ALT} on this channel. * The writing process is committed (i.e. it may not back off). *
* The default semantics of the channel is that of CSP -- i.e. it is * zero-buffered and fully synchronised. The reading process must wait * for a matching writer and vice-versa. *
* However, the static methods of {@link Channel} allow the construction of
* a channel with a plug-in driver conforming to the
* {@link org.jcsp.util.ChannelDataStore ChannelDataStore}
* interface. This allows a variety of different channel semantics to be
* introduced -- including buffered channels of user-defined capacity
* (including infinite), overwriting channels (with various overwriting
* policies) etc..
* Standard examples are given in the org.jcsp.util package, but
* careful users may write their own.
*
* @see org.jcsp.lang.Alternative
* @see org.jcsp.lang.Any2OneChannelImpl
* @see org.jcsp.lang.One2AnyChannelImpl
* @see org.jcsp.lang.Any2AnyChannelImpl
* @see org.jcsp.util.ChannelDataStore
*
* @author P.D. Austin
* @author P.H. Welch
*/
class One2OneChannelImpl implements One2OneChannel, ChannelInternals
{
/** The monitor synchronising reader and writer on this channel */
private Object rwMonitor = new Object ();
/** The (invisible-to-users) buffer used to store the data for the channel */
private Object hold;
/** The synchronisation flag */
private boolean empty = true;
/** The Alternative class that controls the selection */
private Alternative alt;
/** Flag to deal with a spurious wakeup during a write */
private boolean spuriousWakeUp = true;
/*************Methods from One2OneChannel******************************/
/**
* Returns the AltingChannelInput to use for this channel.
* As One2OneChannelImpl implements
* AltingChannelInput itself, this method simply returns
* a reference to the object that it is called on.
*
* @return the AltingChannelInput object to use for this
* channel.
*/
public AltingChannelInput in()
{
return new AltingChannelInputImpl(this,0);
}
/**
* Returns the ChannelOutput object to use for this channel.
* As One2OneChannelImpl implements
* ChannelOutput itself, this method simply returns
* a reference to the object that it is called on.
*
* @return the ChannelOutput object to use for this
* channel.
*/
public ChannelOutput out()
{
return new ChannelOutputImpl(this,0);
}
/*************Methods from ChannelOutput*******************************/
/**
* Writes an Object to the channel.
*
* @param value the object to write to the channel.
*/
public void write(Object value) {
synchronized (rwMonitor) {
hold = value;
if (empty) {
empty = false;
if (alt != null) {
alt.schedule();
}
} else {
empty = true;
rwMonitor.notify();
}
try {
rwMonitor.wait();
while (spuriousWakeUp) {
if (Spurious.logging) {
SpuriousLog.record(SpuriousLog.One2OneChannelWrite);
}
rwMonitor.wait();
}
spuriousWakeUp = true;
} catch (InterruptedException e) {
throw new ProcessInterruptedException(
"*** Thrown from One2OneChannel.write (Object)\n" + e.toString());
}
}
}
/** ***********Methods from AltingChannelInput************************* */
/**
* Reads an Object from the channel.
*
* @return the object read from the channel.
*/
public Object read () {
synchronized (rwMonitor) {
if (empty) {
empty = false;
try {
rwMonitor.wait ();
while (!empty) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.One2OneChannelRead);
}
rwMonitor.wait ();
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException ("*** Thrown from One2OneChannel.read ()\n"
+ e.toString ());
}
} else {
empty = true;
}
spuriousWakeUp = false;
rwMonitor.notify ();
return hold;
}
}
public Object startRead() {
synchronized (rwMonitor) {
if (empty) {
empty = false;
try {
rwMonitor.wait ();
while (!empty) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.One2OneChannelRead);
}
rwMonitor.wait ();
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException ("*** Thrown from One2OneChannel.read ()\n"
+ e.toString ());
}
} else {
empty = true;
}
return hold;
}
}
public void endRead() {
synchronized (rwMonitor) {
spuriousWakeUp = false;
rwMonitor.notify ();
}
}
/**
* turns on Alternative selection for the channel. Returns true if the
* channel has data that can be read immediately.
*
* Note: this method should only be called by the Alternative class * * @param alt the Alternative class which will control the selection * @return true if the channel has data that can be read, else false */ public boolean readerEnable (Alternative alt) { synchronized (rwMonitor) { if (empty) { this.alt = alt; return false; } else { return true; } } } /** * turns off Alternative selection for the channel. Returns true if the * channel contained data that can be read. *
* Note: this method should only be called by the Alternative class * * @return true if the channel has data that can be read, else false */ public boolean readerDisable () { synchronized (rwMonitor) { alt = null; return !empty; } } /** * Returns whether there is data pending on this channel. *
* Note: if there is, it won't go away until you read it. But if there * isn't, there may be some by the time you check the result of this method. *
* This method is provided for convenience. Its functionality can be provided * by Pri Alting the channel against a SKIP guard, although * at greater run-time and syntactic cost. For example, the following code * fragment: *
* if (c.pending ()) {
* Object x = c.read ();
* ... do something with x
* } else (
* ... do something else
* }
*
* is equivalent to:
*
* if (c_pending.priSelect () == 0) {
* Object x = c.read ();
* ... do something with x
* } else (
* ... do something else
* }
*
* where earlier would have had to have been declared:
*
* final Alternative c_pending =
* new Alternative (new Guard[] {c, new Skip ()});
*
*
* @return state of the channel.
*/
public boolean readerPending () {
synchronized (rwMonitor) {
return !empty;
}
}
//No poison in these channels:
public void writerPoison(int strength) {
}
public void readerPoison(int strength) {
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/One2OneConnection.java 0000644 0000000 0000000 00000004712 11105701167 020216 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* Defines an interface for a connection that can be used by a single server and single client.
*
* @author Quickstone Technologies Limited
*/
public interface One2OneConnection
{
/**
* Returns the client end of the connection.
*/
public AltingConnectionClient client();
/**
* Returns the server end of the connection.
*/
public AltingConnectionServer server();
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelIntFactory.java 0000644 0000000 0000000 00000005737 11105701167 020314 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* Defines an interface for a factory that can create channels carrying integers.
*
* @author Quickstone Technologies Limited
*
* @deprecated These channel factories are deprecated in favour of the new one2one() methods in the Channel class.
*/
public interface ChannelIntFactory
{
/**
* Creates a new One2One channel.
*
* @return the created channel.
*/
public One2OneChannelInt createOne2One();
/**
* Creates a new Any2One channel.
*
* @return the created channel.
*/
public Any2OneChannelInt createAny2One();
/**
* Creates a new One2Any channel.
*
* @return the created channel.
*/
public One2AnyChannelInt createOne2Any();
/**
* Creates a new Any2Any channel.
*
* @return the created channel.
*/
public Any2AnyChannelInt createAny2Any();
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Any2OneCallChannel.java 0000644 0000000 0000000 00000100734 11105701167 020272 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import java.io.Serializable;
/**
* This is the super-class for any-to-one interface-specific CALL channels,
* safe for use by many clients and one server.
* * Shortcut to the Constructor and Method Summaries. * *
Description
* Please see {@link One2OneCallChannel} for general information about CALL channels. * Documented here is information specific to this any-1 version. * *Converting a Method Interface into a Variant CALL Channel
* Constructing a any-1 CALL channel for a specific interface * follows exactly the same pattern as in the 1-1 case. Of course, it must * extend Any2OneCallChannel rather than One2OneCallChannel. ** For example, using the same Foo * interface as before, we derive: *
* import org.jcsp.lang.*;
*
* public class Any2OneFooChannel extends Any2OneCallChannel implements Foo {
*
* ... same body as One2OneFooChannel
*
* }
*
*
* Calling a CALL Channel
* All the client needs to see is the method interface * implemented by the CALL channel. So far as the client is concerned, therefore, * there is no difference between any of the varieties of CALL channel * - it just makes the call. * *Accepting a CALL Channel
* The mechanics of accepting a CALL channel are the same for all varieties. * However, the server should declare which kind (or kinds) it allows * to be attached: *
* import org.jcsp.lang.*;
*
* class B implements CSProcess, Foo {
*
* private final ChannelAccept in;
*
* public B (final One2OneFooChannel in) { // original constructor
* this.in = in;
* }
*
* public B (final Any2OneFooChannel in) { // additional constructor
* this.in = in;
* }
*
* ... rest as before
*
* }
*
* When wrapping the above to hide its raw method interface, don't forget to include
* the extra constructor(s):
*
* import org.jcsp.lang.*;
*
* public class B2 implements CSProcess { // no Foo interface
*
* private final B b;
*
* public B2 (final One2OneFooChannel in) { // original constructor
* b = new B (in);
* }
*
* public B2 (final Any2OneFooChannel in) { // additional constructor
* b = new B (in);
* }
*
* public void run () {
* b.run ();
* }
*
* }
*
*
* ALTing on a CALL Channel
* The server may ALT on a any-1 CALL channel, just as it may ALT on * a 1-1 one. As before, it needs to make its intentions explicit. So, in * the above example, the first field declaration of B * needs to become: ** private final AltingChannelAccept in; ** See below for an example of ALTing between CALL channels. * *
Building a CALL Channel Network
* Network building with CALL channels is the same as building with ordinary * channels. First construct the channels and, then, construct the processes * - plugging in the channels as required and running them in {@link Parallel}. ** For example, the network consisting of one server and several clients: *
* Any2OneFooChannel c = new Any2OneFooChannel ();
*
* final A[] aClients = new A[n_aClients];
* for (int i = 0; i < aClients.length; i++) {
* aClients[i] = new A (c);
* }
*
* new Parallel (
* new CSProcess[] {
* new Parallel (aClients),
* new B2 (c)
* }
* ).run ();
*
*
* Example
* This is a CALL channel version of * the Wot-no-Chickens example: *
* The supply CALL channel replaces the ordinary channel of the same name. * Previously, the chef still had to perform two actions to supply the chickens - * a supply.write followed by a second supply.write. This was to model * the extended period while the chef set down the chickens in the canteen. The first * communication synchronised the chef with the canteen, getting its exclusive attention. * The canteen then executed the set-down delay before accepting the second communication * and, hence, releasing the chef. Now, this interaction is a single CALL * on supply.freshChickens. *
* The other difference with the earlier example is that the college now employs many chefs. * This has two minor impacts. It needs to be able to support any-1 CALLs on its * supply channel (as well as on service). Secondly, with all those chefs, * it needs to be able to refuse further supplies of chicken if it has run of room. * *
The Canteen
* There are two other differences in design between the canteen server here and * the CALL channel servers documented above and in {@link One2OneCallChannel}. The first * is trivial - we have inlined the real server as an anonymous inner class of * the public Canteen wrapper. The second is more subtle, but also trivial. * Often, a CALL channel is constructed for a specific server interface and there is * no intention for it to be used for communicating with any other server. In which case, * it makes sense to tie that interface, together with its corresponding CALL channel, * into the server as inner declarations. ** So, the Canteen first publishes its two specific interfaces and matching CALL channels. * The CALL channels follow * the defined pattern, * omitting the optional setting of selected * (since each interface contains only one method): *
* import org.jcsp.lang.*;
*
* class Canteen implements CSProcess {
*
* public static interface Service {
* public int takeChicken (String philId);
* }
*
* public static class One2OneServiceChannel
* extends One2OneCallChannel implements Service {
* public int takeChicken (String philId) {
* join ();
* int n = ((Service) server).takeChicken (philId);
* fork ();
* return n;
* }
* }
*
* public static class Any2OneServiceChannel
* extends Any2OneCallChannel implements Service {
* public int takeChicken (String philId) {
* join ();
* int n = ((Service) server).takeChicken (philId);
* fork ();
* return n;
* }
* }
*
* public static interface Supply {
* public int freshChickens (String chefId, int value);
* }
*
* public static class Any2OneSupplyChannel
* extends Any2OneCallChannel implements Supply {
* public int freshChickens (String chefId, int value) {
* join ();
* int n = ((Supply) server).freshChickens (chefId, value);
* fork ();
* return n;
* }
* }
*
* Note that we have defined both 1-1 and any-1 versions of the Service
* CALL channel. This example makes use only of the any-1 variant - the other will
* be used in a later exercise.
* * Next we set up the constructor and the local fields for saving its parameters: *
* private final AltingChannelAccept service; // shared from all Philosphers
* private final AltingChannelAccept supply; // shared from all Chefs
* private final int serviceTime;
* // how long a philosopher spends in the canteen
* private final int supplyTime;
* // how long a chef spends in the canteen
* private final int maxChickens;
* // maximum number of chickens in the canteen
*
* public Canteen (Any2OneServiceChannel service, Any2OneSupplyChannel supply,
* int serviceTime, int supplyTime, int maxChickens) {
* this.service = service;
* this.supply = supply;
* this.serviceTime = serviceTime;
* this.supplyTime = supplyTime;
* this.maxChickens = maxChickens;
* }
*
* Now, we need to combine the exported interfaces into a single one so that the inner process
* can be created (anonymously) by this wrapper's run method:
*
* private interface inner extends CSProcess, Service, Supply {};
*
* public void run () {
*
* new inner () {
*
* private int nChickens = 0;
* private int nSupplied = 0;
*
* private final CSTimer tim = new CSTimer ();
*
* Impementations of the required CALL interfaces come next:
*
* public int takeChicken (String philId) {
* // pre : nChickens > 0
* System.out.println (" Canteen -> " + philId
* + " : one chicken ordered ... "
* + nChickens + " left ... ");
* tim.sleep (serviceTime);
* nChickens--;
* nSupplied++;
* System.out.println (" Canteen -> " + philId
* + " : one chicken coming down ... "
* + nChickens + " left ... ["
* + nSupplied + " supplied]");
* return 1;
* }
*
* public int freshChickens (String chefId, int value) {
* // pre : nChickens < maxChickens
* System.out.println (" Canteen <- " + chefId
* + " : ouch ... make room ... ");
* tim.sleep (supplyTime);
* nChickens += value;
* int sendBack = nChickens - maxChickens;
* if (sendBack > 0) {
* nChickens = maxChickens;
* System.out.println (" Canteen <- " + chefId
* + " : full up ... sending back "
* + sendBack);
* } else {
* sendBack = 0;
* }
* System.out.println (" Canteen <- " + chefId
* + " : more chickens ... "
* + nChickens + " now available ... ");
* return sendBack;
* }
*
* and the run method that conducts everything:
*
* public void run () {
*
* final Alternative alt = new Alternative (new Guard[] {supply, service});
* final boolean[] precondition = {true, false};
* final int SUPPLY = 0;
* final int SERVICE = 1;
*
* System.out.println (" Canteen : starting ... ");
* while (true) {
* precondition[SERVICE] = (nChickens > 0);
* precondition[SUPPLY] = (nChickens < maxChickens);
* switch (alt.fairSelect (precondition)) {
* case SUPPLY:
* supply.accept (this); // new batch of chickens from a chef
* break;
* case SERVICE:
* service.accept (this); // a philosopher wants a chicken
* break;
* }
* }
*
* }
*
* Finally, don't forget to run this inner process:
* * }.run (); * * } * * } ** *
The Philosopher
* As in the original example, philosophers spend their time thinking, feeling hungry, * calling on the canteen and, once served, eating. Except, of course, for greedy * philosophers who never stop to think: *
* import org.jcsp.lang.*;
*
* class Phil implements CSProcess {
*
* private final String id;
* private final Canteen.Service service;
* private final int thinkTime;
* private final int eatTime;
* private final boolean greedy;
*
* public Phil (String id, Canteen.Service service,
* int thinkTime, int eatTime, boolean greedy) {
* this.id = id;
* this.service = service;
* this.thinkTime = thinkTime;
* this.eatTime = eatTime;
* this.greedy = greedy;
* }
*
* public void run () {
* final CSTimer tim = new CSTimer ();
* int nEaten = 0;
* while (true) {
* if (! greedy) {
* System.out.println (" Phil " + id
* + " : thinking ... ");
* tim.sleep (thinkTime); // thinking
* }
* System.out.println (" Phil " + id
* + " : gotta eat ... ");
* int chicken = service.takeChicken (id);
* nEaten++;
* System.out.println (" Phil " + id
* + " : mmm ... that's good ["
* + nEaten + " so far]");
* tim.sleep (eatTime); // eating
* }
* }
*
* }
*
*
* The Chef
* Chefs cook chickens in batches of batchSize, taking batchTime * milliseconds per batch. When a batch is ready, the chef supplies it to the canteen. * The chef has to wait until the canteen is prepared to take it and, then, helps * to set down the batch (before returning with any for which there was no space) * - all this happens during the CALL of supply.freshChickens: *
* import org.jcsp.lang.*;
*
* class Chef implements CSProcess {
*
* private final String id;
* private final int batchSize;
* private final int batchTime;
* private final Canteen.Supply supply;
*
* public Chef (String id, int batchSize, int batchTime, Canteen.Supply supply) {
* this.id = id;
* this.batchSize = batchSize;
* this.batchTime = batchTime;
* this.supply = supply;
* }
*
* public void run () {
*
* final CSTimer tim = new CSTimer ();
*
* int nReturned = 0;
* int nSupplied = 0;
*
* while (true) {
* System.out.println (" Chef " + id + " : cooking ... "
* + (batchSize - nReturned) + " chickens");
* tim.sleep (batchTime);
* System.out.println (" Chef " + id + " : "
* + batchSize + " chickens, ready-to-go ... ");
* nReturned = supply.freshChickens (id, batchSize);
* nSupplied += (batchSize - nReturned);
* System.out.println (" Chef " + id + " : "
* + nReturned + " returned ["
* + nSupplied + " supplied]");
* }
* }
*
* }
*
*
* The Clock
* The college is feeling generous and provides a clock. This just ticks away, * delivering time-stamps roughly every second (and maintaining real-time). * It is independent of the rest of the system. *
* import org.jcsp.lang.*;
*
* class Clock implements CSProcess {
*
* public void run () {
*
* final CSTimer tim = new CSTimer ();
* final long startTime = tim.read ();
*
* while (true) {
* int tick = (int) (((tim.read () - startTime) + 500)/1000);
* System.out.println ("[TICK] " + tick);
* tim.sleep (1000);
* }
*
* }
*
* }
*
*
* The College
* Despite the greedy behaviour of philosopher 0 (Bill), nobody starves in * this college. Three chefs are provided with differing cooking speeds and batch sizes. * Pierre is the original lightning chef, cooking 4 chickens in 2 seconds flat. * Henri is more leisurely, taking 20 seconds to cook his batch of 10. * Sid has been sent down by the new owners of the college, who are into * mass catering. He produces 100 chickens every 150 seconds, which is a bit silly since * the canteen has only space for 50. Still, it enables Bill to get really sick! ** For convenience, the college network diagram is reproduced here - this time including * the clock and naming some of the characters: *
* import org.jcsp.lang.*;
*
* class College implements CSProcess {
*
* public void run () {
*
* final String[] philId = {"Bill", "Hilary", "Gennifer", "Paula", "Monica"};
*
* final int thinkTime = 3000; // 3 seconds
* final int eatTime = 100; // 100 milliseconds
*
* final int serviceTime = 0; // 0 seconds
* final int supplyTime = 3000; // 3 seconds
* final int maxChickens = 50;
*
* final Canteen.Any2OneServiceChannel service
* = new Canteen.Any2OneServiceChannel ();
* final Canteen.Any2OneSupplyChannel supply
* = new Canteen.Any2OneSupplyChannel ();
*
* final Phil[] phils = new Phil[philId.length];
* for (int i = 0; i < phils.length; i++) {
* phils[i] = new Phil (philId[i], service, thinkTime, eatTime, i == 0);
* }
*
* new Parallel (
* new CSProcess[] {
* new Clock (),
* new Canteen (service, supply, serviceTime, supplyTime, maxChickens),
* new Parallel (phils),
* new Chef ("Pierre", 4, 2000, supply),
* // chefId, batchSize, batchTime
* new Chef ("Henri", 10, 20000, supply),
* new Chef ("Sid", 100, 150000, supply)
* }
* ).run ();
*
* }
*
* public static void main (String argv[]) {
* new College ().run ();
* }
*
* }
*
*
* A Note about System.out and Other Non-Blocking Monitors
* The college network diagram and code hides a key player that * quietly coordinates the reporting of all activity - System.out. * All the processes share this object as a common resource, making heavy and * concurrent demands on its println service. Why is this safe? ** Consider a Java object whose public methods are all synchronized but * contain no invocations of wait or notify (a passive * non-blocking monitor). * Such an object is equivalent to a CSProcess serving one or more * any-1 CALL channels (whose interfaces reflect those synchronized * methods) and whose run consists of an endless loop that does nothing * except unconditionally accept any CALL. *
* So, a simple non-blocking monitor is always safe to share between concurrent JCSP * processes and, currently, carries less overheads than its active server * equivalent. See {@link org.jcsp.awt.DisplayList} for an example from the JCSP library. * Another example is {@link java.io.PrintStream java.io.PrintStream}, of which * System.out is an instance. Its print/println methods * are synchronized on itself (although this does not seem to be documented and * you have to look hard at the code to find out). So, to show the full story, the above * diagram possibly needs an overlay that adds a System.out * process servicing a any-1 println CALL channel, with all the other processes * as clients. This is left as an exercise. *
* Of course, it would be nice if such monitors were accessed via an interface, * so that client processes had neither direct visibilty of them nor concern about their * behaviour. A problem with the above college is that System.out - and * the concept of printing a line of text - is burnt into the code of all its * processes. If we wanted to change the output of the college from a scrolling text * display into some graphics animation, all those processes would have to be changed. *
* A better design would pass in channel (or CALL channel or non-blocking monitor) * interfaces to each of the college processes. These would merely report their identities * and states by writing to (or calling or invoking) those interfaces. To reproduce * the current display, all those interfaces would be instanced by a single any-1 * channel (or CALL channel or monitor) connected to a simple server that responds by * making System.out.println invocations appropriate to the information passed. * For other effects, connect in other servers. * Note that the college processes do not have to be connected to the same server - each * could be connected to a separate server and these servers connected into a graphics * animation network (incorporating, for example, processes from {@link org.jcsp.awt}). * The point is that the college processes would need no changing to drive whatever * was constructed. This is also left as an exercise. * *
Further Thoughts on the Canteen Design
* The decision to bind in the CALL channel (and associated inteface) definitions * as inner classes of Canteen does not fit comfortably with the above * observations. However, processes servicing Canteen.Any2OneServiceChannel * or Canteen.Any2OneSupplyChannel channels do not have to be instances of * Canteen - even though that would seem to be a little odd. * So, the College authorities still have freedom to install canteens with * behaviours quite different to that of Canteen. [Anything with the same * channel interface will fit! The interoperability of processes depends only on * the compatibility of their channel interfaces. Note that this reusability owes * nothing to the concept of inheritance - for example, the alternative canteens * pluggable into the college network need no special sub-classing relationships.] * So, if we really want to allow this flexibility, make it explicit by declaring * the CALL channels separately from any of their servers. ** Another design choice is to burn in CALL channel instances as part of the servers * themselves. For example, the Canteen class could construct and export * its service and supply channels as public and final * fields (rather than import them via constructor parameters). In this case, * the College builder would need to declare and name the canteen * (instead of declaring and naming the channels): *
* import org.jcsp.lang.*;
*
* class College implements CSProcess {
*
* public void run () {
*
* ... declare constants (nPhilosophers, thinkTime etc.)
*
* final Canteen canteen = new Canteen (serviceTime, supplyTime,
* maxChickens);
*
* final Phil[] phils = new Phil[nPhilosophers];
* for (int i = 0; i < phils.length; i++) {
* String philId = new Integer (i).toString ();
* phils[i] = new Phil (philId, canteen.service,
* thinkTime, eatTime, i == 0);
* }
*
* new Parallel (
* new CSProcess[] {
* new Clock (),
* canteen,
* new Parallel (phils),
* new Chef ("Pierre", 4, 2000, canteen.supply),
* new Chef ("Henri", 10, 20000, canteen.supply),
* new Chef ("Sid", 100, 60000, canteen.supply)
* }
* ).run ();
* }
* ... main
* }
*
* Note that this particular burn in does not deny any flexibility to the college
* in choosing any particular variety of canteen. In fact, the only thing of interest
* to the college is that the canteen provides and services CALL channels whose interfaces
* are what its philosophers and chefs expect (i.e. Service and Supply).
* Note also that the college network diagram has not changed.
* * Having gone this far, we may like to consider making the server self-starting * - so that its declaration not only introduces its service channels but also brings it * to life. For example, this could be done for the Canteen by adding the * following as the last line of its constructor: *
* new {@link ProcessManager} (this).start ();
*
* Of course, the canteen instance should then be removed from the {@link Parallel}
* construction above.
* * [Warning: be careful if sub-classes are allowed (i.e. the Canteen class * was not declared final). In this case, the above incantation should be optional * so that each sub-class constructor can invoke a super-class constructor that omits it. * If we let the super-class fire up the process, it may start running before the sub-class * constructor finishes - i.e. before the process has been fully initialised. * It must be the sub-class constructor that self-starts the process (as the last thing * it does).] *
* [Note: a self-starting server exporting its own CALL (or ordinary) channels * for public concurrent use corresponds to the occam3 notion of a MODULE * implemented by a RESOURCE.] * * @see org.jcsp.lang.One2OneCallChannel * @see org.jcsp.lang.One2AnyCallChannel * @see org.jcsp.lang.Any2AnyCallChannel * @see org.jcsp.lang.Alternative * * @author P.H. Welch */ public abstract class Any2OneCallChannel extends AltingChannelAccept implements Serializable { /** * This is used to synchronise the calling and accepting process. */ final private Any2OneChannelImpl c = new Any2OneChannelImpl(); /** * This is used to synchronise the calling and accepting process. */ final private One2OneChannelImpl d = new One2OneChannelImpl(); /** * This holds a reference to a server process so that a client may * make the call. The reference is only valid between the {@link #join join} * and {@link #fork fork} elements of the standard * calling sequence. * As shown in that sequence, it will need casting up to the relevant interface * supported by the specific CALL channel derived from this class. */ protected CSProcess server; // made available to the caller /** * This may be set during the standard calling sequence to record * which method was invoked by a client. It is only safe to do this between * the {@link #join join} and {@link #fork fork} elements of * that sequence. Either all the CALL * channel methods should do this or none - in the latter case, its default * value remains as zero. Its value is returned to a server as the result * the server's invocation of {@link #accept accept}. */ protected int selected = 0; // set (optionally) by the caller /** * This is invoked by a server when it commits to accepting a CALL * from a client. The parameter supplied must be a reference to this server * - see the example from {@link One2OneCallChannel}. * It will not complete until a CALL has been made. If the derived CALL channel has set * the {@link #selected} field in the way defined by the standard * calling sequence, * the value returned by this method will indicate which method was called. * * @param server the server process receiving the CALL. */ public int accept(CSProcess server) { // invoked by the callee this.server = server; c.read(); // ready to ACCEPT the CALL d.read(); // wait until the CALL is complete return selected; } /** * This is invoked by a client during the standard calling * sequence. It will not complete until a server invokes * an {@link #accept accept} on this channel. In turn, that accept * will not complete until the client invokes a {@link #fork fork}, * after having made its CALL on the server. */ protected void join() { // indirectly invoked by the caller c.write(null); } /** * This is invoked by a client during the standard calling * sequence. A server must have invoked an {@link #accept accept} * for the client to have got this far in the sequence - see * the {@link #join join}. This call unblocks that accept, * releasing the server and client to resume separate lives. */ protected void fork() { // indirectly invoked by the caller d.write(null); } /** * This is one of the {@link Guard} methods needed by the {@link Alternative} class. */ boolean enable(Alternative alt) { // ignore this! return c.readerEnable(alt); } /** * This is one of the {@link Guard} methods needed by the {@link Alternative} class. */ boolean disable() { // ignore this! return c.readerDisable(); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/SpuriousLog.java 0000644 0000000 0000000 00000033771 11105701167 017233 0 ustar /************************************************************************* * * * JCSP ("CSP for Java") libraries * * Copyright (C) 1996-2001 Peter Welch and Paul Austin. * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This library is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, * * USA. * * * * Author contact: P.H.Welch@kent.ac.uk * * * *************************************************************************/ package org.jcsp.lang; //{{{ javadoc /** * This holds the log of spurious wakeups and early timeouts. *
Description
* The java.lang.Object.wait method sometimes returns spuriously * - i.e. without being notify'd by another thread or interrupted * or timed-out! This class is an optional (static) repository holding and reporting * counts of any such spurious wakeups. JCSP handles all spurious wakeups cleanly. ** Some JVMs also timeout on calls of wait(timeout) early. This class * enables the specification of how early will be acceptable to JCSP. * ``Timeouts'' returned earlier than the set threshold are treated as * spurious wakeups (i.e. the process is put back to sleep). * Provision is also made for counting and reporting the accepted early timeouts. *
* To operate, this logging must first be switched on ({@link #start}). * * @author P.H. Welch */ //}}} public class SpuriousLog { /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. */ static public final int One2OneChannelIntRead = 0; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int One2OneChannelIntWrite = 1; /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. */ static public final int One2OneChannelIntXRead = 2; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int One2OneChannelIntXWrite = 3; /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. */ static public final int One2OneChannelRead = 4; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int One2OneChannelWrite = 5; /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. */ static public final int One2OneChannelXRead = 6; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int One2OneChannelXWrite = 7; /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. */ static public final int Any2OneChannelIntRead = 8; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int Any2OneChannelIntWrite = 9; /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. */ static public final int Any2OneChannelIntXRead = 10; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int Any2OneChannelIntXWrite = 11; /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. */ static public final int Any2OneChannelRead = 12; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int Any2OneChannelWrite = 13; /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. */ static public final int Any2OneChannelXRead = 14; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int Any2OneChannelXWrite = 15; /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. */ static public final int One2AnyChannelIntRead = 16; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int One2AnyChannelIntWrite = 17; /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. */ static public final int One2AnyChannelIntXRead = 18; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int One2AnyChannelIntXWrite = 19; /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. */ static public final int One2AnyChannelRead = 20; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int One2AnyChannelWrite = 21; /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. */ static public final int One2AnyChannelXRead = 22; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int One2AnyChannelXWrite = 23; /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. */ static public final int Any2AnyChannelIntRead = 24; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int Any2AnyChannelIntWrite = 25; /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. */ static public final int Any2AnyChannelIntXRead = 26; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int Any2AnyChannelIntXWrite = 27; /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. */ static public final int Any2AnyChannelRead = 28; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int Any2AnyChannelWrite = 29; /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. */ static public final int Any2AnyChannelXRead = 30; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int Any2AnyChannelXWrite = 31; /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. */ static public final int AlternativeSelect = 32; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int AlternativeSelectWithTimeout = 33; /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. */ static public final int BarrierSync = 34; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int BucketFallInto = 35; /** * This indexes the counts of spurious wakeups * ({@link #getSpuriousWakeUpCounts()}), * indicating the class and operation that suffered. *
* Note: this field is not operative in the current JCSP release. * Spurious wakeups on AltingBarriers are handled correctly * -- just not recorded. *
*/ static public final int AltingBarrierCoordinateStartEnable = 36; /** * This indexes the counts of spurious wakeups * ({@link #report()}), * indicating the class and operation that suffered. */ static public final int StopRun = 37; static private final int nSpuriousWakeUpPlaces = 38; static private int[] count = new int[nSpuriousWakeUpPlaces]; static private int nSpuriousWakeUps = 0; static private int nEarlyTimeouts = 0; /** * Start logging of spurious wakeups. * This should be set before any concurrency is started. * It should only be set once. * There is no concurrency protection! */ static synchronized public void start () { Spurious.logging = true; } /** * Finish logging of spurious wakeups. * This should be set after any concurrency has finished. * There is no concurrency protection! */ static synchronized public void finish () { Spurious.logging = false; } /** * Returns the number of spurious wakeups so far. * * @return the number of spurious wakeups so far. */ static synchronized public int numberSpuriousWakeUps () { return nSpuriousWakeUps; } /** * Returns the counts of spurious wakeups so far. This array is indexed * by the public constants in this class. Only a clone is returned. * * @return the counts of spurious wakeups so far. */ static synchronized public int[] getSpuriousWakeUpCounts () { return (int[]) count.clone (); } /** * Increment spurious wakeup counts. * * @param x the operation that suffered the spurious wakeup. */ static synchronized void record (int x) { nSpuriousWakeUps++; count[x]++; } /** * This sets the allowed early timeout (in msecs). Some JVMs timeout * on calls of wait(timeout) early - this specifies how early * JCSP will tolerate. ``Timeouts'' returned earlier than the set * threshold are treated as spurious wakeups (i.e. the process * is put back to sleep). ** This should be set before any concurrency is started. * It should only be set once. * There is no concurrency protection! * * @param earlyTimeout the allowed early timeout (in msecs). */ static synchronized public void setEarlyTimeout (long earlyTimeout) { if (earlyTimeout >= 0) { Spurious.earlyTimeout = earlyTimeout; } else { throw new IllegalArgumentException ( "Attempt to set a negative early timeout value\n" ); } } /** * This returns the allowed early timeout (in msecs). * * @return the allowed early timeout (in msecs). */ static synchronized public long getEarlyTimeout () { return Spurious.earlyTimeout; } /** * Returns the number of early timeouts accepted so far. * * @return the number of early timeouts accepted so far. */ static synchronized public int numberEarlyTimeouts () { return nEarlyTimeouts; } /** * Increment the count of early timeouts. */ static synchronized void incEarlyTimeouts () { nEarlyTimeouts++; } /** * This returns a report on the counts of spurious wakeups and early timeouts * so far. A breakdown of spurious wakeup counts is given only if there are some. * * @return the report. */ static synchronized public String report () { String result = "\n>>>>>> Spurious WakeUps: " + nSpuriousWakeUps; if (nSpuriousWakeUps > 0) { for (int i = 0; i < nSpuriousWakeUpPlaces; i++) { if ((i % 10) == 0) { result = result + "\n"; } result = result + " " + i + ":" + count[i]; } } result = result +"\n>>>>>> Early Timeouts: " + nEarlyTimeouts; return result; } private SpuriousLog () { } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelAccept.java 0000644 0000000 0000000 00000006562 11105701167 017426 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * This defines the interface for accepting CALL channels. *
Description
* ChannelAccept defines the interface for accepting CALL channels. * The interface contains only one method - {@link #accept accept}. * *Example
* See the explanations and examples documented in the CALL channel super-classes * (listed below). * * @see org.jcsp.lang.One2OneCallChannel * @see org.jcsp.lang.Any2OneCallChannel * @see org.jcsp.lang.One2AnyCallChannel * @see org.jcsp.lang.Any2AnyCallChannel * * @author P.H. Welch */ public interface ChannelAccept { /** * This is invoked by a server when it commits to accepting a CALL * from a client. The parameter supplied must be a reference to this server * - see the example from {@link One2OneCallChannel}. * It will not complete until a CALL has been made. If the derived CALL channel has set * the selected field in the way defined by the standard * calling sequence, * the value returned by this method will indicate which method was called. * * @param server the server process receiving the CALL. */ public int accept(CSProcess server); } jcsp-1.1-rc4.orig/src/org/jcsp/lang/BufferedOne2AnyChannel.java 0000644 0000000 0000000 00000011751 11105701167 021141 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; import org.jcsp.util.*; /** * This implements an any-to-any object channel with user-definable buffering, * safe for use by many writers and many readers. *Description
* BufferedOne2AnyChannel implements a one-to-any object channel with * user-definable buffering. It is safe for use by any number of reading * processes but ony one writer. Reading processes compete with each other * to use the channel. Only one reader and the writer will actually be using * the channel at any one time. This is taken care of by * BufferedOne2AnyChannel -- user processes just read from or write to it. ** Please note that this is a safely shared channel and not * a multicaster. Currently, multicasting has to be managed by * writing active processes (see {@link org.jcsp.plugNplay.DynamicDelta} * for an example of broadcasting). *
* All reading processes and writing processes commit to the channel * (i.e. may not back off). This means that the reading processes * may not {@link Alternative ALT} on this channel. *
* The constructor requires the user to provide * the channel with a plug-in driver conforming to the * {@link org.jcsp.util.ChannelDataStore ChannelDataStore} * interface. This allows a variety of different channel semantics to be * introduced -- including buffered channels of user-defined capacity * (including infinite), overwriting channels (with various overwriting * policies) etc.. * Standard examples are given in the org.jcsp.util package, but * careful users may write their own. * *
Implementation Note and Caution
* Fair servicing of readers to this channel depends on the fair * servicing of requests to enter a synchronized block (or method) by * the underlying Java Virtual Machine (JVM). Java does not specify how threads * waiting to synchronize should be handled. Currently, Sun's standard JDKs queue * these requests - which is fair. However, there is at least one JVM * that puts such competing requests on a stack - which is legal but unfair * and can lead to infinite starvation. This is a problem for any Java system * relying on good behaviour from synchronized, not just for these * 1-any channels. * * @see org.jcsp.lang.BufferedOne2OneChannel * @see org.jcsp.lang.BufferedOne2AnyChannel * @see org.jcsp.lang.BufferedAny2AnyChannel * @see org.jcsp.util.ChannelDataStore * * @author P.D. Austin * @author P.H. Welch */ class BufferedOne2AnyChannel extends One2AnyImpl { /** * Constructs a new BufferedOne2AnyChannel with the specified ChannelDataStore. * * @param data The ChannelDataStore used to store the data for the channel */ public BufferedOne2AnyChannel(ChannelDataStore data) { super(new BufferedOne2OneChannel(data)); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/AbstractConnectionImpl.java 0000644 0000000 0000000 00000005151 11105701167 021334 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * @author Jo Aldous */ abstract class AbstractConnectionImpl { protected static final int CLIENT_STATE_CLOSED = 1; protected static final int CLIENT_STATE_OPEN = 2; protected static final int CLIENT_STATE_MADE_REQ = 3; protected static final int SERVER_STATE_CLOSED = 1; protected static final int SERVER_STATE_OPEN = 2; protected static final int SERVER_STATE_RECEIVED = 3; protected static final NonSingleRequestOpenMsg nonSingleRequestMsg = new NonSingleRequestOpenMsg(); static class NonSingleRequestOpenMsg { } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/Connection.java 0000644 0000000 0000000 00000020263 11105701167 017027 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * This class provides static factory methods for constructing * different types of connection. The methods are equivalent to * the non-static methods of theStandardConnectionFactory
* class.
*
* @author Quickstone Technologies Limited
*/
public class Connection
{
private static StandardConnectionFactory factory = new StandardConnectionFactory();
/**
* Constructor for Connection.
*/
private Connection()
{
super();
}
/**
* @see org.jcsp.lang.ConnectionFactory#createOne2One()
*/
public static One2OneConnection createOne2One()
{
return factory.createOne2One();
}
/**
* @see org.jcsp.lang.ConnectionFactory#createAny2One()
*/
public static Any2OneConnection createAny2One()
{
return factory.createAny2One();
}
/**
* @see org.jcsp.lang.ConnectionFactory#createOne2Any()
*/
public static One2AnyConnection createOne2Any()
{
return factory.createOne2Any();
}
/**
* @see org.jcsp.lang.ConnectionFactory#createAny2Any()
*/
public static Any2AnyConnection createAny2Any()
{
return factory.createAny2Any();
}
/**
* @see org.jcsp.lang.ConnectionArrayFactory#createOne2One(int)
*/
public static One2OneConnection[] createOne2One(int n)
{
return factory.createOne2One(n);
}
/**
* @see org.jcsp.lang.ConnectionArrayFactory#createAny2One(int)
*/
public static Any2OneConnection[] any2oneArray(int n)
{
return factory.createAny2One(n);
}
/**
* @see org.jcsp.lang.ConnectionArrayFactory#createOne2Any(int)
*/
public static One2AnyConnection[] createOne2Any(int n)
{
return factory.createOne2Any(n);
}
/**
* @see org.jcsp.lang.ConnectionArrayFactory#createAny2Any(int)
*/
public static Any2AnyConnection[] createAny2Any(int n)
{
return factory.createAny2Any(n);
}
/**
* Returns an array of client connection ends suitable for use as guards in an Alternative
* construct.
*
* @param c the connection array to get the client ends from.
* @return the array of client ends.
*/
public static AltingConnectionClient[] getClientArray(One2AnyConnection[] c)
{
AltingConnectionClient r[] = new AltingConnectionClient[c.length];
for (int i = 0; i < c.length; i++)
r[i] = c[i].client();
return r;
}
/**
* Returns an array of client connection ends suitable for use as guards in an Alternative
* construct.
*
* @param c the connection array to get the client ends from.
* @return the array of client ends.
*/
public static AltingConnectionClient[] getClientArray(One2OneConnection[] c)
{
AltingConnectionClient r[] = new AltingConnectionClient[c.length];
for (int i = 0; i < c.length; i++)
r[i] = c[i].client();
return r;
}
/**
* Returns an array of client connection ends suitable for use by multiple concurrent
* processes.
*
* @param c the connection array to get the client ends from.
* @return the array of client ends.
*/
public static SharedConnectionClient[] getClientArray(Any2AnyConnection[] c)
{
SharedConnectionClient r[] = new SharedConnectionClient[c.length];
for (int i = 0; i < c.length; i++)
r[i] = c[i].client();
return r;
}
/**
* Returns an array of client connection ends suitable for use by multiple concurrent
* processes.
*
* @param c the connection array to get the client ends from.
* @return the array of client ends.
*/
public static SharedConnectionClient[] getClientArray(Any2OneConnection[] c)
{
SharedConnectionClient r[] = new SharedConnectionClient[c.length];
for (int i = 0; i < c.length; i++)
r[i] = c[i].client();
return r;
}
/**
* Returns an array of server connection ends suitable for use as guards in an Alternative
* construct.
*
* @param c the connection array to get the server ends from.
* @return the array of server ends.
*/
public static AltingConnectionServer[] getServerArray(Any2OneConnection[] c)
{
AltingConnectionServer r[] = new AltingConnectionServer[c.length];
for (int i = 0; i < c.length; i++)
r[i] = c[i].server();
return r;
}
/**
* Returns an array of server connection ends suitable for use as guards in an Alternative
* construct.
*
* @param c the connection array to get the server ends from.
* @return the array of server ends.
*/
public static AltingConnectionServer[] getServerArray(One2OneConnection[] c)
{
AltingConnectionServer r[] = new AltingConnectionServer[c.length];
for (int i = 0; i < c.length; i++)
r[i] = c[i].server();
return r;
}
/**
* Returns an array of server connection ends suitable for use by multiple concurrent
* processes.
*
* @param c the connection array to get the server ends from.
* @return the array of server ends.
*/
public static SharedConnectionServer[] getServerArray(Any2AnyConnection[] c)
{
SharedConnectionServer r[] = new SharedConnectionServer[c.length];
for (int i = 0; i < c.length; i++)
r[i] = c[i].server();
return r;
}
/**
* Returns an array of server connection ends suitable for use by multiple concurrent
* processes.
*
* @param c the connection array to get the server ends from.
* @return the array of server ends.
*/
public static SharedConnectionServer[] getServerArray(One2AnyConnection[] c)
{
SharedConnectionServer r[] = new SharedConnectionServer[c.length];
for (int i = 0; i < c.length; i++)
r[i] = c[i].server();
return r;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/One2OneConnectionImpl.java 0000644 0000000 0000000 00000010462 11105701167 021037 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.Buffer;
/**
* This class is an implementation of One2OneConnection.
* Each end is safe to be used by one thread at a time.
*
* @author Quickstone Technologies Limited
*/
class One2OneConnectionImpl extends AbstractConnectionImpl implements One2OneConnection
{
private AltingConnectionClient client;
private AltingConnectionServer server;
/**
* Initializes all the attributes to necessary values.
* Channels are created using the static factory in the
* ChannelServer inteface.
*
* Constructor for One2OneConnectionImpl.
*/
public One2OneConnectionImpl()
{
super();
One2OneChannel chanToServer = ConnectionServer.FACTORY.createOne2One(new Buffer(1));
One2OneChannel chanFromServer = ConnectionServer.FACTORY.createOne2One(new Buffer(1));
//create the client and server objects
client = new AltingConnectionClientImpl(chanFromServer.in(),
chanToServer.out(),
chanToServer.out(),
chanFromServer.out());
server = new AltingConnectionServerImpl(chanToServer.in(),
chanToServer.in());
}
/**
* Returns the AltingConnectionClient that can
* be used by a single process at any instance.
*
* This method will always return the same
* AltingConnectionClient object.
* One2OneConnection is only intendended to have two ends.
*
* @return the AltingConnectionClient object.
*/
public AltingConnectionClient client()
{
return client;
}
/**
* Returns the AltingConnectionServer that can
* be used by a single process at any instance.
*
* This method will always return the same
* AltingConnectionServer object.
* One2OneConnection is only intendended to have two ends.
*
* @return the AltingConnectionServer object.
*/
public AltingConnectionServer server()
{
return server;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/ConnectionClientMessage.java 0000644 0000000 0000000 00000004306 11105701167 021473 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import java.io.Serializable;
/**
* @author Quickstone Technologies Limited
*/
class ConnectionClientMessage implements Serializable
{
Object data;
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/SharedChannelInputImpl.java 0000644 0000000 0000000 00000004771 11113671251 021276 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
class SharedChannelInputImpl implements SharedChannelInput {
private ChannelInternals channel;
private int immunity;
SharedChannelInputImpl(ChannelInternals _channel, int _immunity) {
channel = _channel;
immunity = _immunity;
}
public void endRead() {
channel.endRead();
}
public Object read() {
return channel.read();
}
public Object startRead() {
return channel.startRead();
}
public void poison(int strength) {
if (strength > immunity) {
channel.readerPoison(strength);
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/AltingBarrierError.java 0000644 0000000 0000000 00000005647 11105701167 020500 0 ustar
/*************************************************************************
* *
* JCSP ("CSP for Java") libraries *
* Copyright (C) 1996-2008 Peter Welch and Paul Austin. *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Lesser General Public *
* License as published by the Free Software Foundation; either *
* version 2.1 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the Free Software *
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, *
* USA. *
* *
* Author contact: P.H.Welch@kent.ac.uk *
* *
*************************************************************************/
package org.jcsp.lang;
//{{{ javadoc
/**
* This is thrown for an illegal operation on an {@link AltingBarrier}.
*
* Description
* Currently, there are the following causes: *-
*
- * different threads trying to operate on the same front-end; *
- * attempt to use as a {@link Guard} whilst resigned; *
- * attempt to {@link AltingBarrier#sync sync} whilst resigned; *
- * attempt to {@link AltingBarrier#resign resign} whilst resigned; *
- * attempt to {@link AltingBarrier#enroll enroll} whilst enrolled; *
- * attempt to {@link AltingBarrier#expand expand} whilst resigned; *
- * attempt to {@link AltingBarrier#contract contract} whilst resigned; *
- * attempt to {@link AltingBarrier#contract contract} with an array * of front-ends not supplied by {@link AltingBarrier#expand expand}; *
- * attempt to {@link AltingBarrier#mark mark} whilst resigned (caused * by a process transfering a front-end in that state). *
*
* @deprecated There is no longer any need to use this class, after the 1.1 class reorganisation.
*
* Note that usually you do not need the absolute guarantee that this class
* provides - you can usually just cast the channel to an AltingChannelInput,
* which prevents you from accidentally writing to the channel. This
* class mainly exists for use by some of the org.jcsp.net classes, where the
* absolute guarantee that you cannot write to it is important.
*
* @see org.jcsp.lang.AltingChannelInput
*
* @author Quickstone Technologies Limited
*/
public class AltingChannelInputWrapper extends AltingChannelInput
{
/**
* Creates a new AltingChannelInputWrapper which wraps the specified
* channel.
*/
public AltingChannelInputWrapper(AltingChannelInput channel)
{
this.channel = channel;
}
/**
* This constructor does not wrap a channel.
* The underlying channel can be set by calling
* setChannel(AltingChannelInput).
*
*/
protected AltingChannelInputWrapper()
{
this.channel = null;
}
/**
* The real channel which this object wraps.
*
* This used to be a final field but this caused problems
* when sub-classes wanted to be serializable. Added a
* protected mutator.
*/
private AltingChannelInput channel;
/**
* Get the real channel.
*
* @return The real channel.
*/
protected AltingChannelInput getChannel()
{
return channel;
}
/**
* Sets the real channel to be used.
*
* @param chan the real channel to be used.
*/
protected void setChannel(AltingChannelInput chan)
{
this.channel = chan;
}
/**
* Read an Object from the channel.
*
* @return the object read from the channel
*/
public Object read()
{
return channel.read();
}
/**
* Begins an extended rendezvous
*
* @see ChannelInput.startRead
* @return The object read from the channel
*/
public Object startRead()
{
return channel.startRead();
}
/**
* Ends an extended rendezvous
*
* @see ChannelInput.endRead
*/
public void endRead()
{
channel.endRead();
}
/**
* Returns whether there is data pending on this channel.
*
* Note: if there is, it won't go away until you read it. But if there * isn't, there may be some by the time you check the result of this method. * * @return state of the channel. */ public boolean pending() { return channel.pending(); } /** * Returns true if the event is ready. Otherwise, this enables the guard * for selection and returns false. *
* Note: this method should only be called by the Alternative class * * @param alt the Alternative class that is controlling the selection * @return true if and only if the event is ready */ boolean enable(Alternative alt) { return channel.enable(alt); } /** * Disables the guard for selection. Returns true if the event was ready. *
* Note: this method should only be called by the Alternative class * * @return true if and only if the event was ready */ boolean disable() { return channel.disable(); } public void poison(int strength) { channel.poison(strength); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/One2AnyChannelImpl.java 0000644 0000000 0000000 00000011173 11105701167 020316 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * This implements a one-to-any object channel, * safe for use by one writer and many readers. *
Description
* One2AnyChannel is an implementation of a channel which is safe * for use by many reading processes but only one writer. Reading processes * compete with each other to use the channel. Only one reader and the writer will * actually be using the channel at any one time. This is taken care of by * One2AnyChannel -- user processes just read from or write to it. ** Please note that this is a safely shared channel and not * a broadcaster. Currently, broadcasting has to be managed by * writing active processes (see {@link org.jcsp.plugNplay.DynamicDelta} * for an example). *
* All reading processes and the writing process commit to the channel * (i.e. may not back off). This means that the reading processes * may not {@link Alternative ALT} on this channel. *
* The default semantics of the channel is that of CSP -- i.e. it is * zero-buffered and fully synchronised. A reading process must wait * for the matching writer and vice-versa. *
* A factory pattern is used to create channel instances. The create methods of {@link Channel} * allow creation of channels, arrays of channels and channels with varying semantics such as * buffering with a user-defined capacity or overwriting with various policies. * Standard examples are given in the org.jcsp.util package, but * careful users may write their own. * *
Implementation Note and Caution
* Fair servicing of readers to this channel depends on the fair * servicing of requests to enter a synchronized block (or method) by * the underlying Java Virtual Machine (JVM). Java does not specify how threads * waiting to synchronize should be handled. Currently, Sun's standard JDKs queue * these requests - which is fair. However, there is at least one JVM * that puts such competing requests on a stack - which is legal but unfair * and can lead to infinite starvation. This is a problem for any Java system * relying on good behaviour from synchronized, not just for these * 1-any channels. * * @see org.jcsp.lang.One2OneChannel * @see org.jcsp.lang.Any2OneChannel * @see org.jcsp.lang.Any2AnyChannel * @see org.jcsp.util.ChannelDataStore * * @author P.D. Austin and P.H. Welch */ class One2AnyChannelImpl extends One2AnyImpl { One2AnyChannelImpl() { super(new One2OneChannelImpl()); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/AltingBarrierBase.java 0000644 0000000 0000000 00000023355 11105701167 020255 0 ustar /************************************************************************* * * * JCSP ("CSP for Java") libraries * * Copyright (C) 1996-2008 Peter Welch and Paul Austin. * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This library is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, * * USA. * * * * Author contact: P.H.Welch@kent.ac.uk * * * *************************************************************************/ package org.jcsp.lang; class AltingBarrierBase { // package-only visible class /** * All front-ends are chained off here. Each process enrolled must have one, * and only one, of these. */ private AltingBarrier frontEnds = null; /** The number of processes enrolled. */ private int enrolled = 0; /** The number of processes not yet offered to sync on this barrier. */ private int countdown = 0; /* * This creates, and returns, more front-ends to be held by newly enrolling * processes. Initially, none exist - so this * (or {@link #expand()}) must be called at least once. ** Note: except for the first time, this method should only be called by * an AltingBarrier synchronised on this AltingBarrierBase. *
* * @param n the number of front-ends to be created. *
* * @return the new front-ends. * */ AltingBarrier[] expand (int n) { AltingBarrier[] ab = new AltingBarrier[n]; for (int i = 0; i < n; i++) { frontEnds = new AltingBarrier (this, frontEnds); ab[i] = frontEnds; } enrolled += n; countdown += n; return ab; } /* * This creates, and returns, another front-end to be held by a newly enrolling * process. Initially, none exist - so this * (or {@link #expand(int)}) must be called at least once. *
* Note: except for the first time, this method should only be called by * an AltingBarrier synchronised on this AltingBarrierBase. *
* * @return the new front-ends. * */ AltingBarrier expand () { enrolled++; countdown++; frontEnds = new AltingBarrier (this, frontEnds); return frontEnds; } /** * This removes the given front-ends chained to this alting barrier. * It also nulls all of them - to prevent any attempted reuse! *
* Note: this method should only be called by an AltingBarrier synchronised * on this AltingBarrierBase. *
* * @param ab the front-ends being discarded from this barrier. * This array must be unaltered from one previously delivered by * an {@link #expand expand}. */ void contract (AltingBarrier[] ab) { // assume: (ab != null) && (ab.length > 0) AltingBarrier first = ab[0]; // counts the number of front-ends whose (hopefully terminated) processes // were still enrolled. int discard = 0; AltingBarrier fa = null; AltingBarrier fb = frontEnds; while ((fb != null) && (fb != first)) { fa = fb; fb = fb.next; } if (fb == null) { throw new AltingBarrierError ( "\n*** Could not find first front-end in AltingBarrier contract." ); } // Below, we will null elements of "ab" as we pass though the array. // However, the formal "deduce" and "invariant" comments that follow // relate to code that does not do this. This is safe since the logic // of the code does not depend on values of "ab", subsequent to their // anullment. ab[0].base = null; ab[0] = null; // deduce: (fb == ab[0]) && (fb != null) // deduce: (fa == null) || (fa.next == fb) // deduce: (fa == null) <==> (frontEnds == ab[0]) // deduce: (fa != null) <==> (fa.next == ab[0]) for (int i = 1; i < ab.length; i++) { // invariant: (fb == ab[i-1]) && (fb != null) if (fb.enrolled) discard++; fb = fb.next; if (fb == null) { throw new AltingBarrierError ( "\n*** Could not find second (or later) front-end in AltingBarrier contract." ); } if (fb != ab[i]) { throw new AltingBarrierError ( "\n*** Removal array in AltingBarrier contract not one delivered by expand." ); } // deduce: (fb == ab[i]) && (fb != null) ab[i].base = null; ab[i] = null; } // deduce: (fb == ab[(ab.length) - 1]) && (fb != null) if (fb.enrolled) discard++; // deduce: (fa == null) <==> (frontEnds == ab[0]) [NO CHANGE] // deduce: (fa != null) <==> (fa.next == ab[0]) [NO CHANGE] if (fa == null) { frontEnds = fb.next; } else { fa.next = fb.next; } enrolled -= discard; countdown -= discard; if (countdown == 0) { countdown = enrolled; if (enrolled > 0) { AltingBarrierCoordinate.startEnable (); AltingBarrierCoordinate.startDisable (enrolled); AltingBarrier fe = frontEnds; while (fe != null) { fe.schedule (); fe = fe.next; } } } else if (countdown < 0) { throw new JCSP_InternalError ( "Please report the circumstances to jcsp-team@kent.ac.uk - thanks!" ); } } /** * This removes the given front-end chained to this alting barrier. * It also nulls its reference to this base - to prevent any attempted reuse! *
* Note: this method should only be called by an AltingBarrier synchronised * on this AltingBarrierBase. *
* * @param ab the front-end being discarded from this barrier. * This array must be unaltered from one previously delivered by * an {@link #expand expand}. */ void contract (AltingBarrier ab) { // assume: (ab != null) AltingBarrier fa = null; AltingBarrier fb = frontEnds; while ((fb != null) && (fb != ab)) { fa = fb; fb = fb.next; } if (fb == null) { throw new AltingBarrierError ( "\n*** Could not find front-end in AltingBarrier contract." ); } // deduce: (fb == ab) && (fb != null) // deduce: (fa == null) || (fa.next == fb) // deduce: (fa == null) <==> (frontEnds == ab) // deduce: (fa != null) <==> (fa.next == ab) if (fa == null) { frontEnds = fb.next; } else { fa.next = fb.next; } ab.base = null; if (ab.enrolled) { enrolled--; countdown--; } if (countdown == 0) { countdown = enrolled; if (enrolled > 0) { AltingBarrierCoordinate.startEnable (); AltingBarrierCoordinate.startDisable (enrolled); AltingBarrier fe = frontEnds; while (fe != null) { fe.schedule (); fe = fe.next; } } } else if (countdown < 0) { throw new JCSP_InternalError ( "Please report the circumstances to jcsp-team@kent.ac.uk - thanks!" ); } } /** * Record the offer to synchronise. *
* Note: this method should only be called by an AltingBarrier synchronised * on this AltingBarrierBase. *
* * @return true if all the offers are in. */ boolean enable () { countdown--; if (countdown == 0) { countdown = enrolled; AltingBarrierCoordinate.startDisable (enrolled); AltingBarrier fe = frontEnds; while (fe != null) { fe.schedule (); fe = fe.next; } return true; } else { return false; } } /** * Withdraw the offer to synchronise. *
* Note: this method should only be called by an AltingBarrier synchronised * on this AltingBarrierBase. *
* * @return true all the offers are in. */ boolean disable () { if (countdown == enrolled) { return true; } else { countdown++; return false; } } /** * Record resignation. *
* Note: this method should only be called by an AltingBarrier synchronised * on this AltingBarrierBase. *
*/ void resign () { enrolled--; countdown--; if (countdown == 0) { countdown = enrolled; if (enrolled > 0) { AltingBarrierCoordinate.startEnable (); AltingBarrierCoordinate.startDisable (enrolled); AltingBarrier fe = frontEnds; while (fe != null) { fe.schedule (); fe = fe.next; } } } } /** * Record re-enrollment. *
* Note: this method should only be called by an AltingBarrier synchronised * on this AltingBarrierBase. */ void enroll () { enrolled++; countdown++; } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/ParThread.java 0000644 0000000 0000000 00000011277 11105701167 016607 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * This is the Thread class used by {@link Parallel} to run all but * one of its given processes. * *
Description
* A ParThread is a Thread used by {@link Parallel} to run * all but one of its given processes. ** The CSProcess to be executed can be changed using the * setProcess method providing the ParThread is not active. * * @see org.jcsp.lang.CSProcess * @see org.jcsp.lang.ProcessManager * @see org.jcsp.lang.Parallel * * @author P.D. Austin * @author P.H. Welch */ //}}} class ParThread extends Thread { /** the process to be executed */ private CSProcess process; /** the barrier at the end of a PAR */ private Barrier barrier; private boolean running = true; /** parking barrier for this thread */ private Barrier park = new Barrier(2); /** * Construct a new ParThread. * * @param process the process to be executed * @param barrier the barrier for then end of the PAR */ public ParThread(CSProcess process, Barrier barrier) { setDaemon(true); this.process = process; this.barrier = barrier; setName(process.toString()); } /** * reset the ParThread. * * @param process the process to be executed * @param barrier the barrier for then end of the PAR */ public void reset(CSProcess process, Barrier barrier) { this.process = process; this.barrier = barrier; setName(process.toString()); } /** * Sets the ParThread to terminate next time it's unparked. * */ public void terminate() { running = false; park.sync(); } /** * Releases the ParThread to do some more work. */ public void release() { park.sync(); } /** * The main body of this process. * above. */ public void run() { try { Parallel.addToAllParThreads(this); while (running) { try { process.run(); } catch (Throwable e) { Parallel.uncaughtException("org.jcsp.lang.Parallel", e); } barrier.resign(); park.sync(); } } catch (Throwable t) { Parallel.uncaughtException("org.jcsp.lang.Parallel", t); } finally { Parallel.removeFromAllParThreads(this); } } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/SharedChannelInputInt.java 0000644 0000000 0000000 00000004736 11113671251 021130 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * This is the same as {@link ChannelInputInt} except that it is guaranteed * safe to pass on to more than one internal process for parallel reading. *
* A reading-end, obtained from a one-any or any-any * channel by invoking its in() method, will implement this interface. * * @author Quickstone Technologies Limited */ public interface SharedChannelInputInt extends ChannelInputInt { } jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelOutputImpl.java 0000644 0000000 0000000 00000004575 11113671251 020352 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; class ChannelOutputImpl implements ChannelOutput { private ChannelInternals channel; private int immunity; ChannelOutputImpl(ChannelInternals _channel, int _immunity) { channel = _channel; immunity = _immunity; } public void write(Object object) { channel.write(object); } public void poison(int strength) { if (strength > immunity) { channel.writerPoison(strength); } } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/CrewServer.java 0000644 0000000 0000000 00000012545 11105701167 017023 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * @author P.H. Welch */ class CrewServer implements CSProcess { public static final int READER = 0; public static final int WRITER = 1; private final AltingChannelInputInt request; private final AltingChannelInputInt writerControl; private final AltingChannelInputInt readerRelease; ///TODO change this to use poisoning of the above channels, once poison is added private final AltingChannelInputInt poison; public CrewServer(final AltingChannelInputInt request, final AltingChannelInputInt writerControl, final AltingChannelInputInt readerRelease, final AltingChannelInputInt poison) { this.request = request; this.writerControl = writerControl; this.readerRelease = readerRelease; this.poison = poison; } public void run() { int nReaders = 0; final Alternative altMain = new Alternative(new Guard[] {readerRelease, request, poison}); final int MAIN_READER_RELEASE = 0; final int MAIN_REQUEST = 1; final int MAIN_POISON = 2; final Alternative altWriteComplete = new Alternative(new Guard[] {writerControl, poison}); final int WC_WRITER_CONTROL = 0; final int WC_POISON = 1; final Alternative altReadComplete = new Alternative(new Guard[] {readerRelease, poison}); final int RC_READER_RELEASE = 0; final int RC_POISON = 1; while (true) { // invariant : (nReaders is the number of current readers) and (there are no writers) switch (altMain.priSelect()) { case MAIN_READER_RELEASE: readerRelease.read(); nReaders--; break; case MAIN_REQUEST: switch (request.read()) { case READER: nReaders++; break; case WRITER: int n = nReaders; // tmp for (int i = 0; i < n; i++) { switch (altReadComplete.priSelect()) { case RC_READER_RELEASE: readerRelease.read(); nReaders--; // tmp break; case RC_POISON: poison.read(); // let the finalizer complete return; } } nReaders = 0; writerControl.read(); // let writer start writing switch (altWriteComplete.priSelect()) { case WC_WRITER_CONTROL: writerControl.read(); // let writer finish writing break; case WC_POISON: poison.read(); // let the finalizer complete return; } break; } break; case MAIN_POISON: poison.read(); // let the finalizer complete return; } } } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/One2OneChannel.java 0000644 0000000 0000000 00000011105 11113671251 017460 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * This defines the interface for a one-to-one Object channel. *
* The only methods provided are to obtain the ends of the channel, * through which all reading and writing operations are done. * Only an appropriate channel-end should be plugged into a process * – not the whole channel. * A process may use its external channels in one direction only * – either for writing or reading. *
*Actual channels conforming to this interface are made using the relevant * static construction methods from {@link Channel}. * Channels may be {@link Channel#one2one() synchronising}, * {@link Channel#one2one(org.jcsp.util.ChannelDataStore) buffered}, * {@link Channel#one2one(int) poisonable} * or {@link Channel#one2one(org.jcsp.util.ChannelDataStore,int) both} * (i.e. buffered and poisonable). *
* *Description
* One2OneChannelImpl is an interface for a one-to-one object channel. Multiple * readers or multiple writers are not allowed – these are catered for * by {@link Any2OneChannel}, * {@link One2AnyChannel} or * {@link Any2AnyChannel}. ** The reading process may {@link Alternative ALT} on this channel. * The writing process is committed (i.e. it may not back off). *
** The default semantics of the channel is that of CSP – i.e. it is * zero-buffered and fully synchronised. The reading process must wait * for a matching writer and vice-versa. *
*
* The static methods of {@link Channel} construct channels with * either the default semantics or with buffering to user-specified capacity * and a range of blocking/overwriting policies. * Various buffering plugins are given in the org.jcsp.util package, but * careful users may write their own. ** The {@link Channel} methods also provide for the construction of * {@link Poisonable} channels and for arrays of channels. *
* * @see org.jcsp.lang.Channel * @see org.jcsp.lang.Alternative * @see org.jcsp.lang.Any2OneChannel * @see org.jcsp.lang.One2AnyChannel * @see org.jcsp.lang.Any2AnyChannel * @see org.jcsp.util.ChannelDataStore * * @author P.D. Austin * @author P.H. Welch */ public interface One2OneChannel { /** * Returns the input channel end. */ public AltingChannelInput in(); /** * Returns the output channel end. */ public ChannelOutput out(); } jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelFactory.java 0000644 0000000 0000000 00000005705 11105701167 017634 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; /** * Defines an interface for a factory to create instances of channels. * * @author Quickstone Technologies Limited * * @deprecated These channel factories are deprecated in favour of the new one2one() methods in the Channel class. */ public interface ChannelFactory { /** * Creates a newOne2One channel.
*
* @return the created channel.
*/
public One2OneChannel createOne2One();
/**
* Creates a new Any2One channel.
*
* @return the created channel.
*/
public Any2OneChannel createAny2One();
/**
* Creates a new One2Any channel.
*
* @return the created channel.
*/
public One2AnyChannel createOne2Any();
/**
* Creates a new Any2Any channel.
*
* @return the created channel.
*/
public Any2AnyChannel createAny2Any();
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/One2OneChannelSymmetric.java 0000644 0000000 0000000 00000007656 11113671251 021375 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This defines the interface for a symmetric one-to-one Object channel.
* The symmetry relates to the use of its channel ends as {@link Guard guards}
* in an {@link Alternative}: both ends may be so used.
* * The only methods provided are to obtain the ends of the channel, * through which all reading and writing operations are done. * Only an appropriate channel-end should be plugged into a process * – not the whole channel. * A process may use its external channels in one direction only * – either for writing or reading. *
*Actual channels conforming to this interface are made using the relevant * static construction methods from {@link Channel}. * Only fully {@link Channel#one2oneSymmetric() synchronising} channels are currently supported. *
*Description
* One2OneChannelImpl is an interface for a symmetric one-to-one Object channel. * Multiple readers or multiple writers are not allowed. ** Both the reading and writing processes may {@link Alternative ALT} on this channel. *
** The semantics of the channel is that of CSP – i.e. it is * zero-buffered and fully synchronised. The reading process must wait * for a matching writer and vice-versa. *
*
* These channels may be constructed by the {@link Channel#one2oneSymmetric()}. * Channel poisoning and buffering are not currently supported for these channels. * * * @see org.jcsp.lang.Alternative * @see org.jcsp.lang.One2OneChannel * * @author P.H. Welch * @author N.C.C. Brown */ public interface One2OneChannelSymmetric { /** * Returns the input channel end. */ public AltingChannelInput in (); /** * Returns the output channel end. */ public AltingChannelOutput out (); } jcsp-1.1-rc4.orig/src/org/jcsp/lang/Parallel.java 0000644 0000000 0000000 00000073603 11105701167 016472 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; import java.util.*; /** * This process constructor taks an array of CSProcesses * and returns a CSProcess that is the parallel composition of * its process arguments. ** Shortcut to the Constructor and Method Summaries. *
Description
* The Parallel constructor taks an array of CSProcesses * and returns a CSProcess that is the parallel composition of * its process arguments. A run of a Parallel process * terminates when, and only when, all its component processes terminate. ** Note: for those familiar with the occam multiprocessing * language, the Parallel class gives the semantics of the * PAR construct. However, none of the parallel usage * checks mandated by occam can be made by the Java compiler, * so we need to exercise that care ourselves. * For instance, do not try to run the same process instance more than once * in parallel and, generally, watch out for accidentally shared objects! * Running different instances of the same process in parallel * is, of course, allowed. *
* CSProcesses can be added to a Parallel object either via * the {@link #Parallel(CSProcess[]) constructor} or the {@link #addProcess addProcess} methods. * If a call to addProcess is made while the run method is executing, * the extra process(es) will not be included in the network until the next time * run is invoked. *
* CSProcesses can be removed from a Parallel object * via the {@link #removeProcess removeProcess} or * {@link #removeAllProcesses removeAllProcesses} method. * If a call to removeProcess or removeAllProcesses * is made while the run method is executing, the process will * not be removed from the network until the next time run is * invoked. *
* Note: to add/remove a process to/from a network whilst it is running, * see the {@link ProcessManager} class. *
*Example
* The following examples demonstrate high and low level use of Parallel. *High Level
* This high-level example sets up a communicating network * of (in this case non-terminating) processes. Data-flow diagrams are a great help * for designing, understanding and maintaining such parallel systems: *
* import org.jcsp.lang.*;
* import org.jcsp.plugNplay.*;
*
* class ParaplexIntTest {
*
* public static void main (String[] args) {
*
* final One2OneChannelInt[] a = Channel.one2oneIntArray (3);
* final One2OneChannel b = Channel.one2one ();
*
* new Parallel (
* new CSProcess[] {
* new NumbersInt (a[0].out ()),
* new SquaresInt (a[1].out ()),
* new FibonacciInt (a[2].out ()),
* new ParaplexInt (ChannelInt.getInputArray (a), b.out ()),
* new CSProcess () {
* public void run () {
* System.out.println ("\n\t\tNumbers\t\tSquares\t\tFibonacci\n");
* while (true) {
* int[] data = (int[]) b.in ().read ();
* for (int i = 0; i < data.length; i++) {
* System.out.print ("\t\t" + data[i]);
* }
* System.out.println ();
* }
* }
* }
* }
* ).run ();
* }
*
* }
*
* This example tabulates columns of (respectively) natural numbers, perfect
* squares and the Fibonacci sequence. At this level, we are only aware of
* five communicating processes: three that generate the respective sequences
* of integers, one that multiplexes a single item from each sequence into
* a single packet and the in-lined process that receives this packet
* and tabulates its contents. And, at this level, that is all we need to think
* about.
* * However, clicking on any of the generator processes reveals sub-networks * (and, in the case of {@link org.jcsp.plugNplay.ints.SquaresInt} and * {@link org.jcsp.plugNplay.ints.FibonacciInt}, sub-sub-networks). * Altogether, the example contains 28 parallel processes -- 18 of them * high-level (and non-terminating) and 10 low-level * (and transient, but repeatedly re-invoked). One of the key benefits of CSP is that * its semantics are compositional -- i.e. we do not have to reason about * all those 28 processes at the same time to reason about how they behave * in this application. We can build up the complexity in layers. *
* Note: the above example is just to build fluency with the CSP/occam * concept of parallel composition and to show how easy it is. The network * decomposes into fine-grained stateless components that would be excellent * if we were refining this application down to a silicon (e.g. FPGA) implementation * -- but for software running on a uni-processor JVM, we would not suggest going * quite so far! *
* Note: the above layered network of communicating parallel processes is * completely deterministic. It will produce the same results regardless of * the scheduling characteristics of the underlying JVM and regardless of its * physical distribution on to separate processors (and their relative speeds). * This default determinism is one of the founding strengths of CSP concurrency * that reinforces confidence in the systems we build with it. *
* Non-determinism, of course, needs to be addressed for many applications * and is catered for in JCSP by its {@link Alternative} construct * (which corresponds to the CSP external choice operator and occam ALT), * by its any-1, 1-any and any-any channels * (e.g. {@link Any2OneChannel}) and by the overwriting semantics * that can be defined for its channels (e.g. {@link org.jcsp.util.OverWriteOldestBuffer}). * The fact that non-determinism has to be explicitly introduced reduces * the chance of overlooking race-hazards caused by that non-determinism. *
Low Level
* For a low-level application of Parallel, here is the implementation * of the {@link org.jcsp.plugNplay.ints.ParaplexInt} process used in the high-level example above: *
* package org.jcsp.plugNplay.ints;
*
* import org.jcsp.lang.*;
*
* public final class ParaplexInt implements CSProcess {
*
* private final ChannelInputInt[] in;
*
* private final ChannelOutput out;
*
* public ParaplexInt (final ChannelInputInt[] in, final ChannelOutput out) {
* this.in = in;
* this.out = out;
* }
*
* public void run () {
*
* final ProcessReadInt[] inputProcess = new ProcessReadInt[in.length];
* for (int i = 0; i < in.length; i++) {
* inputProcess[i] = new ProcessReadInt (in[i]);
* }
*
* Parallel parInput = new Parallel (inputProcess);
*
* int[][] data = new int[2][in.length]; // double-buffer
* int index = 0; // initial buffer index
*
* while (true) {
* parInput.run ();
* int[] buffer = data[index]; // grab a buffer
* for (int i = 0; i < in.length; i++) {
* buffer[i] = inputProcess[i].value;
* }
* out.write (buffer);
* index = 1 - index; // switch buffers
* }
*
* }
*
* }
*
* Note that the Parallel object (parInput) is constructed once and contains an array
* of processes ({@link org.jcsp.plugNplay.ints.ProcessReadInt}), each of which performs only a single channel
* input and, then, terminates. Each time it is run (parInput.run inside
* the loop), all those sub-processes run concurrently -- the parallel run terminating
* when, and only when, all those sub-processes have terminated. See the documentation
* of {@link org.jcsp.plugNplay.ints.ParaplexInt} for the motivation for this low-level concurrency (and for
* the double-buffering).
*
* Implementation Note
* The Parallel object creates new {@link java.lang.Thread}s to run the first * (n - 1) of its processes, running the last one in its own thread of control. * After each run of the Parallel {@link CSProcess}, all those threads * are parked for reuse in the next run. Thus in the above low-level * application, the overhead for Java thread creation for the internal concurrency * is only incurred on its first cycle. All these implementation Threads * are daemons and, so, will terminate if everything else terminates. *
* If a Parallel process has finished its run() and is not going
* to be used again, its parked threads may be unparked and terminated by invoking
* its {@link #releaseAllThreads releaseAllThreads} method. This will release
* the memory used by those threads.
*
* @see org.jcsp.lang.CSProcess
* @see org.jcsp.lang.ProcessManager
* @see org.jcsp.lang.Sequence
*
* @author P.D. Austin
* @author P.H. Welch
*/
public class Parallel implements CSProcess
{
/**
* Monitor for internal synchronisation.
*/
private final Object sync = new Object();
/** The processes to be executed in Parallel */
private CSProcess[] processes;
/** The number of processes in this Parallel */
private int nProcesses = 0;
/** A pool of ParThreads */
private ParThread[] parThreads;
/** The number of threads created so far by this Parallel */
private int nThreads = 0;
// invariant : (0 <= nProcesses <= processes.length)
// invariant : (0 <= nThreads <= parThreads.length)
/** Used to synchronise the termination of processes in each run of Parallel */
private Barrier barrier = new Barrier();
private boolean priority;
private boolean processesChanged;
/**
* The threads created by all Parallel and {@link ProcessManager} objects.
*/
private static final Set allParThreads = Collections.synchronizedSet(new HashSet());
/**
* Indicates that the destroy() method has already been called.
*/
private static boolean destroyCalled = false;
/**
* Adds the thread object to the allParThreads collection. This should be called by any infrastructure threads when they start.
*
* @param newThread the thread to be added to the collection.
*/
static void addToAllParThreads(final Thread newThread) throws InterruptedException
{
synchronized (allParThreads)
{
if (destroyCalled)
throw new InterruptedException("Parallel.destroy() has been called");
allParThreads.add(newThread);
}
}
/**
* Removes the thread object from the allParThreads collection.
*/
static void removeFromAllParThreads(final Thread oldThread)
{
synchronized (allParThreads)
{
allParThreads.remove(oldThread);
}
}
/**
* Stops all threads created by all Parallel and {@link ProcessManager} objects. No new threads can be
* created until the resetDestroy method gets called.
*/
public static void destroy()
{
synchronized (allParThreads)
{
if (!destroyCalled)
{
System.out.println("*** org.jcsp.lang.Parallel: stopping " +
allParThreads.size() + " threads");
for (Iterator i = allParThreads.iterator(); i.hasNext(); )
{
final Thread t = (Thread)i.next();
try
{
t.interrupt();
}
catch (SecurityException e)
{
System.out.println("*** org.jcsp.lang.Parallel: couldn't stop thread " +
t + " - security exception");
}
}
destroyCalled = true;
}
}
}
/**
* Cancels a call to destroy allowing the JCSP system to be reused. This is provided to that destroy
* can be called from an Applet's termination method, but the Applet can be restarted later.
*/
public static void resetDestroy()
{
synchronized (allParThreads)
{
destroyCalled = false;
}
}
/**
* Construct a new Parallel object initially without any processes.
*/
public Parallel()
{
this(null, false);
}
/**
* Construct a new Parallel object initially without any processes.
* If the priority parameter has the value true, priorities higher in
* the process list will be given a higher priority.
*
* @param priority indicates that different priorities should be given to processes.
*/
Parallel(boolean priority) // package visibilty
{
this(null, priority);
}
/**
* Construct a new Parallel object with the processes specified.
*
* @param processes The processes to be executed in parallel
*/
public Parallel(CSProcess[] processes)
{
this(processes, false);
}
/**
* Construct a new Parallel object with the processes specified.
*
* @param processes The processes to be executed in parallel
*/
public Parallel (CSProcess[][] processes)
{
if (processes != null)
{
int count = 0;
for (int i = 0; i < processes.length; i++)
{
if (processes[i] != null) count += processes[i].length;
}
nProcesses = count;
this.processes = new CSProcess[nProcesses];
count = 0;
for (int i = 0; i < processes.length; i++)
{
if (processes[i] != null)
{
int n = processes[i].length;
System.arraycopy (processes[i], 0, this.processes, count, n);
count += n;
}
}
parThreads = new ParThread[nProcesses];
}
else
{
nProcesses = 0;
this.processes = new CSProcess[0];
parThreads = new ParThread[0];
}
processesChanged = true;
this.priority = false;
}
/**
* Construct a new Parallel object with the processes specified.
* If the priority parameter has the value true, priorities higher in
* the process list will be given a higher priority.
*
* @param processes the processes to be executed in parallel
* @param priority indicates that different priorities should be given to processes.
*/
Parallel(CSProcess[] processes, boolean priority) // package visibilty
{
if (processes != null)
{
nProcesses = processes.length;
this.processes = new CSProcess[nProcesses];
System.arraycopy(processes, 0, this.processes, 0, nProcesses);
parThreads = new ParThread[nProcesses];
}
else
{
nProcesses = 0;
this.processes = new CSProcess[0];
parThreads = new ParThread[0];
}
processesChanged = true;
this.priority = priority;
}
/**
* Add the process to the Parallel object. The extended network
* will be executed the next time run() is invoked.
*
* @param process the CSProcess to be added
*/
public void addProcess(CSProcess process)
{
synchronized (sync)
{
if (process != null)
{
final int targetProcesses = nProcesses + 1;
if (targetProcesses > processes.length)
{
final CSProcess[] tmp = processes;
processes = new CSProcess[2 * targetProcesses];
System.arraycopy(tmp, 0, processes, 0, nProcesses);
}
processes[nProcesses] = process;
nProcesses = targetProcesses;
processesChanged = true;
}
}
}
/**
* Add the array of processes to the Parallel object.
* The extended network will be executed the next time
* run() is invoked.
*
* @param newProcesses the CSProcesses to be added
*/
public void addProcess(CSProcess[] newProcesses)
{
synchronized (sync)
{
if (processes != null)
{
final int extra = newProcesses.length;
final int targetProcesses = nProcesses + extra;
if (targetProcesses > processes.length)
{
final CSProcess[] tmp = processes;
processes = new CSProcess[2 * targetProcesses];
System.arraycopy(tmp, 0, processes, 0, nProcesses);
}
System.arraycopy(newProcesses, 0, processes, nProcesses, extra);
nProcesses = targetProcesses;
processesChanged = true;
}
}
}
/**
* Insert another process to the pri-parallel object at the specifed
* index. The point of insertion is significant because the ordering of
* process components determines the priorities. The extended network
* will be executed the next time run() is invoked.
*
* @param process the process to be inserted * @param index the index at which to insert the process */ public void insertProcessAt(CSProcess process, int index) { synchronized (sync) { if (index >= nProcesses + 1) throw new ArrayIndexOutOfBoundsException(index + " > " + (nProcesses + 1)); if (process != null) { final int targetProcesses = nProcesses + 1; if (targetProcesses > processes.length) { final CSProcess[] tmp = processes; processes = new CSProcess[2 * targetProcesses]; System.arraycopy(tmp, 0, processes, 0, index); System.arraycopy(tmp, index, processes, index + 1, nProcesses - index); } else { if (index < nProcesses) System.arraycopy(processes, index, processes, index + 1, nProcesses - index); } processes[index] = process; nProcesses = targetProcesses; processesChanged = true; } } } /** * Remove the process from the Parallel object. The cut-down network * will not be executed until the next time run() is invoked. * * @param process the CSProcess to be removed */ public void removeProcess(CSProcess process) { synchronized (sync) { for (int i = 0; i < nProcesses; i++) { if (processes[i] == process) { if (i < nProcesses - 1) System.arraycopy(processes, i + 1, processes, i, nProcesses - (i + 1)); nProcesses--; processes[nProcesses] = null; processesChanged = true; return; } } } } /** * Remove all processes from the Parallel object. The cut-down network * will not be executed until the next time run() is invoked. */ public void removeAllProcesses() { synchronized (sync) { for (int i = 0; i < nProcesses; i++) { processes[i] = null; } nProcesses = 0; processesChanged = true; } } /** * System finalizer. When this object falls out of scope it will release all of the threads that it * has allocated. */ protected void finalize() throws Throwable { releaseAllThreads(); } /** * Release all threads saved by the Parallel object for future runs - * the threads all terminate and release their associated workspaces. * This should only be executed when the Parallel object is not running. * If this Parallel object is run again, the necessary threads will be * recreated. */ public void releaseAllThreads() { synchronized (sync) { for (int i = 0; i < nThreads; i++) { parThreads[i].terminate(); parThreads[i] = null; } nThreads = 0; processesChanged = true; } } /** * @return the number of processes currently registered. */ public int getNumberProcesses() { int n; synchronized (sync) { n = nProcesses; } return n; } /** * Run the parallel composition of the processes registered with this * Parallel object. It terminates when, and only when, all its component * processes terminate. *
*Implementation note: In its first run, only * (numProcesses - 1) Threads are created to run the processes -- * the last process is executed in the invoking Thread. * Sunsequent runs reuse these Threads (so the overhead * of thread creation happens only once).
*/ public void run() { boolean emptyRun = true; CSProcess myProcess = null; synchronized (sync) { if (nProcesses > 0) { emptyRun = false; int currentPriority = 0; int maxPriority = 0; if (priority) { Thread thread = Thread.currentThread(); currentPriority = thread.getPriority(); maxPriority = Math.min( currentPriority + nProcesses - 1, Math.min(Thread.MAX_PRIORITY, thread.getThreadGroup().getMaxPriority() ) ); } barrier.reset(nProcesses); myProcess = processes[nProcesses - 1]; if (processesChanged) { if (nThreads < nProcesses - 1) { if (parThreads.length < nProcesses - 1) { final ParThread[] tmp = parThreads; parThreads = new ParThread[processes.length]; System.arraycopy(tmp, 0, parThreads, 0, nThreads); } for (int i = 0; i < nThreads; i++) { parThreads[i].reset(processes[i], barrier); if (priority) { parThreads[i].setPriority(Math.max( currentPriority, maxPriority - i)); } parThreads[i].release(); } for (int i = nThreads; i < nProcesses - 1; i++) { parThreads[i] = new ParThread(processes[i], barrier); if (priority) { parThreads[i].setPriority(Math.max( currentPriority, maxPriority - i)); } parThreads[i].start(); } nThreads = nProcesses - 1; } else { for (int i = 0; i < nProcesses - 1; i++) { parThreads[i].reset(processes[i], barrier); if (priority) { parThreads[i].setPriority(Math.max( currentPriority, maxPriority - i)); } parThreads[i].release(); } } processesChanged = false; } else { for (int i = 0; i < nProcesses - 1; i++) { if (priority) { parThreads[i].setPriority(Math.max(currentPriority, maxPriority - i)); } parThreads[i].release(); } } } } // end synchronized block if (! emptyRun) { try { myProcess.run(); } catch (ProcessInterruptedException e) { // If this was raised then we must propogate the interrupt signal to other processes // PHW: Why? This seems unnecessary ... and, in any case, isn't done if sibling // processes (in their parThreads) are interrupted! synchronized (sync) { // PHW: why synchronize? for (int i = 0; i < nThreads; i++) { try { parThreads[i].interrupt(); } catch (Throwable t) { System.out.println( "*** org.jcsp.lang.Parallel: couldn't stop thread " + t + " - security exception"); } } } } catch (Throwable e) { uncaughtException("org.jcsp.lang.Parallel", e); } barrier.sync(); } } /** * TRUE iff uncaught exceptions are to be displayed. */ private static boolean displayExceptions = true; /** * TRUE iff uncaught errors are to the displayed. */ private static boolean displayErrors = true; /** * Enables or disables the display of Exceptions uncaught by a CSProcess running within a Parallel or under a * ProcessManager object. */ public static void setUncaughtExceptionDisplay(final boolean enable) { displayExceptions = enable; } /** * Enables or disables the display or Errors uncaught by a CSProcess running within a Parallel or under a * ProcessManager object. */ public static void setUncaughtErrorDisplay(final boolean enable) { displayErrors = enable; } static void uncaughtException(final String caller, final Throwable t) { if (((t instanceof Error) && displayErrors) || ((t instanceof Exception) && displayExceptions)) { synchronized (System.err) { System.err.println("\n*** " + caller + ": A process threw the following exception :"); t.printStackTrace(); System.err.println(); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/RejectableChannelOutputImpl.java 0000644 0000000 0000000 00000004267 11113671251 022331 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; class RejectableChannelOutputImpl extends ChannelOutputImpl implements RejectableChannelOutput { public RejectableChannelOutputImpl(ChannelInternals _channel, int _immunity) { super(_channel, _immunity); } } jcsp-1.1-rc4.orig/src/org/jcsp/lang/PoisonableOne2OneChannelImpl.java 0000644 0000000 0000000 00000030364 11113402355 022323 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.lang; import java.io.Serializable; /** * This implements a one-to-one object channel. *Description
* One2OneChannelImpl implements a one-to-one object channel. Multiple * readers or multiple writers are not allowed -- these are catered for * by {@link Any2OneChannelImpl}, * {@link One2AnyChannelImpl} or * {@link Any2AnyChannelImpl}. ** The reading process may {@link Alternative ALT} on this channel. * The writing process is committed (i.e. it may not back off). *
* The default semantics of the channel is that of CSP -- i.e. it is * zero-buffered and fully synchronised. The reading process must wait * for a matching writer and vice-versa. *
* However, the static methods of {@link Channel} allow the creation of
* a channel with a plug-in driver conforming to the
* {@link org.jcsp.util.ChannelDataStore ChannelDataStore}
* interface. This allows a variety of different channel semantics to be
* introduced -- including buffered channels of user-defined capacity
* (including infinite), overwriting channels (with various overwriting
* policies) etc..
* Standard examples are given in the org.jcsp.util package, but
* careful users may write their own.
*
* @see org.jcsp.lang.Alternative
* @see org.jcsp.lang.Any2OneChannelImpl
* @see org.jcsp.lang.One2AnyChannelImpl
* @see org.jcsp.lang.Any2AnyChannelImpl
* @see org.jcsp.util.ChannelDataStore
*
* @author P.D. Austin
* @author P.H. Welch
*/
class PoisonableOne2OneChannelImpl implements One2OneChannel, Serializable, ChannelInternals
{
/** The monitor synchronising reader and writer on this channel */
private Object rwMonitor = new Object ();
/** The (invisible-to-users) buffer used to store the data for the channel */
private Object hold;
/** The synchronisation flag */
private boolean empty = true;
/**
* This flag indicates that the last transfer went OK. The purpose is to not
* throw a PoisonException to the writer side when the last transfer went
* OK, but the reader side injected poison before the writer side finished
* processing of the last write transfer.
*/
private boolean done = false;
/**
* 0 means unpoisoned
*/
private int poisonStrength = 0;
/**
* Immunity is passed to the channel-ends, and is not used directly by the channel algorithms
*/
private int immunity;
/** The Alternative class that controls the selection */
private Alternative alt;
/** Flag to deal with a spurious wakeup during a write */
private boolean spuriousWakeUp = true;
private boolean isPoisoned() {
return poisonStrength > 0;
}
PoisonableOne2OneChannelImpl(int _immunity) {
immunity = _immunity;
}
/*************Methods from One2OneChannel******************************/
/**
* Returns the AltingChannelInput to use for this channel.
* As One2OneChannelImpl implements
* AltingChannelInput itself, this method simply returns
* a reference to the object that it is called on.
*
* @return the AltingChannelInput object to use for this
* channel.
*/
public AltingChannelInput in()
{
return new AltingChannelInputImpl(this,immunity);
}
/**
* Returns the ChannelOutput object to use for this channel.
* As One2OneChannelImpl implements
* ChannelOutput itself, this method simply returns
* a reference to the object that it is called on.
*
* @return the ChannelOutput object to use for this
* channel.
*/
public ChannelOutput out()
{
return new ChannelOutputImpl(this,immunity);
}
/*************Methods from ChannelOutput*******************************/
/**
* Writes an Object to the channel.
*
* @param value the object to write to the channel.
*/
public void write(Object value) {
synchronized (rwMonitor) {
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
hold = value;
if (empty) {
empty = false;
if (alt != null) {
alt.schedule();
}
} else {
empty = true;
rwMonitor.notify();
}
try {
rwMonitor.wait();
while (spuriousWakeUp && !isPoisoned()) {
if (Spurious.logging) {
SpuriousLog.record(SpuriousLog.One2OneChannelWrite);
}
rwMonitor.wait();
}
spuriousWakeUp = true;
} catch (InterruptedException e) {
throw new ProcessInterruptedException(
"*** Thrown from One2OneChannel.write (Object)\n" + e.toString());
}
if (done) {
done = false;
} else if (isPoisoned()) {
hold = null;
throw new PoisonException(poisonStrength);
} else {
done = true;
}
}
}
/** ***********Methods from AltingChannelInput************************* */
/**
* Reads an Object from the channel.
*
* @return the object read from the channel.
*/
public Object read () {
synchronized (rwMonitor) {
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
if (empty) {
empty = false;
try {
rwMonitor.wait ();
while (!empty && !isPoisoned()) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.One2OneChannelRead);
}
rwMonitor.wait ();
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException ("*** Thrown from One2OneChannel.read ()\n"
+ e.toString ());
}
} else {
empty = true;
}
spuriousWakeUp = false;
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
} else {
done = true;
rwMonitor.notify();
return hold;
}
}
}
public Object startRead() {
synchronized (rwMonitor) {
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
if (empty) {
empty = false;
try {
rwMonitor.wait ();
while (!empty && !isPoisoned()) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.One2OneChannelRead);
}
rwMonitor.wait ();
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException ("*** Thrown from One2OneChannel.read ()\n"
+ e.toString ());
}
} else {
empty = true;
}
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
return hold;
}
}
public void endRead() {
synchronized (rwMonitor) {
spuriousWakeUp = false;
rwMonitor.notify ();
}
}
/**
* turns on Alternative selection for the channel. Returns true if the
* channel has data that can be read immediately.
*
* Note: this method should only be called by the Alternative class * * @param alt the Alternative class which will control the selection * @return true if the channel has data that can be read, else false */ public boolean readerEnable (Alternative alt) { synchronized (rwMonitor) { if (isPoisoned()) { return true; } if (empty) { this.alt = alt; return false; } else { return true; } } } /** * turns off Alternative selection for the channel. Returns true if the * channel contained data that can be read. *
* Note: this method should only be called by the Alternative class * * @return true if the channel has data that can be read, else false */ public boolean readerDisable () { synchronized (rwMonitor) { alt = null; return !empty || isPoisoned(); } } /** * Returns whether there is data pending on this channel. *
* Note: if there is, it won't go away until you read it. But if there * isn't, there may be some by the time you check the result of this method. *
* This method is provided for convenience. Its functionality can be provided * by Pri Alting the channel against a SKIP guard, although * at greater run-time and syntactic cost. For example, the following code * fragment: *
* if (c.pending ()) {
* Object x = c.read ();
* ... do something with x
* } else (
* ... do something else
* }
*
* is equivalent to:
*
* if (c_pending.priSelect () == 0) {
* Object x = c.read ();
* ... do something with x
* } else (
* ... do something else
* }
*
* where earlier would have had to have been declared:
*
* final Alternative c_pending =
* new Alternative (new Guard[] {c, new Skip ()});
*
*
* @return state of the channel.
*/
public boolean readerPending () {
synchronized (rwMonitor) {
return !empty || isPoisoned();
}
}
public void writerPoison(int strength) {
if (strength > 0) {
synchronized (rwMonitor) {
this.poisonStrength = strength;
rwMonitor.notifyAll();
if (null != alt) {
alt.schedule();
}
}
}
}
public void readerPoison(int strength) {
if (strength > 0) {
synchronized (rwMonitor) {
this.poisonStrength = strength;
rwMonitor.notifyAll();
}
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Spurious.java 0000644 0000000 0000000 00000006756 11105701167 016574 0 ustar
/*************************************************************************
* *
* JCSP ("CSP for Java") libraries *
* Copyright (C) 1996-2008 Peter Welch and Paul Austin. *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Lesser General Public *
* License as published by the Free Software Foundation; either *
* version 2.1 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the Free Software *
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, *
* USA. *
* *
* Author contact: P.H.Welch@kent.ac.uk *
* *
*************************************************************************/
package org.jcsp.lang;
//{{{ javadoc
/**
* This holds the static flag (indicating whether spurious wakeups should be logged)
* and early timeout allowance (for {@link Alternative}s with {@link CSTimer} guards).
*
* Description
* These fields are held in this separate class to minimise class loading when * spurious wakeups are not logged - the default condition. * * @see org.jcsp.lang.SpuriousLog * * @author P.H. Welch */ //}}} class Spurious { // package-only visible /** * If logging is required, this flag should be set before any concurrency * is started. It should only be set once using {@link SpuriousLog#start()}. * There is no concurrency protection! */ static public boolean logging = false; /** * This is the allowed early timeout (in msecs). Some JVMs timeout on calls * of wait (timeout) early - this specifies how early JCSP will tolerate. ** We need this to distinguish between a JVM-early timeout (that should * be accepted) and a spurious wakeup (that should not). The value to * which this field should be set is machine dependant. For JVMs that do not * return early timeouts, it should be set to zero. For many, it should be * left at the default value (4). If {@link Spurious#logging} is enabled, * counts of spurious wakeups versus accepted early timeouts on select * operations on {@link Alternative}s can be obtained; this field should be * set to minimise the former. *
* This field should be set before any concurrency is started.
* It should only be set once using {@link SpuriousLog#setEarlyTimeout(long)}.
* There is no concurrency protection!
*/
static public long earlyTimeout = 9;
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/Any2OneConnectionImpl.java 0000644 0000000 0000000 00000010245 11105701167 021044 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.*;
/**
* This class is an implementation of Any2OneConnection.
* Each end is safe to be used by one thread at a time.
*
* @author Quickstone Technologies Limited
*/
class Any2OneConnectionImpl implements Any2OneConnection
{
private AltingConnectionServer server;
private One2OneChannel chanToServer;
private One2OneChannel chanFromServer;
private Any2OneChannel chanSynch;
/**
* Initializes all the attributes to necessary values.
* Channels are created using the static factory in the
* ChannelServer inteface.
*
* Constructor for One2OneConnectionImpl.
*/
public Any2OneConnectionImpl() {
super();
chanToServer = ConnectionServer.FACTORY.createOne2One(new Buffer(1));
chanFromServer = ConnectionServer.FACTORY.createOne2One(new Buffer(1));
chanSynch = ConnectionServer.FACTORY.createAny2One(new Buffer(1));
//create the server object - client object created when accessed
server = new AltingConnectionServerImpl(chanToServer.in(), chanToServer.in());
}
/**
* Returns the AltingConnectionClient that can
* be used by a single process at any instance.
*
* @return the AltingConnectionClient object.
*/
public SharedAltingConnectionClient client()
{
return new SharedAltingConnectionClient(chanFromServer.in(),
chanSynch.in(),
chanToServer.out(),
chanToServer.out(),
chanSynch.out(),
chanFromServer.out(),
this);
}
/**
* Returns the AltingConnectionServer that can
* be used by a single process at any instance.
*
* @return the AltingConnectionServer object.
*/
public AltingConnectionServer server()
{
return server;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/PoisonException.java 0000644 0000000 0000000 00000006014 11113671251 020053 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This exception is thrown when a process tries to use a channel that
* has been poisoned.
*
* @see org.jcsp.lang.Poisonable
*/
public class PoisonException extends ChannelDataRejectedException {
private int strength;
/**
* JCSP users should not have to construct these.
*
* @param strength the strength of this exception
* (which will normally be the strength of the poison in the channel).
*/
protected PoisonException (int strength) {
//super("PoisonException, strength: " + strength);
this.strength = strength;
}
/**
* Once this exception has been caught, the catching process should
* poison all its channels with the strength held by the exception
* (which will normally be the strength of the poison in the channel
* that caused the exception to be thrown).
* See the example handler at the end of
* this section
* of the documentation of {@link Alternative}.
*/
public int getStrength() {
return strength;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/RejectableChannelInput.java 0000644 0000000 0000000 00000005235 11105701167 021303 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* Defines an interface for an input channel end that gives the reader the ability to reject instead
* of accepting pending data.
*
* @author Quickstone Technologies Limited
*
* @deprecated This channel is superceded by the poison mechanisms, please see {@link PoisonException}. It remains only because it is used by some of the networking features.
*/
public interface RejectableChannelInput extends ChannelInput
{
/**
* Reject any data pending instead of reading it. The currently blocked writer will receive a
* ChannelDataRejectedException.
*/
public void reject();
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/ChannelInputWrapper.java 0000644 0000000 0000000 00000006716 11113671251 020667 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* Defines a wrapper to go around a channel input end. This wrapper allows a channel end to be given
* away without any risk of the user of that end casting it to a channel output because they cannot
* gain access to the actual channel end.
*
* @deprecated There is no longer any need to use this class, after the 1.1 class reorganisation.
*
* @author Quickstone Technologies Limited
*/
public class ChannelInputWrapper implements ChannelInput
{
/**
* The actual channel end.
*/
private ChannelInput in;
/**
* Constructs a new wrapper around the given channel end.
*
* @param in the existing channel end.
*/
public ChannelInputWrapper(ChannelInput in)
{
this.in = in;
}
/**
* Reads a value from the channel.
*
* @see org.jcsp.lang.ChannelInput
* @return the value read.
*/
public Object read()
{
return in.read();
}
/**
* Begins an extended rendezvous
*
* @see ChannelInput.startRead
* @return The object read from the channel
*/
public Object startRead()
{
return in.startRead();
}
/**
* Ends an extended rendezvous
*
* @see ChannelInput.endRead
*/
public void endRead()
{
in.endRead();
}
public void poison(int strength)
{
in.poison(strength);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/PoisonableBufferedOne2OneChannelInt.java 0000644 0000000 0000000 00000027115 11113671251 023622 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.ints.ChannelDataStoreInt;
class PoisonableBufferedOne2OneChannelInt implements One2OneChannelInt, ChannelInternalsInt {
/** The ChannelDataStore used to store the data for the channel */
private final ChannelDataStoreInt data;
private final Object rwMonitor = new Object();
private Alternative alt;
//Only passed to channel-ends, not used directly:
private int immunity;
private int poisonStrength = 0;
/**
* Constructs a new BufferedOne2OneChannel with the specified ChannelDataStore.
*
* @param data the ChannelDataStore used to store the data for the channel
*/
public PoisonableBufferedOne2OneChannelInt(ChannelDataStoreInt data, int _immunity)
{
if (data == null)
throw new IllegalArgumentException
("Null ChannelDataStore given to channel constructor ...\n");
this.data = (ChannelDataStoreInt) data.clone();
immunity = _immunity;
}
private boolean isPoisoned() {
return poisonStrength > 0;
}
/**
* Reads an Object from the channel.
*
* @return the object read from the channel.
*/
public int read () {
synchronized (rwMonitor) {
if (data.getState () == ChannelDataStoreInt.EMPTY) {
//Reader only sees poison if buffer is empty:
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
try {
rwMonitor.wait ();
while (data.getState () == ChannelDataStoreInt.EMPTY && !isPoisoned()) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.One2OneChannelXRead);
}
rwMonitor.wait ();
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException (
"*** Thrown from One2OneChannel.read (int)\n" + e.toString ()
);
}
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
}
rwMonitor.notify ();
return data.get ();
}
}
public int startRead() {
synchronized (rwMonitor) {
if (data.getState () == ChannelDataStoreInt.EMPTY) {
// Reader only sees poison if buffer is empty:
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
try {
rwMonitor.wait ();
while (data.getState () == ChannelDataStoreInt.EMPTY && !isPoisoned()) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.One2OneChannelXRead);
}
rwMonitor.wait ();
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException (
"*** Thrown from One2OneChannel.read (int)\n" + e.toString ()
);
}
// Reader only sees poison if buffer is empty:
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
}
return data.startGet();
}
}
public void endRead() {
synchronized(rwMonitor) {
data.endGet();
rwMonitor.notify ();
}
}
/**
* Writes an Object to the channel.
*
* @param value the object to write to the channel.
*/
public void write (int value) {
synchronized (rwMonitor) {
//Writer always sees poison:
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
data.put (value);
if (alt != null) {
alt.schedule ();
} else {
rwMonitor.notify ();
}
if (data.getState () == ChannelDataStoreInt.FULL) {
try {
rwMonitor.wait ();
while (data.getState () == ChannelDataStoreInt.FULL && !isPoisoned()) {
if (Spurious.logging) {
SpuriousLog.record (SpuriousLog.One2OneChannelXWrite);
}
rwMonitor.wait ();
}
}
catch (InterruptedException e) {
throw new ProcessInterruptedException (
"*** Thrown from One2OneChannel.write (Object)\n" + e.toString ()
);
}
if (isPoisoned()) {
throw new PoisonException(poisonStrength);
}
}
}
}
/**
* turns on Alternative selection for the channel. Returns true if the
* channel has data that can be read immediately.
*
* Note: this method should only be called by the Alternative class * * @param alt the Alternative class which will control the selection * @return true if the channel has data that can be read, else false */ public boolean readerEnable (Alternative alt) { synchronized (rwMonitor) { if (isPoisoned()) { //If it's poisoned, it will be ready whether because of the poison, or because //the buffer has data in it return true; } else if (data.getState () == ChannelDataStoreInt.EMPTY) { this.alt = alt; return false; } else { return true; } } } /** * turns off Alternative selection for the channel. Returns true if the * channel contained data that can be read. *
* Note: this method should only be called by the Alternative class * * @return true if the channel has data that can be read, else false */ public boolean readerDisable () { synchronized (rwMonitor) { alt = null; return data.getState () != ChannelDataStoreInt.EMPTY || isPoisoned(); } } /** * Returns whether there is data pending on this channel. *
* Note: if there is, it won't go away until you read it. But if there * isn't, there may be some by the time you check the result of this method. *
* This method is provided for convenience. Its functionality can be provided * by Pri Alting the channel against a SKIP guard, although * at greater run-time and syntactic cost. For example, the following code * fragment: *
* if (c.pending ()) {
* Object x = c.read ();
* ... do something with x
* } else (
* ... do something else
* }
*
* is equivalent to:
*
* if (c_pending.priSelect () == 0) {
* Object x = c.read ();
* ... do something with x
* } else (
* ... do something else
* }
*
* where earlier would have had to have been declared:
*
* final Alternative c_pending =
* new Alternative (new Guard[] {c, new Skip ()});
*
*
* @return state of the channel.
*/
public boolean readerPending () {
synchronized (rwMonitor) {
return (data.getState () != ChannelDataStoreInt.EMPTY) || isPoisoned();
}
}
/**
* Returns the AltingChannelInput to use for this channel.
* As BufferedOne2OneChannel implements
* AltingChannelInput itself, this method simply returns
* a reference to the object that it is called on.
*
* @return the AltingChannelInput object to use for this
* channel.
*/
public AltingChannelInputInt in()
{
return new AltingChannelInputIntImpl(this,immunity);
}
/**
* Returns the ChannelOutput object to use for this channel.
* As BufferedOne2OneChannel implements
* ChannelOutput itself, this method simply returns
* a reference to the object that it is called on.
*
* @return the ChannelOutput object to use for this
* channel.
*/
public ChannelOutputInt out()
{
return new ChannelOutputIntImpl(this,immunity);
}
public void writerPoison(int strength) {
if (strength > 0) {
synchronized (rwMonitor) {
this.poisonStrength = strength;
//Poison by writer does *NOT* clear the buffer
rwMonitor.notifyAll();
if (null != alt) {
alt.schedule();
}
}
}
}
public void readerPoison(int strength) {
if (strength > 0) {
synchronized (rwMonitor) {
this.poisonStrength = strength;
//Poison by reader clears the buffer:
data.removeAll();
rwMonitor.notifyAll();
}
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/One2AnyConnectionImpl.java 0000644 0000000 0000000 00000010622 11105701167 021043 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.Buffer;
/**
* This class is an implementation of One2AnyConnection.
* Each end is safe to be used by one thread at a time.
*
* @author Quickstone Technologies Limited
*/
class One2AnyConnectionImpl implements One2AnyConnection
{
private AltingConnectionClient client;
private One2OneChannel chanToServer;
private One2OneChannel chanFromServer;
private Any2OneChannel chanSynch;
/**
* Initializes all the attributes to necessary values.
* Channels are created using the static factory in the
* ChannelServer interface.
*
* Constructor for One2OneConnectionImpl.
*/
public One2AnyConnectionImpl()
{
super();
chanToServer = ConnectionServer.FACTORY.createOne2One(new Buffer(1));
chanFromServer = ConnectionServer.FACTORY.createOne2One(new Buffer(1));
chanSynch = ConnectionServer.FACTORY.createAny2One(new Buffer(1));
//create the client and server objects
client = new AltingConnectionClientImpl(chanFromServer.in(),
chanToServer.out(),
chanToServer.out(),
chanFromServer.out());
}
/**
* Returns the AltingConnectionClient that can
* be used by a single process at any instance.
*
* Each call to this method will return the same object reference.
*
* @return the AltingConnectionClient object.
*/
public AltingConnectionClient client()
{
return client;
}
/**
* Returns a SharedConnectionServer object for this
* connection. This method can be called multiple times to return a new
* SharedConnectionServer object each time. Any object
* created can only be used by one process at a time but the set of
* objects constructed can be used concurrently.
*
* @return a new SharedConnectionServer object.
*/
public SharedConnectionServer server()
{
return new SharedConnectionServerImpl(chanToServer.in(),
chanToServer.in(), chanSynch.in(),
chanSynch.out(), this);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/BufferedOne2OneChannel.java 0000644 0000000 0000000 00000024271 11105701167 021134 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
import org.jcsp.util.*;
/**
* This implements a one-to-one object channel with user-definable buffering.
* Description
* BufferedOne2OneChannel implements a one-to-one object channel with * user-definable buffering. Multiple readers or multiple writers are * not allowed -- these are catered for by {@link BufferedAny2OneChannel}, * {@link BufferedOne2AnyChannel} or {@link BufferedAny2AnyChannel}. ** The reading process may {@link Alternative ALT} on this channel. * The writing process is committed (i.e. it may not back off). *
* The constructor requires the user to provide * the channel with a plug-in driver conforming to the * {@link org.jcsp.util.ChannelDataStore ChannelDataStore} * interface. This allows a variety of different channel semantics to be * introduced -- including buffered channels of user-defined capacity * (including infinite), overwriting channels (with various overwriting * policies) etc.. * Standard examples are given in the org.jcsp.util package, but * careful users may write their own. * * @see org.jcsp.lang.Alternative * @see org.jcsp.lang.BufferedAny2OneChannel * @see org.jcsp.lang.BufferedOne2AnyChannel * @see org.jcsp.lang.BufferedAny2AnyChannel * @see org.jcsp.util.ChannelDataStore * * @author P.D. Austin * @author P.H. Welch */ class BufferedOne2OneChannel implements One2OneChannel, ChannelInternals { /** The ChannelDataStore used to store the data for the channel */ private final ChannelDataStore data; private final Object rwMonitor = new Object(); private Alternative alt; /** * Constructs a new BufferedOne2OneChannel with the specified ChannelDataStore. * * @param data the ChannelDataStore used to store the data for the channel */ public BufferedOne2OneChannel(ChannelDataStore data) { if (data == null) throw new IllegalArgumentException ("Null ChannelDataStore given to channel constructor ...\n"); this.data = (ChannelDataStore) data.clone(); } /** * Reads an Object from the channel. * * @return the object read from the channel. */ public Object read () { synchronized (rwMonitor) { if (data.getState () == ChannelDataStore.EMPTY) { try { rwMonitor.wait (); while (data.getState () == ChannelDataStore.EMPTY) { if (Spurious.logging) { SpuriousLog.record (SpuriousLog.One2OneChannelXRead); } rwMonitor.wait (); } } catch (InterruptedException e) { throw new ProcessInterruptedException ( "*** Thrown from One2OneChannel.read (int)\n" + e.toString () ); } } rwMonitor.notify (); return data.get (); } } public Object startRead() { synchronized (rwMonitor) { if (data.getState () == ChannelDataStore.EMPTY) { try { rwMonitor.wait (); while (data.getState () == ChannelDataStore.EMPTY) { if (Spurious.logging) { SpuriousLog.record (SpuriousLog.One2OneChannelXRead); } rwMonitor.wait (); } } catch (InterruptedException e) { throw new ProcessInterruptedException ( "*** Thrown from One2OneChannel.read (int)\n" + e.toString () ); } } return data.startGet(); } } public void endRead() { synchronized(rwMonitor) { data.endGet(); rwMonitor.notify (); } } /** * Writes an Object to the channel. * * @param value the object to write to the channel. */ public void write (Object value) { synchronized (rwMonitor) { data.put (value); if (alt != null) { alt.schedule (); } else { rwMonitor.notify (); } if (data.getState () == ChannelDataStore.FULL) { try { rwMonitor.wait (); while (data.getState () == ChannelDataStore.FULL) { if (Spurious.logging) { SpuriousLog.record (SpuriousLog.One2OneChannelXWrite); } rwMonitor.wait (); } } catch (InterruptedException e) { throw new ProcessInterruptedException ( "*** Thrown from One2OneChannel.write (Object)\n" + e.toString () ); } } } } /** * turns on Alternative selection for the channel. Returns true if the * channel has data that can be read immediately. *
* Note: this method should only be called by the Alternative class * * @param alt the Alternative class which will control the selection * @return true if the channel has data that can be read, else false */ public boolean readerEnable (Alternative alt) { synchronized (rwMonitor) { if (data.getState () == ChannelDataStore.EMPTY) { this.alt = alt; return false; } else { return true; } } } /** * turns off Alternative selection for the channel. Returns true if the * channel contained data that can be read. *
* Note: this method should only be called by the Alternative class * * @return true if the channel has data that can be read, else false */ public boolean readerDisable () { synchronized (rwMonitor) { alt = null; return data.getState () != ChannelDataStore.EMPTY; } } /** * Returns whether there is data pending on this channel. *
* Note: if there is, it won't go away until you read it. But if there * isn't, there may be some by the time you check the result of this method. *
* This method is provided for convenience. Its functionality can be provided * by Pri Alting the channel against a SKIP guard, although * at greater run-time and syntactic cost. For example, the following code * fragment: *
* if (c.pending ()) {
* Object x = c.read ();
* ... do something with x
* } else (
* ... do something else
* }
*
* is equivalent to:
*
* if (c_pending.priSelect () == 0) {
* Object x = c.read ();
* ... do something with x
* } else (
* ... do something else
* }
*
* where earlier would have had to have been declared:
*
* final Alternative c_pending =
* new Alternative (new Guard[] {c, new Skip ()});
*
*
* @return state of the channel.
*/
public boolean readerPending () {
synchronized (rwMonitor) {
return (data.getState () != ChannelDataStore.EMPTY);
}
}
/**
* Returns the AltingChannelInput to use for this channel.
* As BufferedOne2OneChannel implements
* AltingChannelInput itself, this method simply returns
* a reference to the object that it is called on.
*
* @return the AltingChannelInput object to use for this
* channel.
*/
public AltingChannelInput in()
{
return new AltingChannelInputImpl(this,0);
}
/**
* Returns the ChannelOutput object to use for this channel.
* As BufferedOne2OneChannel implements
* ChannelOutput itself, this method simply returns
* a reference to the object that it is called on.
*
* @return the ChannelOutput object to use for this
* channel.
*/
public ChannelOutput out()
{
return new ChannelOutputImpl(this,0);
}
// No poison in these channels:
public void writerPoison(int strength) {
}
public void readerPoison(int strength) {
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/lang/CSProcess.java 0000644 0000000 0000000 00000036725 11105701167 016606 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.lang;
/**
* This is the JCSP interface for a process - an active component that encapsulates
* the data structures on which it operates.
* Description
* A CSP * process is a component that encapsulates data structures * and algorithms for manipulating that data. Both its data and algorithms * are private. The outside world can neither see that data nor execute those * algorithms. Each process is alive, executing its own algorithms on its own * data. Processes interact solely via CSP synchronising primitives, such as * channels, events or other well-defined modes of access * to shared passive objects. ** In this JCSP * binding of the CSP model into Java, a process is an instance * of a class implementing this CSProcess interface. * Its actions are defined by the run method. *
* Running processes interact solely via CSP channels, events * or carefully synchronised access to shared objects -- not by calling each * other's methods. These passive objects form the CSP interface to a process. * They are not present in the Java interface and must be configured into * each process via public constructors and/or mutators when it is not running * (i.e. before and in between runs). It is safe to extract information from * the process via accessor methods, but only after (or in between) runs. *
* For other general information, see the JCSP * overview. *
Process Oriented Design
* A process-oriented design consists of layered networks of processes. * A network is simply a parallel composition of processes connected * through a set of passive synchronisation objects (wires) and is * itself a process. Each process fulfills a contract with its environment * that specifies not only what functions it performs, but how it is prepared * to synchronise with that environment to obtain information and deliver results. * Note that a process does not interact directly with other processes, only * with the wires to which it is connected. This is a very familiar form of * component interface -- certainly to hardware engineers -- and is one that * allows considerable flexibility and reuse. *Implementation Pattern
* The structure of a JCSP process should follow the outline: *
* import org.jcsp.lang.*;
* ... other imports
*
* class ProcessExample implements CSProcess {
*
* ... private/protected shared synchronisation objects (channels etc.)
* ... private/protected state information
*
* ... public constructors
* ... public configuration/inspection methods (when not running)
*
* ... private/protected support methods (part of a run)
* ... public run method (the process starts here)
*
* }
*
* The pattern of use for these methods is simple and well-disciplined.
* The public constructors and configuration methods must install the shared
* synchronisation objects into their private/protected fields.
* They may also initialise other private/protected state information.
* The public configuration/inspection methods (simple sets and
* gets) may be invoked only when this process is not running
* and are the responsibility of a single process only -- usually
* the process that constructed it. That process is also responsible for
* invoking the public run method that kicks this one into life
* (usually, via a {@link Parallel} or {@link ProcessManager} intermediary).
* The private support methods are triggered only by the run
* method and express the live behaviour of this process.
* * A process instance may have several lives but these must, of course, * be consecutive. Different instances of the same process class may, * also of course, be alive concurrently. Reconfiguration of a process * via its configuration/inspection methods may only take place between * lives. Dynamic reconfiguration of a live process may take place -- * but only with the active cooperation of the process (for example, * through channel communication). *
Motivation
* Like any object, a process should encapsulate a coherent set of data and * algorithms for managing that data. The discipline outlined in the above * implementation pattern has the following broad aims: *-
*
- * maintain the encapsulation of information (which is something that * is easilly lost in free-wheeling OO-design as object references are * passed around); *
- * enable a precise (CSP) specification of the way a process interacts * with its environment (represented in the above pattern by the shared * synchronisation objects); *
- * express the behaviour of the process from its own point of view * (which is something not available to general OO-design whenever * a method of one object is invoked from the method of another); *
- * eliminate the occurrence of race hazards upon the parallel composition * of processes; *
- * enable formal certification of the absence of deadlock, livelock and * process starvation in a parallel system (through design-time analysis * or the checked adherence to higher-level CSP design rules for which * proven safety guarantees are known). *
* This is not to say that the semantics of processes connected in parallel are * simply the sum of the semantics of each individual process -- just that * those semantics should contain no surprises. * Value can added just through the nature of the parallel composition * itself. For example, connect simple stateless processes into a channel * feedback-loop, give them some external wires and we get a component * that contains state. *
Discussion
* The public methods of an arbitrary object are at the mercy of any * other object that has a reference to it. Further, invocations of those * methods may be part of any thread of control. Object designers, * implementors and users need to have this under well-documented control. * This control is not easy to achieve without any rules. ** The process design pattern defines some powerful simplifications that bring * us that control. Backed up with the theory of CSP, it also addresses and * offers solutions to some fundamental issues in concurrency and multi-threading. *
* In unconstrained OO, threads and objects are orthogonal notions -- * sometimes dangerously competitive. Threads have no internal structure and can * cross object boundaries in spaghetti-like trails that relate objects together in * a way that has little correspondence to the original OO design. * A process combines these ideas into a single concept, gives it structure * and maintains strong encapsulation by guarding the distribution and use * of references with some strict (and checkable) design rules. * A process may be wired up in parallel with other processes to form a network -- * which is itself a process. So, a process may have sub-processes that have * sub-sub-processes ad infinitum. This is the way the world works ... *
* The simplicity of the process design pattern is that each process can be * considered individually as an independant serial program, interacting * with external I/O devices (the synchronisation objects -- channels etc.). * At the other end of those devices may lie other processes, but that is of * no concern to the consideration of this process. All our past skills and * intuition about serial programming can safely be applied. The new skills * needed to design and use parallel process networks sit alongside those * earlier skills and no cross-interference takes place. *
Examples
* Numerous examples are scattered throughout the documentation of this library. * Good starting ponts are in the {@link Parallel} and {@link Alternative} classes. * Here is another very simple one: *
* import org.jcsp.lang.*;
*
* // LaunchControl is a process to control the launch of a space rocket.
*
* // It is configured with a countdown time in seconds -- this must be above
* // a minimum threshold, MIN_COUNTDOWN, else the launch is immediately aborted.
*
* // There are two control lines, abort and hold, that respectively abort
* // or hold the launch if signalled. The hold is released by a second
* // signal on the same line.
*
* // During countdown, the count is reported by outputting on the countdown
* // channel.
*
* // If not aborted, LaunchControl fires the rocket (by outputting on its fire
* // channel) when the countdown reaches zero. An ABORTED launch is also
* // reported on this fire channel.
*
* // After a successful or aborted launch, LaunchControl terminates.
* // The status attribute records whether the launch was FIRED or ABORTED
* // and may then be inspected.
*
* public class LaunchControl implements CSProcess {
*
* public static final int MIN_COUNTDOWN = 10;
*
* public static final int FIRED = 0;
* public static final int HOLDING = 1;
* public static final int COUNTING = 2;
* public static final int ABORTED = 3;
* public static final int UNDEDFINED = 4;
*
* private final int start;
* private final AltingChannelInputInt abort;
* private final AltingChannelInputInt hold;
* private final ChannelOutputInt countdown;
* private final ChannelOutputInt fire;
*
* private int status = UNDEDFINED;
*
* public LaunchControl (final int start,
* final AltingChannelInputInt abort,
* final AltingChannelInputInt hold,
* final ChannelOutputInt countdown,
* final ChannelOutputInt fire) {
* this.start = start;
* this.abort = abort;
* this.hold = hold;
* this.countdown = countdown;
* this.fire = fire;
* }
*
* public int getStatus () { // inspection method
* return status; // (can only be used in between runs)
* }
*
* public void run () {
*
* final CSTimer tim = new CSTimer (); // JCSP timers have
* final long oneSecond = 1000; // millisecond granularity
*
* long timeout = tim.read () + oneSecond; // compute first timeout
*
* final Alternative alt =
* new Alternative (new Guard[] {abort, hold, tim});
* final int ABORT = 0;
* final int HOLD = 1;
* final int TICK = 2;
*
* int count = start;
* boolean counting = (start >= MIN_COUNTDOWN); // abort if bad start
*
* while ((count > 0) && counting) {
* countdown.write (count); // public address system
* tim.setAlarm (timeout); // set next timeout
* switch (alt.priSelect ()) {
* case ABORT: // abort signalled
* abort.read (); // clear the signal
* counting = false;
* break;
* case HOLD: // hold signalled
* long timeLeft = timeout - tim.read (); // time till next tick
* hold.read (); // clear the signal
* fire.write (HOLDING); // signal rocket
* hold.read (); // wait for the release
* timeout = tim.read () + timeLeft; // recompute next timeout
* fire.write (COUNTING); // signal rocket
* break;
* case TICK: // timeout expired
* count--;
* timeout += oneSecond; // compute next timeout
* break;
* }
* }
*
* status = (counting) ? FIRED : ABORTED; // set status attribute
* fire.write (status); // signal rocket (go/nogo)
* if (counting) countdown.write (0); // complete countdown
* }
* }
*
*
* @see org.jcsp.lang.Parallel
* @see org.jcsp.lang.PriParallel
* @see org.jcsp.lang.Alternative
* @see org.jcsp.lang.ChannelInput
* @see org.jcsp.lang.ChannelOutput
* @see org.jcsp.lang.One2OneChannel
* @see org.jcsp.lang.Any2OneChannel
* @see org.jcsp.lang.One2AnyChannel
* @see org.jcsp.lang.Any2AnyChannel
* @see org.jcsp.lang.ChannelInputInt
* @see org.jcsp.lang.ChannelOutputInt
* @see org.jcsp.lang.One2OneChannelInt
* @see org.jcsp.lang.Any2OneChannelInt
* @see org.jcsp.lang.One2AnyChannelInt
* @see org.jcsp.lang.Any2AnyChannelInt
* @see org.jcsp.lang.ProcessManager
* @author P.D. Austin
* @author P.H. Welch
*/
public interface CSProcess
{
/**
* This defines the actions of the process.
*/
public void run();
}
jcsp-1.1-rc4.orig/src/org/jcsp/win32/ 0000755 0000000 0000000 00000000000 11410045045 014076 5 ustar jcsp-1.1-rc4.orig/src/org/jcsp/win32/svcclasses.cpp 0000644 0000000 0000000 00000012671 10522104430 016757 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2006 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@ukc.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
#include "svcclasses.h"
#include LoadDLL.go () from their static initializers.
*
* @author Quickstone Technologies Limited
*/
class LoadDLL
{
/**
* Indicates whether the library has already been loaded.
*/
private static boolean loaded = false;
/**
* Loads the library if it hasn't already been loaded.
*/
static synchronized void go()
{
if (loaded)return;
File f = new File("./org.win32.dll");
System.load(f.getAbsolutePath());
loaded = true;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/win32/NTService.c 0000644 0000000 0000000 00000012276 10522104430 016111 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2006 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@ukc.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
#include Abstract class for declaring an NT service. A Java implementation of a service must declare the
* startService and stopService methods. startService must run the
* actual service and must block until the service is ready to terminate. For example it may sit in a loop
* servicing requests. stopService will be called when startService is expected
* to stop blocking and return. The stopService method should return promptly. Any time
* consuming shutdown code should be done asynchronously (for example in the startService
* thread) before startService returns.
For example:
* *
* public class MyService extends NTService {
* boolean running = true;
* protected void startService () {
* while (running) {
* System.beep ();
* Thread.sleep (1000);
* }
* }
* protected void stopService () {
* running = false;
* }
* private MyService () {
* super ("MyService");
* }
* public static void main (String[] args) {
* new MyService ().run ();
* }
* }
*
*
* @author Quickstone Technologies Limited
*/
public abstract class NTService
{
/**
* The name of the service as registered with the NT dispatcher. This really ought to be unique.
*/
private final String serviceName;
/**
* Registers a callback function from the DLL with the NT dispatcher and starts the service.
*/
private native int startDispatcher();
/**
* Blocks inside the DLL until the NT service dispatcher is ready to start the service. This is because
* the threads allocated by the NT service dispatcher cannot directly call a Java method because there
* is no valid JNI environment for them.
*/
private native void waitForStart();
/**
* Blocks inside the DLL until the NT service dispatcher is ready to stop the service. This is because
* the threads allocated by the NT service dispatcher cannot directly call a Java method because there
* is no valid JNI environment for them.
*/
private native void waitForStop();
/**
* Notifies the NT service dispatcher that the stop has completed and the service has terminated. It is
* quite possible that the JVM could terminate abruptly (ie do an equivilant of a System.exit)
* once this method has been called.
*/
private native void acknowledgeStop();
/**
* This must be called prior to any of the other methods to initialize the semaphores maintained internally
* by the DLL.
*/
private native void prepareSemaphores();
/**
* This will be called when the service is started and must block until the service
* completes.
*/
protected abstract void startService();
/**
* This will be called when the service is stopped and the startService method must
* terminate.
*/
protected abstract void stopService();
/**
* Will call the user's startService method when the dispatcher requires it.
*/
private class StarterThread extends Thread
{
public StarterThread()
{
setDaemon(true);
start();
}
public void run()
{
waitForStart();
startService();
}
}
/**
* Will call the user's stopService method when the dispatcher requires it.
*/
private class StopperThread extends Thread
{
public StopperThread()
{
setDaemon(true);
start();
}
public void run()
{
waitForStop();
stopService();
acknowledgeStop();
}
}
/**
* Ensures that the DLL is loaded.
*/
static
{
LoadDLL.go();
}
/**
* Creates a new NT service wrapper with the given name. This name ought to match the name that is
* registered with the NT service manager but probably will work if it doesn't. What is more important
* is that the name is system unique.
*/
protected NTService(String serviceName)
{
this.serviceName = serviceName;
}
/**
* Runs the service, registering it with the NT service dispatcher. If there is a problem this will
* terminate the JVM with the Windows error code. If all is okay, this will never return. All subsequent
* processing is done by the allocated StarterThread and StopperThread objects
* and threads internal to the DLL.
*/
protected final void run()
{
prepareSemaphores();
new StarterThread();
new StopperThread();
int ec = startDispatcher();
if (ec != 0)
System.exit(ec);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/awt/ 0000755 0000000 0000000 00000000000 11410045053 013726 5 ustar jcsp-1.1-rc4.orig/src/org/jcsp/awt/WindowEventHandler.java 0000644 0000000 0000000 00000013442 11105701167 020352 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.awt;
import org.jcsp.lang.*;
import java.awt.event.*;
/**
* @author P.D. Austin and P.H. Welch
*/
class WindowEventHandler implements WindowListener
{
/**
* The Channel action event notifications are sent down.
*/
protected ChannelOutput event;
/**
* constructs a new WindowEventHandler with the specified output Channel.
*
* @param event The Channel to send the event notification down
*/
public WindowEventHandler(ChannelOutput event)
{
this.event = event;
}
/**
* Invoked when the Component the event handler is listening to has the window
* opened. Notifies the event process that a WindowEvent has
* occurred by sending the WindowEvent Object. Some notifications will be
* lost so there are no guarantees that all events generated will be
* processed.
*
* @param e The parameters associated with this event
*/
public void windowOpened(WindowEvent e)
{
event.write(e);
}
/**
* Invoked when the Component the event handler is listening to has the window
* start to close. Notifies the event process that a WindowEvent has
* occurred by sending the WindowEvent Object. Some notifications will be
* lost so there are no guarantees that all events generated will be
* processed.
*
* @param e The parameters associated with this event
*/
public void windowClosing(WindowEvent e)
{
event.write(e);
}
/**
* Invoked when the Component the event handler is listening to has the window
* closed. Notifies the event process that a WindowEvent has
* occurred by sending the WindowEvent Object. Some notifications will be
* lost so there are no guarantees that all events generated will be
* processed.
*
* @param e The parameters associated with this event
*/
public void windowClosed(WindowEvent e)
{
event.write(e);
}
/**
* Invoked when the Component the event handler is listening to has the window
* iconified. Notifies the event process that a WindowEvent has
* occurred by sending the WindowEvent Object. Some notifications will be
* lost so there are no guarantees that all events generated will be
* processed.
*
* @param e The parameters associated with this event
*/
public void windowIconified(WindowEvent e)
{
event.write(e);
}
/**
* Invoked when the Component the event handler is listening to has the window
* deiconified. Notifies the event process that a WindowEvent has
* occurred by sending the WindowEvent Object. Some notifications will be
* lost so there are no guarantees that all events generated will be
* processed.
*
* @param e The parameters associated with this event
*/
public void windowDeiconified(WindowEvent e)
{
event.write(e);
}
/**
* Invoked when the Component the event handler is listening to has the window
* activated. Notifies the event process that a WindowEvent has
* occurred by sending the WindowEvent Object. Some notifications will be
* lost so there are no guarantees that all events generated will be
* processed.
*
* @param e The parameters associated with this event
*/
public void windowActivated(WindowEvent e)
{
event.write(e);
}
/**
* Invoked when the Component the event handler is listening to has the window
* deactivated. Notifies the event process that a WindowEvent has
* occurred by sending the WindowEvent Object. Some notifications will be
* lost so there are no guarantees that all events generated will be
* processed.
*
* @param e The parameters associated with this event
*/
public void windowDeactivated(WindowEvent e)
{
event.write(e);
}
} jcsp-1.1-rc4.orig/src/org/jcsp/awt/MouseEventHandler.java 0000644 0000000 0000000 00000007241 11105701167 020173 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.awt;
import org.jcsp.lang.*;
import java.awt.event.*;
/**
* @author P.D. Austin and P.H. Welch
*/
class MouseEventHandler implements MouseListener
{
/**
* The channel down which action event notifications are sent.
*/
private ChannelOutput event;
/**
* constructs a new MouseEventHandler with the specified output channel
*
* @param event the Channel to which to send the event notification
*/
public MouseEventHandler(ChannelOutput event)
{
this.event = event;
}
/**
* Assumes the event channel is being serviced (eg by an overwriting channel).
*
* @param e The parameters associated with this event
*/
public void mouseClicked(MouseEvent e)
{
event.write(e);
}
/**
* Assumes the event channel is being serviced (eg by an overwriting channel).
*
* @param e The parameters associated with this event
*/
public void mousePressed(MouseEvent e)
{
event.write(e);
}
/**
* Assumes the event channel is being serviced (eg by an overwriting channel).
*
* @param e The parameters associated with this event
*/
public void mouseReleased(MouseEvent e)
{
event.write(e);
}
/**
* Assumes the event channel is being serviced (eg by an overwriting channel).
*
* @param e The parameters associated with this event
*/
public void mouseEntered(MouseEvent e)
{
event.write(e);
}
/**
* Assumes the event channel is being serviced (eg by an overwriting channel).
*
* @param e The parameters associated with this event
*/
public void mouseExited(MouseEvent e)
{
event.write(e);
}
} jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveLabel.java 0000644 0000000 0000000 00000037654 11105701167 016771 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.awt;
import java.awt.*;
import java.util.Vector;
import org.jcsp.lang.*;
/**
* {@link java.awt.Label java.awt.Label}
* with a channel interface.
* Process Diagram
*
Description
* ActiveLabel is a process extension of java.awt.Label * with channels for run-time configuration and event notification. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure channel is settable from a constructor. * Event channels can be added to notify the occurrence of any type of Event * the component generates (by calling the appropriate * addXXXEventChannel method before the process is run). * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myMouseEvent = Channel.one2one (new OverWriteOldestBuffer (n));
*
* final ActiveLabel myLabel = new ActiveLabel ("Look at Me");
* myContainer.addMouseEventChannel (myMouseEvent.out ());
*
* This will ensure that the Java Event Thread will never be blocked.
* Slow or inattentive readers may miss rapidly generated events, but
* the n most recent events will always be available.
*
* Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *String | *Change the label on the ActiveLabel to the value of the String | *
| Boolean | *
*
|
* |
| ActiveLabel.Configure | *Invoke the user-defined Configure.configure method on the label. | *|
| Output Channels | *||
| componentEvent | *ComponentEvent | *See the {@link #addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the {@link #addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the {@link #addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the {@link #addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the {@link #addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import java.awt.*;
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
*
* public class ActiveLabelExample {
*
* public static void main (String argv[]) {
*
* final Frame root = new Frame ("ActiveLabel Example");
*
* final int nLabels = 8;
* final int countdown = 10;
*
* final One2OneChannel[] configureLabel = Channel.one2oneArray (nLabels);
*
* final ActiveLabel[] label = new ActiveLabel[nLabels];
* for (int i = 0; i < label.length; i++) {
* label[i] = new ActiveLabel (configureLabel[i].in (), "==> " + countdown + " <==");
* label[i].setAlignment (Label.CENTER);
* }
*
* final One2OneChannel configureButton = Channel.one2one ();
* final One2OneChannel event = Channel.one2one (new OverWriteOldestBuffer (10));
*
* final ActiveButton button = new ActiveButton (configureButton.in (), event.out (), "Start");
*
* root.setSize (300, 200);
* root.setLayout (new GridLayout (3, 3));
* for (int i = 0; i < nLabels + 1; i++) {
* if (i < 4) {
* root.add (label[i]);
* } else if (i == 4) {
* root.add (button);
* } else if (i > 4) {
* root.add (label[i - 1]);
* }
* }
* root.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* new Parallel (label),
* button,
* new CSProcess () {
* public void run () {
* final long second = 1000;
* CSTimer tim = new CSTimer ();
* Alternative alt = new Alternative (new Guard[] {event.in (), tim});
* event.in ().read (); // wait for the start signal
* configureButton.out ().write ("Restart");
* int count = countdown;
* long timeout = tim.read () + second;
* while (count > 0) {
* tim.setAlarm (timeout);
* switch (alt.priSelect ()) {
* case 0: // reset signal
* event.in ().read (); // clear the reset
* timeout = tim.read () + second;
* count = countdown;
* break;
* case 1: // timeout signal
* timeout += second;
* count--;
* break;
* }
* final String newLabel = "==> " + count + " <==";
* for (int i = 0; i < nLabels; i++) {
* configureLabel[i].out ().write (newLabel);
* }
* }
* root.setVisible (false);
* System.exit (0);
* }
* }
* }
* ).run ();
*
* }
*
* }
*
*
* @see java.awt.Label
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveLabel extends Label implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* Constructs a new ActiveLabel with no label or configuration channel.
*/
public ActiveLabel()
{
this("");
}
/**
* Constructs a new ActiveLabel with no configuration channel.
*
* @param s the initial string displayed on the label.
*/
public ActiveLabel(String s)
{
this(null, s);
}
/**
* Constructs a new ActiveLabel with no initial label.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public ActiveLabel(ChannelInput configure)
{
this(configure, "");
}
/**
* Constructs a new ActiveLabel.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param s the initial string displayed on the label.
*/
public ActiveLabel(ChannelInput configure, String s)
{
super(s);
this.configure = configure;
}
/**
* Sets the configuration channel for this ActiveLabel.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* Add a new channel to this component that will be used to notify that
* a ComponentEvent has occurred. This should be used
* instead of registering a ComponentListener with the component. It is
* possible to add more than one channel by calling this method multiple times
* If the channel passed is null, no action will be taken.
* * NOTE: This method must be called before this process is run. * * @param componentEvent the channel down which to send ComponentEvents. */ public void addComponentEventChannel(ChannelOutput componentEvent) { if (componentEvent != null) { ComponentEventHandler handler = new ComponentEventHandler(componentEvent); addComponentListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a FocusEvent has occurred. This should be used * instead of registering a FocusListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param focusEvent the channel down which to send FocusEvents. */ public void addFocusEventChannel(ChannelOutput focusEvent) { if (focusEvent != null) { FocusEventHandler handler = new FocusEventHandler(focusEvent); addFocusListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a KeyEvent has occurred. This should be used * instead of registering a KeyListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param keyEvent the channel down which to send KeyEvents. */ public void addKeyEventChannel(ChannelOutput keyEvent) { if (keyEvent != null) { KeyEventHandler handler = new KeyEventHandler(keyEvent); addKeyListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseEvent has occurred. This should be used * instead of registering a MouseListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseEvent the channel down which to send MouseEvents. */ public void addMouseEventChannel(ChannelOutput mouseEvent) { if (mouseEvent != null) { MouseEventHandler handler = new MouseEventHandler(mouseEvent); addMouseListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseMotionEvent has occurred. This should be used * instead of registering a MouseMotionListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseMotionEvent the channel down which to send MouseMotionEvents. */ public void addMouseMotionEventChannel(ChannelOutput mouseMotionEvent) { if (mouseMotionEvent != null) { MouseMotionEventHandler handler = new MouseMotionEventHandler(mouseMotionEvent); addMouseMotionListener(handler); vec.addElement(handler); } } /** * This enables general configuration of this component. Any object implementing * this interface and sent down the configure channel to this component will have its * configure method invoked on this component. *
* For an example, see {@link ActiveApplet.Configure}. */ static public interface Configure { /** * @param label the Label being configured. */ public void configure(final Label label); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message instanceof String) setText((String) message); else if (message instanceof Boolean) { if (message == Boolean.TRUE) setEnabled(true); else if (message == Boolean.FALSE) setEnabled(false); } else if (message instanceof Configure) ((Configure) message).configure(this); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveList.java 0000644 0000000 0000000 00000050626 11105701167 016657 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.List java.awt.List} * with a channel interface. *
Process Diagram
*
Description
* ActiveList is a process extension of java.awt.List * with channels for run-time configuration and event notification. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure and event channels are * settable from a constructor. * When an item in the ActiveList is * double-clicked, its label is written down the event channel. * Other event channels can be added to notify the occurrence of any other events * the component generates (by calling the appropriate * addXXXEventChannel method before the process is run). * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myListEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * final One2OneChannel myListItemEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveList myList = new ActiveList (null, myListEvent.out ()); * myList.addItemEventChannel (myListItemEvent.out ()); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *String | ** Empty strings are ignored. If the string is "-*", all items in * the list are removed. Otherwise, if the first character is '-', * the item corresponding to the tail of the string is removed from the list. * Otherwise, the string is added to the end of the list. * | *
| Integer | ** Sets the selected item in this ActiveList list to be the item * at the specified position. * | *|
| Boolean | *
*
|
* |
| ActiveList.Configure | *Invoke the user-defined Configure.configure method on the list. | *|
| Output Channels | *||
| event | *String | ** When an item in the ActiveList is double-clicked, * its label is written down this channel. * | *
| itemEvent | *ItemEvent | *See the {@link #addItemEventChannel * addItemEventChannel} method. | *
| componentEvent | *ComponentEvent | *See the {@link #addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the {@link #addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the {@link #addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the {@link #addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the {@link #addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import java.awt.*;
* import java.awt.event.*;
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
*
* public class ActiveListExample {
*
* public static void main (String argv[]) {
*
* final Frame root = new Frame ("ActiveList Example");
*
* final One2OneChannel configure = Channel.one2one ();
*
* final One2OneChannel event = Channel.one2one (new OverWriteOldestBuffer (10));
* final One2OneChannel itemEvent = Channel.one2one (new OverWriteOldestBuffer (10));
*
* final ActiveList list = new ActiveList (configure.in (), event.out (), 0, true);
* list.addItemEventChannel (itemEvent.out ());
*
* final String[] menu = {"Hello World", "Rocket Science", "CSP",
* "Monitors", "Ignore Me", "Goodbye World"};
*
* for (int i = 0; i < menu.length; i++) {
* list.add (menu[i]);
* }
*
* root.setSize (300, 105);
* root.add (list);
* root.setVisible (true);
*
* new Parallel (
* new CSProcess[] { // respond to the event channel
* list,
* new CSProcess () {
* public void run () {
* boolean running = true;
* while (running) {
* final String s = (String) event.in ().read ();
* System.out.println (" Action ==> `" + s + "'");
* running = (s != menu[menu.length - 1]);
* }
* root.setVisible (false);
* System.exit (0);
* }
* },
* new CSProcess () { // respond to the itemEvent channel
* public void run () {
* while (true) {
* final ItemEvent e = (ItemEvent) itemEvent.in ().read ();
* final Integer item = (Integer) e.getItem ();
* if (e.getStateChange () == ItemEvent.SELECTED) {
* System.out.println ("Selected item " + item);
* } else {
* System.out.println ("Unselected item " + item);
* }
* }
* }
* },
* new CSProcess () { // dynamically reconfigure the list
* public void run () {
* CSTimer tim = new CSTimer ();
* long timeout = tim.read ();
* while (true) {
* timeout += 10000;
* tim.after (timeout);
* System.out.println ("*** Removing last three items ...");
* for (int i = 3; i < menu.length; i++) {
* configure.out ().write ("-" + menu[i]);
* }
* timeout += 10000;
* tim.after (timeout);
* System.out.println ("*** Restoring last three items ...");
* for (int i = 3; i < menu.length; i++) {
* configure.out ().write (menu[i]);
* }
* }
* }
* }
* }
* ).run ();
*
* }
*
* }
*
*
* @see java.awt.List
* @see java.awt.event.ItemEvent
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveList extends List implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* Constructs an ActiveList with no visible lines, no configuration
* or event channels and only one item selectable.
*/
public ActiveList()
{
this(null, null, 0, false);
}
/**
* Constructs an ActiveList with the specified number of visible
* lines, but with no configuration or event channels
* and only one item selectable.
*
* @param rows the number of visible lines.
*/
public ActiveList(int rows)
{
this(null, null, rows, false);
}
/**
* Constructs an ActiveList with the specified number of visible
* lines and a multiple selection option, but with no configuration
* or event channels.
*
* @param rows the number of visible lines.
* @param multipleMode the multiple selection option.
*/
public ActiveList(int rows, boolean multipleMode)
{
this(null, null, rows, multipleMode);
}
/**
* Constructs an ActiveList with configuration and event channels,
* but no visible items and only one item selectable.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the String label from a list item will be output when
* it is double-clicked -- can be null if no notification is required.
*/
public ActiveList(ChannelInput configure, ChannelOutput event)
{
this(configure, event, 0, false);
}
/**
* Constructs an ActiveList with configuration and event channels,
* the specified number of visible lines and only one item selectable.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the String label from a list item will be output when
* it is double-clicked -- can be null if no notification is required.
* @param rows the number of visible lines.
*/
public ActiveList(ChannelInput configure, ChannelOutput event, int rows)
{
this(configure, event, rows, false);
}
/**
* Constructs an ActiveList with configuration and event channels,
* the specified number of visible lines and a multiple selection option.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the String label from a list item will be output when
* it is double-clicked -- can be null if no notification is required.
* @param rows the number of visible lines.
* @param multipleMode the multiple selection option.
*/
public ActiveList(ChannelInput configure, ChannelOutput event, int rows, boolean multipleMode)
{
super(rows, multipleMode);
if (event != null)
{
ActionEventHandler handler = new ActionEventHandler(event);
addActionListener(handler);
vec.addElement(handler);
}
this.configure = configure;
}
/**
* Sets the configuration channel for this ActiveList.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* Add a new channel to this component that will be used to notify that
* an ItemEvent has occurred. This should be used
* instead of registering a ItemListener with the component. It is
* possible to add more than one channel by calling this method multiple times
* If the channel passed is null, no action will be taken.
* * NOTE: This method must be called before this process is run. * * @param itemEvent the channel down which to send ItemEvents. */ public void addItemEventChannel(ChannelOutput itemEvent) { if (itemEvent != null) { ItemEventHandler handler = new ItemEventHandler(itemEvent); addItemListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a ComponentEvent has occurred. This should be used * instead of registering a ComponentListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param componentEvent the channel down which to send ComponentEvents. */ public void addComponentEventChannel(ChannelOutput componentEvent) { if (componentEvent != null) { ComponentEventHandler handler = new ComponentEventHandler(componentEvent); addComponentListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a FocusEvent has occurred. This should be used * instead of registering a FocusListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param focusEvent the channel down which to send FocusEvents. */ public void addFocusEventChannel(ChannelOutput focusEvent) { if (focusEvent != null) { FocusEventHandler handler = new FocusEventHandler(focusEvent); addFocusListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a KeyEvent has occurred. This should be used * instead of registering a KeyListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param keyEvent the channel down which to send KeyEvents. */ public void addKeyEventChannel(ChannelOutput keyEvent) { if (keyEvent != null) { KeyEventHandler handler = new KeyEventHandler(keyEvent); addKeyListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseEvent has occurred. This should be used * instead of registering a MouseListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseEvent the channel down which to send MouseEvents. */ public void addMouseEventChannel(ChannelOutput mouseEvent) { if (mouseEvent != null) { MouseEventHandler handler = new MouseEventHandler(mouseEvent); addMouseListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseMotionEvent has occurred. This should be used * instead of registering a MouseMotionListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseMotionEvent the channel down which to send MouseMotionEvents. */ public void addMouseMotionEventChannel(ChannelOutput mouseMotionEvent) { if (mouseMotionEvent != null) { MouseMotionEventHandler handler = new MouseMotionEventHandler(mouseMotionEvent); addMouseMotionListener(handler); vec.addElement(handler); } } /** * This enables general configuration of this component. Any object implementing * this interface and sent down the configure channel to this component will have its * configure method invoked on this component. *
* For an example, see {@link ActiveApplet.Configure}. */ static public interface Configure { /** * @param list the List being configured. */ public void configure(final List list); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message instanceof String) { String s = (String) message; if (s.length() > 0) { if (s.equals("-*")) removeAll(); else if (s.charAt(0) == '-') remove(s.substring(1)); else add(s); } } else if (message instanceof Integer) select(((Integer) message).intValue()); else if (message instanceof Boolean) { if (message == Boolean.TRUE) setEnabled(true); else if (message == Boolean.FALSE) setEnabled(false); } else if (message instanceof Configure) ((Configure) message).configure(this); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ComponentEventHandler.java 0000644 0000000 0000000 00000010520 11105701167 021037 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.event.*; import org.jcsp.lang.*; /** * @author P.D. Austin and P.H. Welch */ class ComponentEventHandler implements ComponentListener { /** * The Channel action event notifications are sent down. */ private ChannelOutput event; /** * constructs a new ComponentEventHandler with the specified event output * Channel. * * @param event The Channel to send the event notification down */ public ComponentEventHandler(ChannelOutput event) { this.event = event; } /** * Invoked when the component the event handler is listening to is resized. * Notifies the event process that an ComponentEvent has occurred by sending * the ComponentEvent Object. Some notifications will be lost so there are no * guarantees that all events generated will be processed. * * @param e The parameters associated with this event */ public void componentResized(ComponentEvent e) { event.write(e); } /** * Invoked when the component the event handler is listening to is moved. * Notifies the event process that an ComponentEvent has occurred by sending * the ComponentEvent Object. Some notifications will be lost so there are no * guarantees that all events generated will be processed. * * @param e The parameters associated with this event */ public void componentMoved(ComponentEvent e) { event.write(e); } /** * Invoked when the component the event handler is listening to is shown. * Notifies the event process that an ComponentEvent has occurred by sending * the ComponentEvent Object. Some notifications will be lost so there are no * guarantees that all events generated will be processed. * * @param e The parameters associated with this event */ public void componentShown(ComponentEvent e) { event.write(e); } /** * Invoked when the component the event handler is listening to is hidden. * Notifies the event process that an ComponentEvent has occurred by sending * the ComponentEvent Object. Some notifications will be lost so there are no * guarantees that all events generated will be processed. * * @param e The parameters associated with this event */ public void componentHidden(ComponentEvent e) { event.write(e); } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveTextEnterField.java 0000644 0000000 0000000 00000041075 11105701167 020630 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import org.jcsp.lang.*; import org.jcsp.util.*; import org.jcsp.plugNplay.*; import java.awt.event.*; /** * A specialisation of {@link ActiveTextField} that writes text to * the event channel only when ENTER or ESCAPE is pressed. *
Process Diagram
*
*
Description
* ActiveTextEnterField is a process containing an {@link ActiveTextField ActiveTextField}, * configured with channels for event notification and configuration. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure and event channels are * settable from a constructor. *
* The difference between this class and ActiveTextField is that text * is only written to the event channel when ENTER or ESCAPE is pressed on * the text field (not on every keystroke). When this happens, the text field * is temporarilly disabled for (by default) half a second; this is to give * feedback to the user. The disable period can be changed by calling the * setDisableTime method before the process is run. *
* The internal ActiveTextField can be extracted with the getActiveTextField method. * Channels can then be added to notify the occurrence of any other type of Event * the ActiveFrame generates. This is done by calling its appropriate * addXXXEventChannel method * (before the process is run). As many channels can be added as are needed. *
* Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that the output channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. The simplest way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myTextFieldEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveTextEnterField myTextEnterField = * new ActiveTextEnterField (null, myTextFieldEvent.out (), "Edit Me"); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *String | *Set the text in this ActiveTextEnterField to the value of the String | *
| Boolean | *
*
|
* |
| ActiveTextField.Configure | *Invoke the user-defined Configure.configure method on the textField. | *|
| otherwise | *Append the toString form of the object to the text in this ActiveTextField. | *|
| Output Channels | *||
| event | *String | *The text in the ActiveTextEnterField (whenever ENTER or ESCAPE is pressed) | *
| componentEvent | *ComponentEvent | *See the * {@link #getActiveTextField getActiveTextField}.{@link ActiveTextField#addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the * {@link #getActiveTextField getActiveTextField}.{@link ActiveTextField#addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the * {@link #getActiveTextField getActiveTextField}.{@link ActiveTextField#addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the * {@link #getActiveTextField getActiveTextField}.{@link ActiveTextField#addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the * {@link #getActiveTextField getActiveTextField}.{@link ActiveTextField#addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
* import java.awt.*;
*
* public class ActiveTextEnterFieldExample {
*
* public static void main (String argv[]) {
*
* final ActiveClosingFrame frame =
* new ActiveClosingFrame ("ActiveTextEnterField Example");
*
* final Any2OneChannel event = Channel.any2one (new OverWriteOldestBuffer (10));
*
* final String[] string =
* {"Entia Non Sunt Multiplicanda Praeter Necessitatem",
* "Less is More ... More or Less",
* "Everything we do, we do it to you",
* "Race Hazards - What Rice Hozzers?",
* "Cogito Ergo Occam"};
*
* final String goodbye = "Goodbye World";
*
* final ActiveTextEnterField[] activeText =
* new ActiveTextEnterField[string.length];
*
* for (int i = 0; i < string.length; i++) {
* activeText[i] = new ActiveTextEnterField (null, event.out (), string[i]);
* }
*
* Panel panel = new Panel (new GridLayout (string.length, 1));
* for (int i = 0; i < string.length; i++) {
* panel.add (activeText[i].getActiveTextField ());
* }
*
* final Frame realFrame = frame.getActiveFrame ();
* realFrame.setBackground (Color.green);
* realFrame.add (panel);
* realFrame.pack ();
* realFrame.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* frame,
* new Parallel (activeText),
* new CSProcess () {
* public void run () {
* boolean running = true;
* while (running) {
* String s = (String) event.in ().read ();
* System.out.println (s);
* running = (! s.equals (goodbye));
* }
* realFrame.setVisible (false);
* System.exit (0);
* }
* }
* }
* ).run ();
* }
*
* }
*
*
* @see org.jcsp.awt.ActiveTextField
* @see java.awt.TextField
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveTextEnterField implements CSProcess
{
private AltingChannelInput configure;
private ChannelOutput event;
private String s;
private int columns;
private long disableTime = 500;
private ActiveTextField field;
private One2OneChannel keyEvent = Channel.one2one(new OverWriteOldestBuffer(10));
private One2OneChannel textEvent = Channel.one2one(new OverWriteOldestBuffer(10));
private One2OneChannel configureA = Channel.one2one();
private One2OneChannel configureB = Channel.one2one();
/**
* Constructs a new ActiveTextEnterField with configuration and event channels,
* but no initial text.
*
* @param configure the AltingChannelInput for configuration events
* -- can be null if no configuration is required.
* @param event the current text will be output when the ENTER or ESCAPE key is pressed
* -- can be null if no notification is required.
*/
public ActiveTextEnterField(AltingChannelInput configure, ChannelOutput event)
{
this(configure, event, "", 0);
}
/**
* Constructs a new ActiveTextEnterField with configuration and event channels,
* initial text and default width.
*
* @param configure the AltingChannelInput for configuration events
* -- can be null if no configuration is required.
* @param event the current text will be output when the ENTER or ESCAPE key is pressed
* -- can be null if no notification is required.
* @param s the initial text displayed in the field.
*/
public ActiveTextEnterField(AltingChannelInput configure, ChannelOutput event, String s)
{
this(configure, event, s, s.length());
}
/**
* Constructs a new ActiveTextEnterField with configuration and event channels,
* initial text and width.
*
* @param configure the AltingChannelInput for configuration events
* -- can be null if no configuration is required.
* @param event the current text will be output when the ENTER or ESCAPE key is pressed
* -- can be null if no notification is required.
* @param s the initial text displayed in the field.
* @param columns the width of the field.
*/
public ActiveTextEnterField(AltingChannelInput configure, ChannelOutput event, String s, int columns)
{
if (configure == null)
this.configure = Channel.one2one().in(); // the Plex2 process must have non-null channels
else
this.configure = configure;
this.event = event;
this.s = s;
this.columns = columns;
this.field = new ActiveTextField(configureB.in(), textEvent.out(), s, columns);
}
/**
* Sets the configuration channel for this ActiveTextEnterField.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public void setConfigureChannel(AltingChannelInput configure)
{
if (configure != null)
this.configure = configure; // the Plex2 process must have non-null channels
}
/**
* This is used to set the time during which the text field is disabled
* after an ENTER or ESCAPE has been entered.
* * NOTE: This may only be called before this process is run. * * @param disableTime the disable time after an ENTER or ESCAPE. */ public void setDisableTime(final long disableTime) { this.disableTime = disableTime; } /** * This is used to get the ActiveTextField within this component * so that it can be configured (using {@link java.awt.TextField} or * {@link org.jcsp.awt.ActiveTextField} methods) or added to some container. * For example, event channels can be added by invoking * getActiveTextField().addXXXEventChannel(...). *
* NOTE: such configuration must be finished before this process is run. *
* NOTE: do not use this method to set a configure channel - use an appropriate * constructor or {@link #setConfigureChannel setConfigureChannel}. * * @return the ActiveTextField within this component. */ public ActiveTextField getActiveTextField() { return field; } /** * The main body of this process. */ public void run() { field.addKeyEventChannel(keyEvent.out()); new Parallel(new CSProcess[] { new Plex2(configure, configureA.in(), configureB.out()), field, new CSProcess() { public void run() { CSTimer tim = new CSTimer(); Guard[] guard = {keyEvent.in(), textEvent.in()}; Alternative alt = new Alternative(guard); String text = s; ChannelInput keyEventIn = keyEvent.in(); ChannelInput textEventIn = textEvent.in(); ChannelOutput configureAOut = configureA.out(); while (true) { switch (alt.priSelect()) { case 0: final KeyEvent key = (KeyEvent) keyEventIn.read(); switch (key.getKeyCode()) { case KeyEvent.VK_ENTER: case KeyEvent.VK_ESCAPE: switch (key.getID()) { case KeyEvent.KEY_PRESSED: if (event != null) event.write(text); configureAOut.write(Boolean.FALSE); tim.after(tim.read() + disableTime); configureAOut.write(Boolean.TRUE); break; } break; } break; case 1: text = (String) textEventIn.read(); break; } } } } }).run(); } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/DisplayList.java 0000644 0000000 0000000 00000065560 11105701167 017054 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; /** * This implements the {@link Display} and {@link Paintable} interfaces and provides * a channel-like connection between user processes and an active graphics component. *
Description
* A DisplayList is a passive object providing graphics services on behalf * of a CSProcess. It provides an occam3-like CALL * channel between the application CSProcess and the active graphics component * (such as {@link ActiveCanvas ActiveCanvas}) * on which it wishes to draw. * *
* The user process sees the {@link Display Display} interface to the DisplayList * (in the same way as a writer process sees the OutputChannel interface to * a Channel). The ActiveCanvas process sees the {@link Paintable Paintable} * interface to the DisplayList (in the same way as a reader process sees * the InputChannel interface to a Channel). *
* Unlike a Channel, however, a DisplayList should never block * any of its attached processes indefinitely, regardless of the behaviour of its * partner at the other end. * The DisplayList imposes mutually exclusive access to its state and * there are no wait/notify operations -- so any delays should be transient. * User process sets/extends/changes and ActiveCanvas * paints/updates on the DisplayList, therefore, should always succeed. *
* Note: the cautionary note in the above paragraph is because Java * makes no guarantee that any invocation of a synchronized method * ever takes place. This is something with which any Java application has to live. *
* Any number of user processes may draw on the same component via a DisplayList * -- i.e. it is a any-one channel. * By reserving different sections of a DisplayList for control by different * processes, complex multiple animations can be simply managed. *
* Note: in this release, only the {@link #extend extend} and * {@link #change change} methods are safe for direct use by multiple * user processes on the same DisplayList. A process should only invoke * {@link #set set} at times when it knows others cannot be operating * on that DisplayList. This would normally be required by an application, * since a DisplayList reset invalidates the result * returned by a previous extend and the base index used in * a change -- i.e. concurrent processes doing these things will need * to be informed before they do them again! However, if the list really needs concurrent * setting without such an arrangement, this can be done within * a synchronized block on the DisplayList. *
* User applications will not normally be implementing new processes that are at the receiving * end of a DisplayList. Users will only be responsible for connecting a DisplayList * to a standard org.jcsp.awt drawing component. This can either be done statically (e.g. * through {@link ActiveCanvas#setPaintable setPaintable}) or dynamically (by sending * a {@link GraphicsProtocol.SetPaintable} object through * a {@link GraphicsProtocol} channel). * * @see org.jcsp.awt.GraphicsCommand * @see org.jcsp.awt.Display * @see org.jcsp.awt.Paintable * @see org.jcsp.awt.ActiveCanvas * * @author P.H. Welch */ public class DisplayList implements Paintable, Display { private Component component; private Dimension size; // *** private Image image; // *** private Graphics imageGraphics; // *** private final int INITIAL_MAX_COMMANDS = 10; private GraphicsCommand[] command = new GraphicsCommand[INITIAL_MAX_COMMANDS]; private int maxCommands = INITIAL_MAX_COMMANDS; private int nCommands = 0; private int updateIndex = 0; // invariant: 0 <= updateIndex <= nCommands <= maxCommands private boolean refresh = false; private boolean updated = true; private long minRefreshInterval = 10; // milliseconds /** * Sets the array of GraphicsCommands to be executed. The commands will * be executed in ascending order of index. * The repaint method of the registered component is called to trigger * the {@link #update update} callback on this object. * All commands will be executed. *
* * @param c the array of GraphicsCommands to be executed. */ public void set(final GraphicsCommand[] c) { if (c != null) { final int n = c.length; if (n > 0) { if (n <= maxCommands) { synchronized (this) { System.arraycopy(c, 0, command, 0, n); nCommands = n; updateIndex = 0; refresh = true; } } else { maxCommands = 2*n; final GraphicsCommand[] tmp = new GraphicsCommand[maxCommands]; System.arraycopy(c, 0, tmp, 0, n); synchronized (this) { command = tmp; nCommands = n; updateIndex = 0; refresh = true; } } } } component.repaint(minRefreshInterval); } /** * Sets the GraphicsCommand to be executed. * The repaint method of the registered component is called to trigger * the {@link #update update} callback on this object. *
* * @param c the GraphicsCommand to be executed. */ public void set(final GraphicsCommand c) { if (c != null) { synchronized (this) { command[0] = c; nCommands = 1; updateIndex = 0; refresh = true; } } component.repaint(minRefreshInterval); } /** * Extends the array of GraphicsCommands to be executed. * The repaint method of the registered component is called to trigger * the {@link #update update} callback on this object. * Only the new commands will be executed. *
* * @param c the extra GraphicsCommands to be executed. * @return the start index of the extension. */ public synchronized int extend(final GraphicsCommand[] c) { final int extensionStart = nCommands; if (c != null) { final int n = c.length; if (n > 0) { final int newNcommands = extensionStart + n; if (newNcommands <= maxCommands) { System.arraycopy(c, 0, command, extensionStart, n); if (updated) { updateIndex = extensionStart; updated = false; } nCommands = newNcommands; } else { maxCommands = 2*newNcommands; final GraphicsCommand[] tmp = new GraphicsCommand[maxCommands]; System.arraycopy(command, 0, tmp, 0, extensionStart); System.arraycopy(c, 0, tmp, extensionStart, n); command = tmp; if (updated) { updateIndex = extensionStart; updated = false; } nCommands = newNcommands; } } } component.repaint(minRefreshInterval); return extensionStart; } /** * Extends the array of GraphicsCommands to be executed by one command. * The repaint method of the registered component is called to trigger * the {@link #update update} callback on this object. * Only the new command will be executed. *
* * @param c the extra GraphicsCommand to be executed. * @return the start index of the extension. */ public synchronized int extend(final GraphicsCommand c) { final int extensionStart = nCommands; if (c != null) { final int newNcommands = extensionStart + 1; if (newNcommands <= maxCommands) { command[extensionStart] = c; if (updated) { updateIndex = extensionStart; updated = false; } nCommands = newNcommands; } else { maxCommands = 2*newNcommands; final GraphicsCommand[] tmp = new GraphicsCommand[maxCommands]; System.arraycopy(command, 0, tmp, 0, extensionStart); tmp[extensionStart] = c; command = tmp; if (updated) { updateIndex = extensionStart; updated = false; } nCommands = newNcommands; } } component.repaint(minRefreshInterval); return extensionStart; } /** * Changes the array of GraphicsCommands to be executed by replacing elements * i onwards with the new ones. There must be at least (i + c.length) * elements in the original array -- else this method will not change anything and will * return false. * The repaint method of the registered component is called to trigger * the {@link #update update} callback on this object. * All commands will be executed. *
* * @param c the new GraphicsCommands to be executed. * @param i the start index for the replacement. * @return true if and only if the changes are successfully made. */ public boolean change(final GraphicsCommand[] c, final int i) { if (c != null) { final int n = c.length; if (n > 0) { if ((i + n) <= nCommands) { synchronized (this) { System.arraycopy(c, 0, command, i, n); updateIndex = 0; refresh = true; } } else { return false; } } } component.repaint(minRefreshInterval); return true; } /** * Changes the array of GraphicsCommands to be executed by replacing element * i with the new one. There must be at least (i + 1) * elements in the original array -- else this method will not change anything and will * return false. * The repaint method of the registered component is called to trigger * the {@link #update update} callback on this object. * All commands will be executed. *
* * @param c the new GraphicsCommand to be executed. * @param i the index for the replacement. * @return true if and only if the change is successfully made. */ public boolean change(final GraphicsCommand c, final int i) { if (c != null) { if (i < nCommands) { synchronized (this) { command[i] = c; updateIndex = 0; refresh = true; } } else return false; } component.repaint(minRefreshInterval); return true; } /** * Returns a copy of the array of GraphicsCommands currently held. *
* * @return a copy of the array of GraphicsCommands currently held. */ public GraphicsCommand[] get() { final GraphicsCommand[] c = new GraphicsCommand[nCommands]; synchronized (this) { System.arraycopy(command, 0, c, 0, nCommands); } return c; } /** * Sets the repaint interval invoked by the {@link #set set}, * {@link #extend extend} and {@link #change change} commands. * The default is 10 milliseconds (the normal default for the * {@link java.awt.Component#repaint repaint} method from {@link java.awt.Component}). *
* * @param minRefreshInterval the display commands will be executed at most once * per minRefreshInterval milliseconds. */ public void setMinRefreshInterval(final long minRefreshInterval) { this.minRefreshInterval = minRefreshInterval; } private void execute(int start, Graphics g) { for (int i = start; i < nCommands; i++) { final GraphicsCommand c = command[i]; switch (c.tag) { case GraphicsCommand.NULL_TAG: // do nothing break; case GraphicsCommand.TRANSLATE: final GraphicsCommand.Translate t = (GraphicsCommand.Translate) c; g.translate(t.x, t.y); break; case GraphicsCommand.SET_COLOR: final GraphicsCommand.SetColor sc = (GraphicsCommand.SetColor) c; g.setColor(sc.c); break; case GraphicsCommand.SET_PAINT_MODE_TAG: g.setPaintMode(); break; case GraphicsCommand.SET_XOR_MODE: final GraphicsCommand.SetXORMode sx = (GraphicsCommand.SetXORMode) c; g.setXORMode(sx.c); break; case GraphicsCommand.SET_FONT: final GraphicsCommand.SetFont sf = (GraphicsCommand.SetFont) c; g.setFont(sf.f); break; case GraphicsCommand.CLIP_RECT: final GraphicsCommand.ClipRect clr = (GraphicsCommand.ClipRect) c; g.clipRect(clr.x, clr.y, clr.width, clr.height); break; case GraphicsCommand.SET_CLIP: final GraphicsCommand.SetClip scl = (GraphicsCommand.SetClip) c; switch (scl.cliptag) { case 0: g.setClip(scl.x, scl.y, scl.width, scl.height); break; case 1: g.setClip(scl.s); break; } break; case GraphicsCommand.COPY_AREA: final GraphicsCommand.CopyArea ca = (GraphicsCommand.CopyArea) c; g.copyArea(ca.x, ca.y, ca.width, ca.height, ca.dx, ca.dy); break; case GraphicsCommand.DRAW_LINE: final GraphicsCommand.DrawLine dl = (GraphicsCommand.DrawLine) c; g.drawLine(dl.x1, dl.y1, dl.x2, dl.y2); break; case GraphicsCommand.FILL_RECT: final GraphicsCommand.FillRect fr = (GraphicsCommand.FillRect) c; g.fillRect(fr.x, fr.y, fr.width, fr.height); break; case GraphicsCommand.DRAW_RECT: final GraphicsCommand.DrawRect dr = (GraphicsCommand.DrawRect) c; g.drawRect(dr.x, dr.y, dr.width, dr.height); break; case GraphicsCommand.CLEAR_RECT: final GraphicsCommand.ClearRect cr = (GraphicsCommand.ClearRect) c; g.clearRect(cr.x, cr.y, cr.width, cr.height); break; case GraphicsCommand.DRAW_ROUND_RECT: final GraphicsCommand.DrawRoundRect drr = (GraphicsCommand.DrawRoundRect) c; g.drawRoundRect(drr.x, drr.y, drr.width, drr.height, drr.arcWidth, drr.arcHeight); break; case GraphicsCommand.FILL_ROUND_RECT: final GraphicsCommand.FillRoundRect frr = (GraphicsCommand.FillRoundRect) c; g.fillRoundRect(frr.x, frr.y, frr.width, frr.height, frr.arcWidth, frr.arcHeight); break; case GraphicsCommand.DRAW_3D_RECT: final GraphicsCommand.Draw3DRect d3r = (GraphicsCommand.Draw3DRect) c; g.draw3DRect(d3r.x, d3r.y, d3r.width, d3r.height, d3r.raised); break; case GraphicsCommand.FILL_3D_RECT: final GraphicsCommand.Fill3DRect f3r = (GraphicsCommand.Fill3DRect) c; g.fill3DRect(f3r.x, f3r.y, f3r.width, f3r.height, f3r.raised); break; case GraphicsCommand.DRAW_OVAL: final GraphicsCommand.DrawOval dov = (GraphicsCommand.DrawOval) c; g.drawOval(dov.x, dov.y, dov.width, dov.height); break; case GraphicsCommand.FILL_OVAL: final GraphicsCommand.FillOval fov = (GraphicsCommand.FillOval) c; g.fillOval(fov.x, fov.y, fov.width, fov.height); break; case GraphicsCommand.DRAW_ARC: final GraphicsCommand.DrawArc da = (GraphicsCommand.DrawArc) c; g.drawArc(da.x, da.y, da.width, da.height, da.startAngle, da.arcAngle); break; case GraphicsCommand.FILL_ARC: final GraphicsCommand.FillArc fa = (GraphicsCommand.FillArc) c; g.fillArc(fa.x, fa.y, fa.width, fa.height, fa.startAngle, fa.arcAngle); break; case GraphicsCommand.DRAW_POLYLINE: final GraphicsCommand.DrawPolyline dpl = (GraphicsCommand.DrawPolyline) c; g.drawPolyline(dpl.xPoints, dpl.yPoints, dpl.nPoints); break; case GraphicsCommand.DRAW_POLYGON: final GraphicsCommand.DrawPolygon dpg = (GraphicsCommand.DrawPolygon) c; switch (dpg.polytag) { case 0: g.drawPolygon(dpg.xPoints, dpg.yPoints, dpg.nPoints); break; case 1: g.drawPolygon(dpg.p); break; } break; case GraphicsCommand.FILL_POLYGON: final GraphicsCommand.FillPolygon fpg = (GraphicsCommand.FillPolygon) c; switch (fpg.polytag) { case 0: g.fillPolygon(fpg.xPoints, fpg.yPoints, fpg.nPoints); break; case 1: g.fillPolygon(fpg.p); break; } break; case GraphicsCommand.DRAW_STRING: final GraphicsCommand.DrawString ds = (GraphicsCommand.DrawString) c; g.drawString(ds.string, ds.x, ds.y); break; case GraphicsCommand.DRAW_CHARS: final GraphicsCommand.DrawChars dc = (GraphicsCommand.DrawChars) c; g.drawChars(dc.data, dc.offset, dc.length, dc.x, dc.y); break; case GraphicsCommand.DRAW_BYTES: final GraphicsCommand.DrawBytes db = (GraphicsCommand.DrawBytes) c; g.drawBytes(db.data, db.offset, db.length, db.x, db.y); break; case GraphicsCommand.DRAW_IMAGE: final GraphicsCommand.DrawImage di = (GraphicsCommand.DrawImage) c; switch (di.drawtag) { case 0: g.drawImage(di.image, di.x, di.y, component); break; case 1: g.drawImage(di.image, di.x, di.y, di.width, di.height, component); break; case 2: g.drawImage(di.image, di.x, di.y, di.bgcolor, component); break; case 3: g.drawImage(di.image, di.x, di.y, di.width, di.height, di.bgcolor, component); break; case 4: g.drawImage(di.image, di.dx1, di.dy1, di.dx2, di.dy2, di.sx1, di.sy1, di.sx2, di.sy2, component); break; case 5: g.drawImage(di.image, di.dx1, di.dy1, di.dx2, di.dy2, di.sx1, di.sy1, di.sx2, di.sy2, di.bgcolor, component); break; } break; case GraphicsCommand.GENERAL: final GraphicsCommand.General general = (GraphicsCommand.General) c; general.g.doGraphic(g, component); break; } } } /** * Register the Component that will delegate its paint and * update methods here. Only the JCSP Active component should * perform this registration (in response to being passed this Paintable). *
* * @param c the Component that will do the delegating. */ public synchronized void register(final Component c) { component = c; } /** * This is the call-back delegated here by the registered Component. * It will normally be the JVM event thread that is making this call. *
* * @param g the graphics context for the painting. */ public synchronized void paint(final Graphics g) { final Dimension newSize = component.getSize(); if (image == null) { size = newSize; image = component.createImage(size.width, size.height); imageGraphics = image.getGraphics(); } else if ((newSize.width != size.width) || (newSize.height != size.height)) { size = newSize; image = component.createImage(size.width, size.height); imageGraphics = image.getGraphics(); } execute(0, imageGraphics); g.drawImage(image, 0, 0, component); refresh = false; } /** * This is the call-back delegated here by the registered Component. * It will normally be the JVM event thread that is making this call. *
* * @param g the graphics context for the painting. */ public synchronized void update(final Graphics g) { if (refresh) { final Dimension newSize = component.getSize(); if (image == null) { size = newSize; image = component.createImage(size.width, size.height); imageGraphics = image.getGraphics(); } else if ((newSize.width != size.width) || (newSize.height != size.height)) { size = newSize; image = component.createImage(size.width, size.height); imageGraphics = image.getGraphics(); } execute(0, imageGraphics); g.drawImage(image, 0, 0, component); refresh = false; updated = true; } else { final Dimension newSize = component.getSize(); if (image == null) { size = newSize; image = component.createImage(size.width, size.height); imageGraphics = image.getGraphics(); } else if ((newSize.width != size.width) || (newSize.height != size.height)) { size = newSize; image = component.createImage(size.width, size.height); imageGraphics = image.getGraphics(); } execute(updateIndex, imageGraphics); g.drawImage(image, 0, 0, component); updated = true; } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/TextEventHandler.java 0000644 0000000 0000000 00000005667 11105701167 020041 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.awt.event.*; import org.jcsp.lang.*; /** * @author P.D. Austin and P.H. Welch */ class TextEventHandler implements TextListener { /** * The Channel TextEvent notifications are sent down. */ private ChannelOutput event; /** * constructs a new TextEventHandler with the specified event Channel. * * @param event The Channel TextEvent notifications are sent down. */ public TextEventHandler(ChannelOutput event) { this.event = event; } /** * Invoked when an Text change occurs on the component the event handler is * listening to. Notifies the event process that an TextEvent has * occurred. Some notifications will be lost so there are no guarantees * that all events generated will be processed. * * @param e The parameters associated with this event */ public void textValueChanged(TextEvent e) { event.write(((TextComponent)e.getSource()).getText()); } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/KeyEventHandler.java 0000644 0000000 0000000 00000007510 11105701167 017632 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import org.jcsp.lang.*; import java.awt.event.*; /** * @author P.D. Austin and P.H. Welch */ class KeyEventHandler implements KeyListener { /** * The Channel action event notifications are sent down. */ private ChannelOutput event; /** * constructs a new KeyEventHandler with the specified output Channel. * * @param event The Channel to send the event notification down */ public KeyEventHandler(ChannelOutput event) { this.event = event; } /** * Invoked when the Component the event handler is listening to has a key * pressed and then released. Notifies the event process that a KeyEvent has * occurred by sending the KeyEvent Object. Some notifications will be * lost so there are no guarantees that all events generated will be * processed. * * @param e The parameters associated with this event */ public void keyTyped(KeyEvent e) { event.write(e); } /** * Invoked when the Component the event handler is listening to has a key * pressed. Notifies the event process that a KeyEvent has * occurred by sending the KeyEvent Object. Some notifications will be * lost so there are no guarantees that all events generated will be * processed. * * @param e The parameters associated with this event */ public void keyPressed(KeyEvent e) { event.write(e); } /** * Invoked when the Component the event handler is listening to has a key * released. Notifies the event process that a KeyEvent has * occurred by sending the KeyEvent Object. Some notifications will be * lost so there are no guarantees that all events generated will be * processed. * * @param e The parameters associated with this event */ public void keyReleased(KeyEvent e) { event.write(e); } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/Paintable.java 0000644 0000000 0000000 00000010545 11105701167 016503 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.Graphics; import java.awt.Component; /** * Active components may delegate their paint and update * methods to objects implementing this interface. *
Description
* Objects implementing Paintable may be passed to an Active * component (such as {@link ActiveCanvas}). The Active component will * then {@link #register register} with the Paintable object * and delegate to it its paint and update methods. ** The Paintable object may either be passed statically * (via the component's {@link ActiveCanvas#setPaintable setPaintable} * method, before the component starts running) or dynamically * (via the component's * {@link ActiveCanvas#setGraphicsChannels toGraphics/fromGraphics} * channels). *
* Note: these operations are currently supported only for * {@link ActiveCanvas ActiveCanvas} components. *
* A CSProcess may choose to implement Paintable itself and take * responsibility for its own painting/updating. However, this would break the JCSP * design pattern that the thread(s) of control within a running process have exclusive * access to the process state (since painting/updating is actually done by the * Java event thread). It is, therefore, better to delegate this task to * a different (and passive) object such as a {@link DisplayList}. * * @see org.jcsp.awt.ActiveCanvas * @see org.jcsp.awt.DisplayList * * @author P.H. Welch */ public interface Paintable { /** * Register the Component that will delegate its paint and * update methods here. * * @param c the Component that will do the delegating. */ public void register(final Component c); /** * This is the call-back delegated here by the registered Component. * It will normally be the JVM event thread that is making this call. * * @param g the graphics context for the painting. */ public void paint(final Graphics g); /** * This is the call-back delegated here by the registered Component. * It will normally be the JVM event thread that is making this call. * * @param g the graphics context for the painting. */ public void update(final Graphics g); } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveScrollPane.java 0000644 0000000 0000000 00000037401 11105701167 020002 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.ScrollPane java.awt.ScrollPane} * with a channel interface. *
Process Diagram
*
Description
* ActiveScrollPane is a process extension of java.awt.ScrollPane * with channels for run-time configuration and event notification. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure channel is settable from a constructor. * Event channels can be added to notify the occurrence of any type of Event * the component generates (by calling the appropriate * addXXXEventChannel method before the process is run). * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myMouseEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveScrollPane myScrollPane = new ActiveScrollPane (); * myScrollPane.addMouseEventChannel (myMouseEvent.out ()); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *ActiveScrollPane.Configure | *Invoke the user-defined Configure.configure method on the scrollPane. | *
| Output Channels | *||
| containerEvent | *ContainerEvent | *See the {@link #addContainerEventChannel * addContainerEventChannel} method. | *
| componentEvent | *ComponentEvent | *See the {@link #addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the {@link #addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the {@link #addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the {@link #addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the {@link #addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import java.awt.*;
* import java.awt.event.*;
* import org.jcsp.util.*;
* import org.jcsp.lang.*;
* import org.jcsp.awt.*;
*
* public class ActiveScrollPaneExample {
*
* public static void main (String argv[]) {
*
* final Frame root = new Frame ("ActiveScrollPane Example");
*
* final One2OneChannel mouseEvent = Channel.one2one (new OverWriteOldestBuffer (10));
*
* final ActiveScrollPane scrollPane = new ActiveScrollPane ();
* scrollPane.addMouseEventChannel (mouseEvent.out ());
*
* root.add (scrollPane);
* root.setSize (400, 400);
* root.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* scrollPane,
* new CSProcess () {
* public void run () {
* boolean running = true;
* while (running) {
* final MouseEvent event = (MouseEvent) mouseEvent.in ().read ();
* switch (event.getID ()) {
* case MouseEvent.MOUSE_ENTERED:
* System.out.println ("MOUSE_ENTERED");
* break;
* case MouseEvent.MOUSE_EXITED:
* System.out.println ("MOUSE_EXITED");
* break;
* case MouseEvent.MOUSE_PRESSED:
* System.out.println ("MOUSE_PRESSED");
* break;
* case MouseEvent.MOUSE_RELEASED:
* System.out.println ("MOUSE_RELEASED");
* break;
* case MouseEvent.MOUSE_CLICKED:
* if (event.getClickCount() > 1) {
* System.out.println ("MOUSE_DOUBLE_CLICKED ... goodbye!");
* running = false;
* } else {
* System.out.println ("MOUSE_CLICKED ... *double* click to quit!");
* }
* break;
* }
* }
* root.setVisible (false);
* System.exit (0);
* }
* }
* }
* ).run ();
* }
*
* }
*
*
* @see java.awt.ScrollPane
* @see java.awt.event.ContainerEvent
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveScrollPane extends ScrollPane implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* Constructs a new ActiveScrollPane with a display policy of
* java.awt.ScrollPane.SCROLLBARS_AS_NEEDED and without a configure
* channel.
*/
public ActiveScrollPane()
{
this(SCROLLBARS_AS_NEEDED, null);
}
/**
* Constructs a new ActiveScrollPane without a configure
* channel.
*
* @param scrollbarDisplayPolicy - policy for when scrollbars should be shown
* (java.awt.ScrollPane.SCROLLBARS_AS_NEEDED, SCROLLBARS_ALWAYS,
* SCROLLBARS_NEVER).
*/
public ActiveScrollPane(int scrollbarDisplayPolicy)
{
this(scrollbarDisplayPolicy, null);
}
/**
* Constructs a new ActiveScrollPane.
*
* @param scrollbarDisplayPolicy - policy for when scrollbars should be shown
* (java.awt.ScrollPane.SCROLLBARS_AS_NEEDED, SCROLLBARS_ALWAYS,
* SCROLLBARS_NEVER).
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public ActiveScrollPane(int scrollbarDisplayPolicy, ChannelInput configure)
{
super(scrollbarDisplayPolicy);
this.configure = configure;
}
/**
* Sets the configuration channel for this ActiveScrollPane.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* Add a new channel to this component that will be used to notify that
* a ContainerEvent has occurred. This should be used
* instead of registering a ContainerListener with the component. It is
* possible to add more than one Channel by calling this method multiple times
* If the channel passed is null, no action will be taken.
* * NOTE: This method must be called before this process is run. * * @param containerEvent the channel down which to send ContainerEvents. */ public void addContainerEventChannel(ChannelOutput containerEvent) { if (containerEvent != null) { ContainerEventHandler handler = new ContainerEventHandler(containerEvent); addContainerListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a ComponentEvent has occurred. This should be used * instead of registering a ComponentListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param componentEvent the channel down which to send ComponentEvents. */ public void addComponentEventChannel(ChannelOutput componentEvent) { if (componentEvent != null) { ComponentEventHandler handler = new ComponentEventHandler(componentEvent); addComponentListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a FocusEvent has occurred. This should be used * instead of registering a FocusListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param focusEvent the channel down which to send FocusEvents. */ public void addFocusEventChannel(ChannelOutput focusEvent) { if (focusEvent != null) { FocusEventHandler handler = new FocusEventHandler(focusEvent); addFocusListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a KeyEvent has occurred. This should be used * instead of registering a KeyListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param keyEvent the channel down which to send KeyEvents. */ public void addKeyEventChannel(ChannelOutput keyEvent) { if (keyEvent != null) { KeyEventHandler handler = new KeyEventHandler(keyEvent); addKeyListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseEvent has occurred. This should be used * instead of registering a MouseListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseEvent the channel down which to send MouseEvents. */ public void addMouseEventChannel(ChannelOutput mouseEvent) { if (mouseEvent != null) { MouseEventHandler handler = new MouseEventHandler(mouseEvent); addMouseListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseMotionEvent has occurred. This should be used * instead of registering a MouseMotionListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseMotionEvent the channel down which to send MouseMotionEvents. */ public void addMouseMotionEventChannel(ChannelOutput mouseMotionEvent) { if (mouseMotionEvent != null) { MouseMotionEventHandler handler = new MouseMotionEventHandler(mouseMotionEvent); addMouseMotionListener(handler); vec.addElement(handler); } } /** * This enables general configuration of this component. Any object implementing * this interface and sent down the configure channel to this component will have its * configure method invoked on this component. *
* For an example, see {@link ActiveApplet.Configure}. */ static public interface Configure { /** * @param scrollPane the ScrollPane being configured. */ public void configure(final ScrollPane scrollPane); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message instanceof Configure) ((Configure) message).configure(this); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveMenu.java 0000644 0000000 0000000 00000033314 11105701167 016643 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.Menu java.awt.Menu} * with a channel interface. *
Process Diagram
*
*
Description
* ActiveMenu is a process extension of java.awt.Menu * with channels for run-time configuration and event notification. The event channel * should be connected to an application-specific server process (instead * of registering a passive object as a Listener to this component). ** The configure and event channels are * settable from a constructor. * The event channel delivers the command string associated with this * ActiveMenu whenever it is selected. * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service the event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that a (non-null) event channel from this process is * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myMenuEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveMenu myMenu = * new ActiveMenu (null, myMenuEvent.out (), "Look at this"); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *String | *Change the label on the ActiveMenu to the value of the String | *
| java.awt.MenuShortcut | *Sets the MenuShortcut for the ActiveMenu | *|
| Integer | ** Inserts a separator at the specified position. * | *|
| Boolean | *
*
|
* |
| ActiveMenu.Configure | *Invoke the user-defined Configure.configure method on the activeMenu. | *|
| Output Channels | *||
| event | *String | *The command for the ActiveMenu (when the menu is selected) | *
Example
*
* import java.awt.*;
* import java.awt.event.*;
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
*
* public class ActiveMenuExample {
*
* public static void main (String argv[]) {
*
* final ActiveClosingFrame activeClosingFrame =
* new ActiveClosingFrame ("ActiveCheckboxMenuItem Example");
*
* final ActiveFrame frame = activeClosingFrame.getActiveFrame ();
*
* final MenuBar menuBar = new MenuBar ();
* frame.setMenuBar (menuBar);
*
* final Menu fileMenu = new Menu ("File");
* menuBar.add (fileMenu);
*
* final String[] fileOptions = {"Hello World", "Rocket Science", "CSP",
* "Monitors", "Ignore Me", "Goodbye World"};
*
* final Any2OneChannel event[] = Channel.any2oneArray (2, new OverWriteOldestBuffer (10));
*
* final ActiveMenuItem[] fileMenuItem =
* new ActiveMenuItem[fileOptions.length];
* for (int i = 0; i < fileOptions.length; i++) {
* fileMenuItem[i] = new ActiveMenuItem (null, event[0].out (), fileOptions[i]);
* fileMenu.add (fileMenuItem[i]);
* }
*
* fileMenu.addSeparator ();
*
* final Any2OneChannel langConfigure = Channel.any2one ();
* final ActiveMenu langMenu = new ActiveMenu (langConfigure.in (), null, "Language");
* fileMenu.add (langMenu); // set up the active langMenu as a sub-menu
*
* final String[] langOptions = {"occam-pi", "Java", "Smalltalk", "Algol-60",
* "Pascal", "Haskell", "SML", "Lisp"};
*
* final ActiveCheckboxMenuItem[] langCheckboxMenuItem =
* new ActiveCheckboxMenuItem[langOptions.length];
* for (int i = 0; i < langOptions.length; i++) {
* langCheckboxMenuItem[i] =
* new ActiveCheckboxMenuItem (null, event[1].out (), langOptions[i]);
* langMenu.add (langCheckboxMenuItem[i]);
* }
*
* frame.setSize (700, 350);
* frame.setBackground (Color.green);
* frame.setVisible (true);
*
* new Parallel (
* new CSProcess[] { // don't forget to include all active processes
* langMenu,
* activeClosingFrame,
* new Parallel (fileMenuItem),
* new Parallel (langCheckboxMenuItem),
* new CSProcess () {
* public void run () {
* boolean running = true;
* while (running) {
* final String s = (String) event[0].in ().read ();
* System.out.println ("File ==> `" + s + "' selected ...");
* if (s == fileOptions[0]) {
* langConfigure.out ().write (Boolean.TRUE);
* System.out.println ("`Language' enabled ...");
* }
* running = (s != fileOptions[fileOptions.length - 1]);
* }
* frame.setVisible (false);
* System.exit (0);
* }
* },
* new CSProcess () {
* public void run () {
* while (true) {
* final ItemEvent e = (ItemEvent) event[1].in ().read ();
* final String item = (String) e.getItem ();
* System.out.print ("Language ==> `" + item);
* if (e.getStateChange () == ItemEvent.SELECTED) {
* System.out.println ("' selected ...");
* if (item == langOptions[0]) {
* langConfigure.out ().write (Boolean.FALSE);
* System.out.println ("`Language' disabled ...");
* }
* } else {
* System.out.println ("' deselected ...");
* }
* }
* }
* }
* }
* ).run ();
*
* }
*
* }
*
*
* @see java.awt.Menu
* @see java.awt.event.ItemEvent
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveMenu extends Menu implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* Constructs an ActiveMenu with no initial label and no configuration
* or event channels.
*/
public ActiveMenu()
{
this(null, null, "", false);
}
/**
* Constructs an ActiveMenu with an initial label,
* but with no configuration or event channels.
*
* @param label the label on the menu.
*/
public ActiveMenu(String label)
{
this(null, null, label, false);
}
/**
* Constructs an ActiveMenu with an initial label
* and a tear-off option, but with no configuration
* or event channels.
*
* @param label the label on the menu.
* @param tearOff if true, this is a tear-off menu.
*/
public ActiveMenu(String label, boolean tearOff)
{
this(null, null, label, tearOff);
}
/**
* Constructs an ActiveMenu with configuration and event channels,
* but with no initial label.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public ActiveMenu(ChannelInput configure, ChannelOutput event)
{
this(configure, event, "", false);
}
/**
* Constructs an ActiveMenu with configuration and event channels
* and an initial label.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param label the label on the menu.
*/
public ActiveMenu(ChannelInput configure, ChannelOutput event, String label)
{
this(configure, event, label, false);
}
/**
* Constructs an ActiveMenu with configuration and event channels,
* an initial label and a tear-off option.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param label the label on the menu.
* @param tearOff if true, this is a tear-off menu.
*/
public ActiveMenu(ChannelInput configure, ChannelOutput event, String label, boolean tearOff)
{
super(label, tearOff);
if (event != null)
{
ActionEventHandler handler = new ActionEventHandler(event);
addActionListener(handler);
vec.addElement(handler);
}
this.configure = configure;
}
/**
* Sets the configuration channel for this ActiveMenu.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* This enables general configuration of this component. Any object implementing
* this interface and sent down the configure channel to this component will have its
* configure method invoked on this component.
*
* For an example, see {@link ActiveApplet.Configure}.
*/
static public interface Configure
{
/**
* @param menu the Menu being configured.
*/
public void configure(final Menu menu);
}
/**
* The main body of this process.
*/
public void run()
{
if (configure != null)
{
while (true)
{
Object message = configure.read();
if (message instanceof String)
setLabel((String) message);
else if (message instanceof MenuShortcut)
setShortcut((MenuShortcut) message);
if (message instanceof Integer)
insertSeparator(((Integer) message).intValue());
else if (message instanceof Boolean)
{
if (message == Boolean.TRUE)
setEnabled(true);
else if (message == Boolean.FALSE)
setEnabled(false);
}
else if (message instanceof Configure)
((Configure) message).configure(this);
}
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/awt/doc-files/ 0000755 0000000 0000000 00000000000 11410045053 015573 5 ustar jcsp-1.1-rc4.orig/src/org/jcsp/awt/doc-files/ActiveComponent1.gif 0000644 0000000 0000000 00000020724 10520670125 021453 0 ustar GIF89aÜ&÷ $$$(((,,,000888<<<@@@HHHLLLPPPYYY]]]aaaiiiqqquuuyyy}}}………•••¡¡¡¥¥¥®®®²²²¶¶¶¾¾¾ÆÆÆÎÎÎÖÖÖÚÚÚÞÞÞæææîîîòòòöööÿÿÿ , Ü& ÿ U H° Áƒ*\È°¡Ã‡#JœH±¢Å‹3jÜȱ£Ç CŠ I²¤É“(Sª\ɲ¥Ë—0cÊœI³¦Í›8sêÜɳ§ÏŸ@ƒ
J´¨Ñ£H“*]Ê´)Ä,HJµªÕ«X³jÝʵ«×¯W/”pJ¶¬Y H ˶۷pÁV €á¬Ý»x&‘weŠ'ú
ì á” @ ^ÌX¨áÆ$CžLÙæãÊ %cÞÌ9ååÎ5ƒ MšãçÒE£^ÍúáéÖUÞM[àëÚ eãÞ]ú6 Çì{øÀàÆ“/.ž ùdT\(@zt‰Ð•ßenÜ9ä
¤ÿ p¡¼b‰àµÛå>Ü;J8 !0‚|ú"\P@A„"¨à ñy ÿ]çÀñ]·ß|*dà@÷e @úà@D * ¨€R8Ÿ…ªg{¹wÒü§‚\AÐg¡¤GÝ ‚ èW *üè $LdâEУ P—Á ü'_„8&y \`!XJY •VªX‹¿¹X’Bª€‚
pžWãtt†9cxG
T£Œ*P eŸpú`•dB¹g’áaI^y~fУ ‚Šà yŠÊ˜žšd±É››$*gžÞ %œÑizÝŸáI7ht…Zÿg ž‹¦‡å† þ瀀wŠI«¦rÚ”§»J†(ܘ¤‡câ‰j
˜° L‚ [ÖHª € t™ò©@“ÔZ*Âœ`Æ™A"˜à€¿ŠKŸ°L‹›±#õøcˆÕE笶ì
u ªp#xôi+»ØR‡$óº`uÖ (¯gº*PÄÜîJïRöÖ†/NÚ~l2A!Ó6òM%Ÿ|rʳlÓ¹.» 3l2uB
5wsk9e]<÷ÌÛϬ
€AÑFÓ†ôjJÿT X;
uÔ¬MÚÄ%öØ`5€õÙZsÝõÇ„MöÛp[ÅôÙ ÐÚkÓ[µOWcÿm7Þy]ÚÞ=- ›à¤¾ÓÐ(>ã£9®S`’Oþ±å™wŽå áKß¼FY:“ æšNéžSzgÆö·’"y¬‘íùç€}¸®D}Zê*ÑغE¯s*¼oâ~‘¸›À®@ »’¢]V` ½ Qò›Új´Æ‡¤&XL©|ÎSÀ¾ñF$Œé>®Y>tR`߸ô«Ïur§‚ÅÇb*€4#ûxÌ}
(Ø€¸•¾€ñOþ“·"@E
}êƒ h‚ í
RÞ“ø0ã&ý%I:Å{a”
€€vÛ£ ý#‚ê¥Ê]½Û ÿÐ7¾f@Nj” лì
¤z©a’ Ä :1±UT²Q}@°° (GDAý!ùGK%¤!\8Ÿ.ÎH$h
Sø½Íg!PŒTФpK:©ÈHHARp†Ø@"=äAT©<ûy!¤z œ‡Oid}bÈÃ"…k$ß'q(=HVò’R úc.@Ψåaâ Õ'EWÒ±Žz»£B¶W éhýÓŒ2`4RÄ4¦t$Çha«3DD:¨‡RÔŸIN?9$Ï•ÈøF&Z¬ƒ•üÄCl¾Ð‘»"_ë'Î$™«xë”a óyÿK‡¬°2nÚ •ö(ÆèHO‰sr çÔ@5ª ŠIÑ éÄG [²O §§ nŠi¢ÚÏœ((Xá(V$£¶9#ÅÄhF郞=
v {\låA7vD Á4¥9´^?òOÊÔ‹é#~Ž˜J(r‘£ÏSõŸ¥[ AÁô®(,D‹ hÇA¬ju û‰`® ôm ŒD”PÁà£Vø½¬ â#Yé³;lO‚çÏî6æÔ#‚¨ZCu bCnfˆ;jbRÔɸi¬ü;Œ0sÒŸÉús±ž
íç@+ÚÒN¤²áœiéˆÚƨvµÞk-c^ ÛÖÿÉv1´mçn{˜ÜêVr¼%Œo ¸àf¸ÄU›qƒÜäFm¹}i®s{ݼHwº6#-v[]¼\w» ëî]¾ ^a‰×.ä-¯šÎ{–ôªW=ì5‹{ß«œø–e¾ôõ™vóZû’¿üýà ïfÀM)°kƒ`¦(x"pÌHêT·`4x)Ž$;‘ÐM“™a…Kra¥d"}ÊxR7‘[˜$%Nʉ âa€9ìCÔ‰–ñ$¨}m*wå#Dý³âeQG`êÞ‹;c¤Ì¸! £
¸5¤‰˜üžR4É UlKÊR«}E)
Q€ZKI“òä†h«ÿd j¤–¡¤€ sÅ–)Žj$½Ý¨”¤rqšA²f£´™!oÆ¡håˆJP:¤£ ‚! I•R˜†=hº(‡^ˆ¶nT-j‘ H=â`‘<@ éÍPY²B¡ -¦N>ÁJCÓ’r§=½_žLèCÿaªˆ
æ¾íJD–Pð
* All channels are optional. The configure and event channels are
* settable from a constructor.
*
* The difference between this class and ActiveFrame is that a Window Closing event,
* generated on the (internal) ActiveFrame, is intercepted by the anonymous process
* and results in a System.exit. This happens regardless as to whether
* the (external) event channel is null. Otherwise, WindowEvents
* are forwarded to the (external) event channel, so long as it's not null).
*
* The internal ActiveFrame can be extracted with the getActiveFrame method.
* Channels can then be added to notify the occurrence of any other type of Event
* the ActiveFrame generates. This is done by calling its appropriate
* addXXXEventChannel method
* (before the process is run). As many channels can be added as are needed.
*
* Messages can be sent down the configure channel at any time to configure
* the component. See the table below for details.
*
* All channels are managed by independent internal handler processes. It is, therefore,
* safe for a serial application process both to service an event channel and configure
* the component -- no deadlock can occur.
*
* IMPORTANT: it is essential that the output channels from this process are
* always serviced -- otherwise the Java Event Thread will be blocked and the GUI
* will stop responding. The simplest way to guarantee this is to use channels
* configured with overwriting buffers.
* For example:
* Process Diagram
* 
Description
* ActiveClosingFrame is a process containing an {@link ActiveFrame ActiveFrame},
* configured with channels for event notification and configuration. The event channels
* should be connected to one or more application-specific server processes (instead
* of registering a passive object as a Listener to this component).
*
* final One2OneChannel myWindowEvent = Channel.one2one (new OverWriteOldestBuffer (n));
* final One2OneChannel myMouseEvent = Channel.one2one (new OverWriteOldestBuffer (n));
*
* final ActiveClosingFrame myFrame = new ActiveClosingFrame (myWindowEvent.out ());
* final ActiveFrame myActiveFrame = myFrame.getActiveFrame ();
* myActiveFrame.addMouseEventChannel (myMouseEvent.out ());
*
* This will ensure that the Java Event Thread will never be blocked.
* Slow or inattentive readers may miss rapidly generated events, but
* the n most recent events will always be available.
*
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *Boolean | *
*
|
*
| ActiveFrame.Configure | *Invoke the user-defined Configure.configure method on the frame. | *|
| Output Channels | *||
| event | *WindowEvent | *The WindowEvent generated by the component (note that * Window Closing is handled locally to cause * a System.exit). | *
| containerEvent | *ContainerEvent | *See the * {@link #getActiveFrame getActiveFrame}.{@link ActiveFrame#addContainerEventChannel * addContainerEventChannel} method. | *
| componentEvent | *ComponentEvent | *See the * {@link #getActiveFrame getActiveFrame}.{@link ActiveFrame#addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the * {@link #getActiveFrame getActiveFrame}.{@link ActiveFrame#addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the * {@link #getActiveFrame getActiveFrame}.{@link ActiveFrame#addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the * {@link #getActiveFrame getActiveFrame}.{@link ActiveFrame#addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the * {@link #getActiveFrame getActiveFrame}.{@link ActiveFrame#addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import java.awt.*;
* import java.awt.event.*;
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
*
* public class ActiveClosingFrameButtonExample {
*
* public static void main (String argv[]) {
*
* final ActiveClosingFrame frame =
* new ActiveClosingFrame ("ActiveClosingFrameButton Example");
*
* final String[] label = {"Hello World", "Rocket Science", "CSP",
* "Monitors", "Ignore Me", "Goodbye World"};
*
* final Any2OneChannel buttonEvent = Channel.any2one (new OverWriteOldestBuffer (10));
*
* final ActiveButton[] button = new ActiveButton[label.length];
* for (int i = 0; i < label.length; i++) {
* button[i] = new ActiveButton (null, buttonEvent.out (), label[i]);
* }
*
* final Frame realFrame = frame.getActiveFrame ();
* realFrame.setSize (300, 200);
* realFrame.setLayout (new GridLayout (label.length/2, 2));
* for (int i = 0; i < label.length; i++) {
* realFrame.add (button[i]);
* }
* realFrame.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* frame,
* new Parallel (button),
* new CSProcess () {
* public void run () {
* boolean running = true;
* while (running) {
* final String s = (String) buttonEvent.in ().read ();
* System.out.println ("Button `" + s + "' pressed ...");
* running = (s != label[label.length - 1]);
* }
* realFrame.setVisible (false);
* System.exit (0);
* }
* }
* }
* ).run ();
*
* }
*
* }
*
*
* @see org.jcsp.awt.ActiveFrame
* @see java.awt.Frame
* @see java.awt.event.ContainerEvent
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveClosingFrame implements CSProcess
{
private ChannelInput configure;
private ChannelOutput event;
private String title;
private ActiveFrame frame;
private One2OneChannel windowEvent = Channel.one2one();
/**
* Constructs a new ActiveClosingFrame with no title and no configuration
* or event channels.
*
*/
public ActiveClosingFrame()
{
this(null, null, "");
}
/**
* Constructs a new ActiveClosingFrame with a title but no configuration
* or event channels.
*
* @param title the title for the frame.
*/
public ActiveClosingFrame(String title)
{
this(null, null, title);
}
/**
* Constructs a new ActiveClosingFrame with configuration
* and event channels, but no title.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event a WindowEvent will be output whenever it occurs
* -- can be null if no notification is required.
*/
public ActiveClosingFrame(ChannelInput configure, ChannelOutput event)
{
this(configure, event, "");
}
/**
* Constructs a new ActiveClosingFrame with configuration
* and event channels and a title.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event a WindowEvent will be output whenever it occurs
* -- can be null if no notification is required.
* @param title the title for the frame.
*/
public ActiveClosingFrame(ChannelInput configure, ChannelOutput event, String title)
{
this.configure = configure;
this.event = event;
this.title = title;
this.frame = new ActiveFrame(this.configure, windowEvent.out(), title);
}
/**
* Sets the configuration channel for this ActiveButton.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.frame.setConfigureChannel(configure);
}
/**
* This is used to get the ActiveFrame within this component
* so that it can be configured or have components added
* (using {@link java.awt.Frame} or {@link org.jcsp.awt.ActiveFrame} methods).
* For example, event channels can be added by invoking
* getActiveFrame().addXXXEventChannel(...).
* * NOTE: This must be finished before this process is run. * * @return the Frame within this component. */ public ActiveFrame getActiveFrame() { return frame; } /** * The main body of this process. */ public void run() { new Parallel(new CSProcess[] {frame, new CSProcess() { public void run() { boolean running = true; ChannelInput windowEventIn = windowEvent.in(); while (running) { final WindowEvent window = (WindowEvent) windowEventIn.read(); if (event != null) event.write(window); switch (window.getID()) { case WindowEvent.WINDOW_CLOSING: running = false; break; } } frame.setVisible(false); System.exit(0); } } }).run(); } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveButtonState.java 0000644 0000000 0000000 00000017223 11105701167 020214 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; /** * A state of the {@link ActiveButtonControl} finite state machine. *
Description
* ActiveButtonState is one of the elements of the state table governing * the behaviour of the finite state machine within an {@link ActiveButtonControl}. * For each controlled button, it holds the index of the label to be displayed in * this state, whether that button should be enabled or disabled and which state * should be jumped to if that button is pressed. * See the example documented in * ActiveButtonControl. ** @see org.jcsp.awt.ActiveButton * @see org.jcsp.awt.ActiveButtonControl * * @author P.H. Welch */ public class ActiveButtonState { int[] labelId; // button labels for this state boolean[] enable; // button status for this state int[] next; // next state after this button is pushed private boolean verbose; /** * Constructs a new ActiveButtonState, performing consistency * checks on its supplied arguments. * * @param labelId the button labels for this state. * @param enable the enable/disable status of each button for this state * (true <==> enabled). * @param next the next state after each button is pushed. * @throws ActiveButtonState.BadArguments if the consistency check fails. * The exception contains details of the error. */ public ActiveButtonState(int[] labelId, boolean[] enable, int[] next) throws ActiveButtonState.BadArguments { this(labelId, enable, next, false); } /** * Constructs a new ActiveButtonState, performing consistency * checks on its supplied arguments, with a verbose reporting option. * * @param labelId the button labels for this state. * @param enable the enable/disable status of each button for this state * (true <==> enabled). * @param next the next state after each button is pushed. * @param verbose if true, a running commentary is printed on the consistency checks. * @throws ActiveButtonState.BadArguments if the consistency check fails. * The exception contains details of the error. */ public ActiveButtonState(int[] labelId, boolean[] enable, int[] next, boolean verbose) throws ActiveButtonState.BadArguments { if (verbose) System.out.println("ActiveButtonState creating ..."); // sanity checks if (labelId == null) throw new ActiveButtonState.BadArguments("labelId == null"); if (enable == null) throw new ActiveButtonState.BadArguments("enable == null"); if (next == null) throw new ActiveButtonState.BadArguments("next == null"); if (verbose) System.out.println("ActiveButtonState: arguments not null"); if (labelId.length != enable.length) throw new ActiveButtonState.BadArguments("labelId.length != enable.length"); if (verbose) System.out.println("labelId.length == enable.length"); if (labelId.length != next.length) throw new ActiveButtonState.BadArguments("labelId.length != next.length"); if (verbose) System.out.println("labelId.length == next.length"); for (int i = 0; i < labelId.length; i++) if (labelId[i] < 0) throw new ActiveButtonState.BadArguments("labelId[" + i + "] is negative"); if (verbose) System.out.println("all label indices positive"); for (int i = 0; i < next.length; i++) if (next[i] < 0) throw new ActiveButtonState.BadArguments("next[" + i + "] is negative"); if (verbose) System.out.println("all next states positive"); if (verbose) for (int i = 0; i < next.length; i++) System.out.println(" " + labelId[i] + ", " + enable[i] + ", " + next[i]); // sanity checks complete this.labelId = labelId; this.enable = enable; this.next = next; this.verbose = verbose; if (verbose) System.out.println("ActiveButtonState created OK"); } void check(int i, int nButtons, int nStates, String[][] label) throws ActiveButtonControl.BadArguments { if (verbose) System.out.println("ActiveButtonState " + i + " checking labelId.length (" + nButtons + ", " + labelId.length + ") ..."); if (labelId.length != nButtons) throw new ActiveButtonControl.BadArguments("state[" + i + "]: table lengths != nButtons"); if (verbose) System.out.println("ActiveButtonState " + i + " checking next.length ..."); for (int n = 0; n < next.length; n++) if (next[n] >= nStates) throw new ActiveButtonControl.BadArguments("state[" + i + "]: next[" + n + "] is too big"); if (verbose) System.out.println("ActiveButtonState " + i + " checking labelId[n] ..."); for (int n = 0; n < labelId.length; n++) if (labelId[n] >= label[n].length) throw new ActiveButtonControl.BadArguments("state[" + i + "]: labelId[" + n + "] is too big"); if (verbose) System.out.println("ActiveButtonState " + i + " checked"); } /** * This gets thrown if a consistency check fails in the {@link ActiveButtonState} * constructor. */ public static class BadArguments extends Exception { /** * * @param s details of the consistency failure. */ public BadArguments(String s) { super(s); } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/package.html 0000644 0000000 0000000 00000001376 11077340707 016233 0 ustar
This provides CSP extensions for all AWT {@link java.awt.Component} components: GUI events and widget configurations map to channel communications.Each AWT component (e.g. {@link java.awt.Button}) is mirrored by an active {@link org.jcsp.lang.CSProcess process} (e.g. {@link org.jcsp.awt.ActiveButton}) that works to a channel interface. GUI events are signalled as output messages sent on channels coming from the CSP component. Each component may be dynamically configured by sending it a message on its configuration channel.
The JCSP-AWT components may be wired up to any (JCSP) application network. This allows a safe and natural approach to GUI building as a (multi-threaded) network of communicating processes. jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveFrame.java 0000644 0000000 0000000 00000042555 11105701167 017000 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.Frame java.awt.Frame} * with a channel interface. *
Process Diagram
*
Description
* ActiveFrame is a process extension of java.awt.Frame * with channels for run-time configuration and event notification. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure and event channels are * settable from a constructor. * The event channel delivers a WindowEvent whenever one is generated * on the ActiveFrame. * Other event channels can be added to notify the occurrence of any other events * the component generates (by calling the appropriate * addXXXEventChannel method before the process is run). * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myWindowEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * final One2OneChannel myMouseEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveFrame myFrame = new ActiveFrame (myWindowEvent.out ()); * myFrame.addMouseEventChannel (myMouseEvent.out ()); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *Boolean | *
*
|
*
| ActiveFrame.Configure | *Invoke the user-defined Configure.configure method on the frame. | *|
| Output Channels | *||
| event | *WindowEvent | *The WindowEvent generated by the component | *
| containerEvent | *ContainerEvent | *See the {@link #addContainerEventChannel * addContainerEventChannel} method. | *
| componentEvent | *ComponentEvent | *See the {@link #addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the {@link #addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the {@link #addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the {@link #addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the {@link #addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import java.awt.*;
* import java.awt.event.*;
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
*
* public class ActiveFrameButtonExample {
*
* public static void main (String argv[]) {
*
* final Any2OneChannel windowEvent = Channel.any2one (new OverWriteOldestBuffer (10));
*
* final ActiveFrame frame =
* new ActiveFrame (null, windowEvent.out (), "ActiveButton Example");
*
* final String[] label = {"Hello World", "Rocket Science", "CSP",
* "Monitors", "Ignore Me", "Goodbye World"};
*
* final Any2OneChannel buttonEvent = Channel.any2one (new OverWriteOldestBuffer (10));
*
* final ActiveButton[] button = new ActiveButton[label.length];
* for (int i = 0; i < label.length; i++) {
* button[i] = new ActiveButton (null, buttonEvent.out (), label[i]);
* }
*
* frame.setSize (300, 200);
* frame.setLayout (new GridLayout (label.length/2, 2));
* for (int i = 0; i < label.length; i++) {
* frame.add (button[i]);
* }
* frame.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* new Parallel (button),
* new CSProcess () { // respond to window events
* public void run () {
* boolean running = true;
* while (running) {
* final WindowEvent w = (WindowEvent) windowEvent.in ().read ();
* System.out.println ("Window event: " + w);
* running = (w.getID () != WindowEvent.WINDOW_CLOSING);
* }
* frame.setVisible (false);
* System.exit (0);
* }
* },
* new CSProcess () { // respond to button events
* public void run () {
* boolean running = true;
* while (running) {
* final String s = (String) buttonEvent.in ().read ();
* System.out.println ("Button `" + s + "' pressed ...");
* running = (s != label[label.length - 1]);
* }
* frame.setVisible (false);
* System.exit (0);
* }
* }
* }
* ).run ();
*
* }
*
* }
*
*
* @see org.jcsp.awt.ActiveClosingFrame
* @see java.awt.Frame
* @see java.awt.event.ContainerEvent
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveFrame extends Frame implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* Constructs a new ActiveFrame with no title and no configuration
* or event channels.
*
*/
public ActiveFrame()
{
this(null, null, "");
}
/**
* Constructs a new ActiveFrame with a title but no configuration
* or event channels.
*
* @param title the title for the frame.
*/
public ActiveFrame(String title)
{
this(null, null, title);
}
/**
* Constructs a new ActiveFrame with configuration
* and event channels, but no title.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event a WindowEvent will be output whenever it occurs
* -- can be null if no notification is required.
*/
public ActiveFrame(ChannelInput configure, ChannelOutput event)
{
this(configure, event, "");
}
/**
* Constructs a new ActiveFrame with configuration
* and event channels and a title.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event a WindowEvent will be output whenever it occurs
* -- can be null if no notification is required.
* @param title the title for the frame.
*/
public ActiveFrame(ChannelInput configure, ChannelOutput event, String title)
{
super(title);
if (event != null)
{
WindowEventHandler handler = new WindowEventHandler(event);
addWindowListener(handler);
vec.addElement(handler);
}
this.configure = configure;
}
/**
* Sets the configuration channel for this ActiveFrame.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* Add a new channel to this component that will be used to notify that
* a ContainerEvent has occurred. This should be used
* instead of registering a ContainerListener with the component. It is
* possible to add more than one Channel by calling this method multiple times
* If the channel passed is null, no action will be taken.
* * NOTE: This method must be called before this process is run. * * @param containerEvent the channel down which to send ContainerEvents. */ public void addContainerEventChannel(ChannelOutput containerEvent) { if (containerEvent != null) { ContainerEventHandler handler = new ContainerEventHandler(containerEvent); addContainerListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a ComponentEvent has occurred. This should be used * instead of registering a ComponentListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param componentEvent the channel down which to send ComponentEvents. */ public void addComponentEventChannel(ChannelOutput componentEvent) { if (componentEvent != null) { ComponentEventHandler handler = new ComponentEventHandler(componentEvent); addComponentListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a FocusEvent has occurred. This should be used * instead of registering a FocusListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param focusEvent the channel down which to send FocusEvents. */ public void addFocusEventChannel(ChannelOutput focusEvent) { if (focusEvent != null) { FocusEventHandler handler = new FocusEventHandler(focusEvent); addFocusListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a KeyEvent has occurred. This should be used * instead of registering a KeyListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param keyEvent the channel down which to send KeyEvents. */ public void addKeyEventChannel(ChannelOutput keyEvent) { if (keyEvent != null) { KeyEventHandler handler = new KeyEventHandler(keyEvent); addKeyListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseEvent has occurred. This should be used * instead of registering a MouseListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseEvent the channel down which to send MouseEvents. */ public void addMouseEventChannel(ChannelOutput mouseEvent) { if (mouseEvent != null) { MouseEventHandler handler = new MouseEventHandler(mouseEvent); addMouseListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseMotionEvent has occurred. This should be used * instead of registering a MouseMotionListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseMotionEvent the channel down which to send MouseMotionEvents. */ public void addMouseMotionEventChannel(ChannelOutput mouseMotionEvent) { if (mouseMotionEvent != null) { MouseMotionEventHandler handler = new MouseMotionEventHandler(mouseMotionEvent); addMouseMotionListener(handler); vec.addElement(handler); } } /** * This enables general configuration of this component. Any object implementing * this interface and sent down the configure channel to this component will have its * configure method invoked on this component. *
* For an example, see {@link ActiveApplet.Configure}. */ static public interface Configure { /** * @param frame the Frame being configured. */ public void configure(final Frame frame); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message == null) break; else if (message instanceof Boolean) { if (message == Boolean.TRUE) setVisible(true); else if (message == Boolean.FALSE) setVisible(false); } else if (message instanceof Configure) ((Configure) message).configure(this); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveApplet.java 0000644 0000000 0000000 00000153656 11111260160 017166 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.applet.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.applet.Applet java.applet.Applet} * with a channel interface, specialising in the operation * of {@link org.jcsp.lang.CSProcess} networks as applets. *
* Shortcut to the Constructor and Method Summaries. *
Description
* ActiveApplet is an extension of {@link java.applet.Applet} to simplify * the management of an associated {@link org.jcsp.lang.CSProcess}. There are three * areas of provision: *-
*
- * controlling the execution of the associated process; *
- * a channel interface to and from the underlying {@link java.awt.Panel}; *
- * some methods to help accessing applet parameters. *
Applet Processes
* In an application, a network of processes can be executed simply by invoking run * on the defining ({@link org.jcsp.lang.Parallel}) process from the main thread of control. * We cannot do this from the applet init or start methods since * the browser would freeze until the process network terminated. Instead, the process * network must be started asynchronously with the applet thread. This can be achieved * by using a {@link org.jcsp.lang.ProcessManager}. ** We could do this by directly extending the {@link java.applet.Applet} class and * overriding its start, stop and destroy methods suitably - * however, the necessary logic has already been built into this class. All the user * needs to do is override the init method to contruct the desired * {@link org.jcsp.lang.CSProcess} and register it with this ActiveApplet * (by means of the {@link #setProcess setProcess} method). *
* For example: *
* import org.jcsp.awt.*;
*
* public class Flasher extends ActiveApplet {
*
* public void init () {
* setProcess (new FlasherNetwork (500, this));
* }
*
* }
*
* In the above, FlasherNetwork is the CSProcess that will be run
* by the ActiveApplet. The 500 parameter defines the period
* (in milliseconds) of its flashing and should really
* be a parameter of the applet itself.
* The reason for passing the reference to this into the FlasherNetwork
* process is explained in the description of its implementation
* in the next section.
*
* Default ActiveApplet stop/start/destroy Behaviour
* The default behaviours of the start, stop and destroy methods * implemented by this ActiveApplet are as follows. ** When the HTML browser invokes start for the first * time, the CSProcess (registered by the {@link #setProcess setProcess} * method) will be set running in its own thread of control. As the browser subsequently * invokes stop and start methods, events will be posted to channels * which may be optionally registered with the Applet. *
* When the browser invokes destroy, an event will be posted to the optionally * registered channel. If this is not present or does not cause network termination the * process network will be forcefully destroyed. *
*
Sun's Java Plug-in
* Most of the problems arising from the default ActiveApplet * controls are avoided by taking note of the following: **
| * Use of this ActiveApplet class is recommended only for browsers on systems * that have installed Sun's * Java Plug-in. * | *
* This has the robust behaviour of invoking a destroy immediately following * a stop whenever we leave a web page containing a Plug-in controlled * applet. It re-launches the applet from scratch whenever we return. Whilst this * removes the option of allowing applets continued execution during visits to other * pages (but see the cheat), it does relieve various deadlock problems * that may otherwise strike our browser. *
* Note: to use the Java Plug-in, HTML pages containing applets must be * transformed using the * Java Plug-in HTML Converter. * This renders the HTML somewhat more complex than it was before conversion, * but the results are worthwhile. * A browser visiting such a page without the Plug-in installed is invited * to install it - a link is offered to make this easy. * *
User-Defined Applet stop/start/destroy Behaviours
* The applet stop, start and destroy methods can, * of course, be overridden by the user to interact in some user-chosen way with * the process associated with the ActveApplet. * However, the proper way to interact with a process is to communicate with it over * a channel and support for this is provided without the user having to override anything. ** The methods {@link #setStopStartChannel setStopStartChannel} and * {@link #setDestroyChannels setDestroyChannels} let us connect special channels * to the ActveApplet process: *
* If a pair of destroy/destroyAck channels have been set, * an {@link #DESTROY ActiveApplet.DESTROY} will be written to the destroy * channel when the browser invokes its destroy method. * The browser will wait for up to {@link #DEFAULT_TIMEOUT_ACK 10 seconds} (by default) * for the applet process to respond with a message on destroyAck, before * proceeding to execute the default destroy mechanisms. * The timeout period can be specified (or disabled) * {@link ActiveApplet#setDestroyChannels(org.jcsp.lang.ChannelOutputInt,org.jcsp.lang.AltingChannelInputInt,int) when the channels are set}. *
* These channels should be set up either as an explicit part of the init * method (and passed to the user process as a constructor or mutator parameter) or * by the user process constructor itself (to which this ActveApplet * would have had to have been passed). It is important that these channels are in place * before the user process starts running (otherwise the default mechanism may be triggered * if the user quits the ActveApplet web page or the browser too quickly). *
* It is crucial, of course, that these communications are accepted by the user process * associated with the ActveApplet. Using a channel configured with * an overwriting buffer (of capacity one) will ensure this. Note that this overwriting * cannot cause the loss of any significant information to the user process. *
* The stop/start and destroy operations are implemented * via separately set channels so that the designer may make separate decisions on whether * to use each of them. *
* Freezing a process network (e.g. in response to * a {@link #STOP} is usually easy to arrange - just pinch the data-flow at a crucial * point to achieve a temporary deadlock. When the {@link #START} message arrives, * just let go. *
* Note: if the Java Plug-in is not * being used, it is strongly recommended to set and operate this stopStart channel * (rather than rely on the default suspend operations). *
* Note: if the Java Plug-in is being used, user-defined * behaviour for the stop/start operations are not needed. * Any stop is quickly followed by a destroy (for which the default * ActveApplet response will release any locked resource). * Second invocations of start never take place. * *
* The destroy/destroyAck channels enable the process network to * tidy up any created resources (e.g. to make invisible and dispose of any widgets * spawned off the web page) before termination. * Correctly terminating a process network (e.g. in response to a destroy) * is usually harder to arrange safely - so it may be better to leave this to the * default mechanism (which will follow the destroyAck signal). However, * secure CSP algorithms, at least for 1-1 channels, are known * (e.g. the graceful termination protocol) * and support for this may be provided in later versions of this library. *
* Note: if the destroy/destroyAck channels have been set, * the default suspend mechanism (if not already overridden by setting * a stopStart channel) will be suppressed. This is because the browser invokes * the stop method immediately before invoking the destroy. * If we did not do this, the suspended network would not be able to respond * to the destroy channel. *
* *
The ActveApplet as an ActivePanel
* An ActveApplet extends a {@link java.applet.Applet java.applet.Applet} * which extends a {@link java.awt.Panel java.awt.Panel}. Most activeApplets * will just use this panel as a container for other active GUI processes that * form part of their ActiveApplet network. However, if there is a need for run-time * configuration of the underlying panel and/or reaction to GUI events occurring on the * panel, the ActveApplet can itself be used as a process in that network. * Fot this case, an ActveApplet has a channel interface (which, together with * the browser control channels, extends that offered by * an {@link org.jcsp.awt.ActivePanel}): *
* All channels are optional. The configure channel is connected by invoking * the {@link #setConfigureChannel setConfigureChannel} method. * Event channels can be added to notify the occurrence of any type of Event * the component generates (by calling the appropriate * addXXXEventChannel method before the process is run). * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myMouseEvent = * Channel.one2one (new OverWriteOldestBuffer (n)); * * activeApplet.addMouseEventChannel (myMouseEvent); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| destroyAck | *int | *See the {@link #setDestroyChannels * setDestroyChannels} methods. | *
| configure | *{@link ActiveApplet.Configure ActiveApplet.Configure} | *Invoke the user-defined Configure.configure method on the applet. | *
| Output Channels | *||
| stopStart | *int | *See the {@link #setStopStartChannel * setStopStartChannel} method. | *
| destroy | *int | *See the {@link #setDestroyChannels * setDestroyChannels} methods. | *
| containerEvent | *ContainerEvent | *See the {@link #addContainerEventChannel * addContainerEventChannel} method. | *
| componentEvent | *ComponentEvent | *See the {@link #addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the {@link #addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the {@link #addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the {@link #addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the {@link #addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
* This example continues the Flasher example * introduced earlier. * FlasherNetwork consists of two processes: one is the ActiveApplet * (supplied as a parameter to its constructor) and the other is a user-written * FlasherControl. Here is the network diagram: *
* Here is the code to set up this process: *
* import org.jcsp.lang.*;
* import org.jcsp.awt.*;
*
* public class FlasherNetwork implements CSProcess {
*
* final private long period;
* final private ActiveApplet activeApplet;
*
* public FlasherNetwork (final long period,
* final ActiveApplet activeApplet) {
* this.period = period;
* this.activeApplet = activeApplet;
* }
*
* public void run () {
*
* final One2OneChannel mouseEvent = Channel.one2one ();
* final One2OneChannel appletConfigure = Channel.one2one ();
*
* activeApplet.addMouseEventChannel (mouseEvent.out ());
* activeApplet.setConfigureChannel (appletConfigure.in ());
*
* new Parallel (
* new CSProcess[] {
* activeApplet,
* new FlasherControl (period, mouseEvent.in (), appletConfigure.out ())
* }
* ).run ();
*
* }
*
* }
*
* FlasherControl demonstrates three basic JCSP techniques:
* -
*
- * {@link org.jcsp.lang.Alternative ALTing} between guards (a channel * communication and a timeout); *
- * {@link org.jcsp.lang.Alternative ALTing} with pre-conditions * (the mouse must be present in the applet for the flashing - controlled * by the timeout - to take place); *
- * construction and use of general configuration objects for an Active GUI * process (including the double-buffering needed for security when reusing these * objects - see the note in {@link ActiveApplet.Configure}). *
* import org.jcsp.lang.*;
* import org.jcsp.awt.*;
* import java.awt.*;
* import java.awt.event.*;
* import java.util.*;
*
* public class FlasherControl implements CSProcess {
*
* final private long period;
* final private AltingChannelInput mouseEvent;
* final private ChannelOutput appletConfigure;
*
* public FlasherControl (final long period,
* final AltingChannelInput mouseEvent,
* final ChannelOutput appletConfigure) {
* this.period = period;
* this.mouseEvent = mouseEvent;
* this.appletConfigure = appletConfigure;
* }
*
* private class AppletColour implements ActiveApplet.Configure {
* private Color colour = Color.lightGray;
* public void setColour (Color colour) {
* this.colour = colour;
* }
* public void configure (java.applet.Applet applet) {
* applet.setBackground (colour);
* }
* }
*
* public void run () {
*
* final Random random = new Random ();
* final CSTimer tim = new CSTimer ();
*
* final Alternative alt = new Alternative (new Guard[] {mouseEvent, tim});
* final boolean[] preCondition = {true, false};
* final int MOUSE = 0;
* final int TIMER = 1;
*
* final AppletColour[] appletColour = {new AppletColour (), new AppletColour ()};
* final AppletColour panelBlack = new AppletColour ();
* panelBlack.setColour (Color.black);
*
* appletConfigure.write (panelBlack);
*
* int index = 0;
* AppletColour appletCol = appletColour[index];
* appletCol.setColour (new Color (random.nextInt ()));
*
* long timeout = tim.read ();
* boolean mousePresent = false;
* boolean running = true;
*
* while (running) {
*
* switch (alt.priSelect (preCondition)) {
*
* case MOUSE:
* switch (((MouseEvent) mouseEvent.read ()).getID ()) {
* case MouseEvent.MOUSE_ENTERED:
* if (! mousePresent) {
* mousePresent = true;
* timeout = tim.read () + period;
* tim.setAlarm (timeout);
* appletConfigure.write (appletCol);
* preCondition[TIMER] = true;
* }
* break;
* case MouseEvent.MOUSE_EXITED:
* if (mousePresent) {
* mousePresent = false;
* appletConfigure.write (panelBlack);
* preCondition[TIMER] = false;
* }
* break;
* }
* break;
*
* case TIMER:
* timeout += period;
* tim.setAlarm (timeout);
* index = 1 - index;
* appletCol = appletColour[index];
* appletCol.setColour (new Color (random.nextInt ()));
* appletConfigure.write (appletCol);
* break;
*
* }
*
* }
*
* }
*
* }
*
*
* Accessing Applet Parameters
* ActveApplet provides a set of methods for simplifying * the acquisition of parameters from the HTML source code. These methods are not * specific for JCSP - they are useful for any applets. ** All methods getAppletXXX have the same form, where XXX * is one of Java's primitive types (int, boolean, byte, * short, long, float and double). Each returns * an XXX value, parsed from the applet parameter named in the method's * first parameter. A standby value must be supplied in case the named * applet parameter does not exist or parse correctly. The number returning methods * must supply min and max values against which the applet supplied * value will be checked - values below min being truncated to min * and values above max to max. *
* For example, Flasher should really * acquire its period value as an applet parameter: *
* import org.jcsp.lang.*;
* import org.jcsp.awt.*;
* import java.awt.*;
*
* public class Flasher extends ActiveApplet {
*
* public static final int minPeriod = 300; // milliseconds
* public static final int maxPeriod = 1000; // milliseconds
* public static final int defaultPeriod = 500; // milliseconds
*
* public void init () {
*
* final int period =
* getAppletInt ("period", minPeriod, maxPeriod, defaultPeriod);
*
* setProcess (new FlasherNetwork (period, this));
*
* }
*
* }
*
* Now, if no applet parameter "period" is present, the defaultPeriod
* is chosen. Same if the parameter was present but doesn't parse. Otherwise,
* values below minPeriod are rounded up to minPeriod,
* values above maxPeriod are rounded down to maxPeriod
* and good values are just accepted.
*
* @see java.applet.Applet
* @see java.awt.Panel
* @see java.awt.event.ContainerEvent
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveApplet extends Applet implements CSProcess
{
/**
* The process defining the behaviour of this Applet.
*/
private CSProcess process = null;
/**
* This must be called during the init() method for this ActiveApplet.
* It defines the process that is to be managed.
*
* @param process the process defining the applet behaviour.
*/
public void setProcess(final CSProcess process)
{
this.process = process;
}
/**
* The ProcessManager used to control the execution of this Applet.
*/
private ProcessManager manager = null;
/**
* TRUE iff the applet is currently active.
*/
private boolean started = false;
/**
* This value is sent down a {@link #setStopStartChannel stopStart} channel
* when the browser invokes a stop -
* see the user-defined stop/start response.
*/
public static final int STOP = 0;
/**
* This value is sent down a {@link #setStopStartChannel stopStart} channel
* on second and subsequent browser invocations of start -
* see the user-defined stop/start response.
*/
public static final int START = 1;
/**
* This value is sent down a {@link #setDestroyChannels destroy} channel
* when the browser invokes a destroy -
* see the user-defined destroy response.
*/
public static final int DESTROY = 2;
/**
* This is the default time (in milliseconds) that the browser will wait for the applet
* process to acknowledge (on destroyAck) a DESTROY message
* (sent down destroy). The default value is 10000 (i.e. 10 seconds).
* See the user-defined destroy response.
*/
public static final int DEFAULT_TIMEOUT_ACK = 10000;
/**
* This is the time (in milliseconds) that the browser will wait for the applet
* process to acknowledge (on destroyAck) a DESTROY message
* (sent down destroy). If negative, no timeout will be set.
* * The default value is 10000 (i.e. 10 seconds). */ private int timeoutAck = DEFAULT_TIMEOUT_ACK; /** * If this channel is set, the default stop/start behaviour changes - * see the user-defined stop/start response. */ private ChannelOutputInt stopStart = null; /** * If this channel is set, the default destroy behaviour changes - * see the user-defined destroy response. */ private ChannelOutputInt destroy = null; /** * If this channel is set, the default destroy behaviour changes - * see the user-defined destroy response. */ private AltingChannelInputInt destroyAck = null; private final CSTimer tim = new CSTimer(); private Alternative destroyAlt; private final int ACKNOWLEDGE = 0; private final int TIMEOUT = 1; /** * This sets a stopStart channel to allow * a user-defined stop/start response. * If the channel passed is null, no action will be taken. * * @param stopStart the channel controlling the stop/start behaviour of the applet. */ public void setStopStartChannel(final ChannelOutputInt stopStart) { this.stopStart = stopStart; } /** * This sets destroy/destroyAck channels to allow * a user-defined destroy response. * If either channel passed is null, no action will be taken. * A {@link #DEFAULT_TIMEOUT_ACK default timeout delay} (10000 milliseconds) * for the applet process to acknowledge the destroy signal is set. * * @param destroy the channel to which a {@link #DESTROY} will be written. * @param destroyAck the acknowledgement channel associated with destroy. */ public void setDestroyChannels(final ChannelOutputInt destroy, final AltingChannelInputInt destroyAck) { setDestroyChannels(destroy, destroyAck, DEFAULT_TIMEOUT_ACK); } /** * This sets destroy/destroyAck channels to allow * a user-defined destroy response. * If either channel passed is null, no action will be taken. * The timeout delay for the applet process to acknowledge the destroy * signal is set by timeoutAck. If this is set negative, * no timeout will be set - i.e. the browser will wait indefinitely (which may * cause a problem if the applet process is mis-programmed). * * @param destroy the channel to which a {@link #DESTROY} will be written. * @param destroyAck the acknowledgement channel associated with destroy. * @param timeoutAck the timeout (in milliseconds) allowed for the acknowledgement * - if negative, no timeout will be set. */ public void setDestroyChannels(final ChannelOutputInt destroy, final AltingChannelInputInt destroyAck, final int timeoutAck) { if ((destroy != null) && (destroyAck != null)) { this.destroy = destroy; this.destroyAck = destroyAck; this.timeoutAck = timeoutAck; this.destroyAlt = new Alternative(new Guard[] {destroyAck, tim}); } } /** * Called by the browser when the ActiveApplet is first started and each time * its web page is revisited. See above for the default and * user-definable behaviours obtainable from this method. */ public void start() { if (manager != null) { if (!started) { manager.start(); started = true; } if (stopStart != null) stopStart.write(START); } else { if (process == null) System.err.println("*** org.jcsp.awt.ActiveApplet: no process defined"); else { Parallel.resetDestroy(); manager = new ProcessManager(process); manager.start(); started = true; } } } /** * Called by the browser when the web page containing this ActiveApplet is * replaced by another page or just before this ActiveApplet is to be destroyed. * See above for the default and * user-definable behaviours obtainable from this method. */ public void stop() { if (manager != null) { if (stopStart != null) stopStart.write(STOP); else { manager.interrupt(); // used to call stop() ... started = false; } } } /** * Called by the browser when the ActiveApplet needs to be destroyed. * See above for the default and * user-definable behaviours obtainable from this method. */ public void destroy() { if (manager != null) { if (destroy != null) { destroy.write(DESTROY); if (timeoutAck < 0) destroyAck.read(); else { tim.setAlarm(tim.read() + timeoutAck); switch (destroyAlt.select()) { case ACKNOWLEDGE: destroyAck.read(); break; case TIMEOUT: break; } } } manager = null; process = null; } Parallel.destroy(); } //////////////////////////////////////////////////// // Special methods for applet parameter gathering // //////////////////////////////////////////////////// /** * This looks for the named parameter in the HTML applet source code * and attempts to parse it into an int. If all is well, the value is * checked that it lies between min and max inclusive and * then returned. If the parameter is not present or doesn't parse, * the standby value is returned. If the checks fail, the value * is truncated to either min or max (depending on the direction * of the error) and returned. * * @param parameter the applet parameter name. * @param min the minimum acceptable parameter value. * @param max the maximum acceptable parameter value. * @param standby the value to retun in case the applet parameter is bad. * * @return either the value of the named parameter or standby. */ public int getAppletInt(String parameter, int min, int max, int standby) { int i; final String s = getParameter(parameter); if (s == null) { System.out.println("*** Applet parameter " + parameter + " is missing - defaulting to " + standby); i = standby; } else try { i = Integer.parseInt(s); if (i < min) { System.out.println("*** Applet parameter " + parameter + " too small (" + i + ") - defaulting to " + min); i = min; } else if (i > max) { System.out.println("*** Applet parameter " + parameter + " too large (" + i + ") - defaulting to " + max); i = max; } } catch (NumberFormatException e) { System.out.println("*** Applet parameter " + parameter + " is not an integer (" + s + ") - defaulting to " + standby); i = standby; } return i; } /** * This looks for the named parameter in the HTML applet source code * and attempts to parse it into a boolean. If the parameter is not present * or doesn't parse, the standby value is returned. * * @param parameter the applet parameter name. * @param standby the value to retun in case the applet parameter is bad. * * @return either the value of the named parameter or standby. */ public boolean getAppletBoolean(String parameter, boolean standby) { final String s = getParameter(parameter); if (s == null) { System.out.println("*** Applet parameter " + parameter + " is missing - defaulting to " + standby); return standby; } final String sl = s.toLowerCase(); if (sl.equals("true")) return true; if (sl.equals("false")) return false; System.out.println("*** Applet parameter " + parameter + " is not a boolean - defaulting to " + standby); return standby; } /** * This looks for the named parameter in the HTML applet source code * and attempts to parse it into a byte. If all is well, the value is * checked that it lies between min and max inclusive and * then returned. If the parameter is not present or doesn't parse, * the standby value is returned. If the checks fail, the value * is truncated to either min or max (depending on the direction * of the error) and returned. * * @param parameter the applet parameter name. * @param min the minimum acceptable parameter value. * @param max the maximum acceptable parameter value. * @param standby the value to retun in case the applet parameter is bad. * * @return either the value of the named parameter or standby. */ public byte getAppletByte(String parameter, byte min, byte max, byte standby) { byte i; final String s = getParameter(parameter); if (s == null) { System.out.println("*** Applet parameter " + parameter + " is missing - defaulting to " + standby); i = standby; } else try { i = Byte.parseByte(s); if (i < min) { System.out.println("*** Applet parameter " + parameter + " too small (" + i + ") - defaulting to " + min); i = min; } else if (i > max) { System.out.println("*** Applet parameter " + parameter + " too large (" + i + ") - defaulting to " + max); i = max; } } catch (NumberFormatException e) { System.out.println("*** Applet parameter " + parameter + " is not a byte (" + s + ") - defaulting to " + standby); i = standby; } return i; } /** * This looks for the named parameter in the HTML applet source code * and attempts to parse it into a short. If all is well, the value is * checked that it lies between min and max inclusive and * then returned. If the parameter is not present or doesn't parse, * the standby value is returned. If the checks fail, the value * is truncated to either min or max (depending on the direction * of the error) and returned. * * @param parameter the applet parameter name. * @param min the minimum acceptable parameter value. * @param max the maximum acceptable parameter value. * @param standby the value to retun in case the applet parameter is bad. * * @return either the value of the named parameter or standby. */ public short getAppletShort(String parameter, short min, short max, short standby) { short i; final String s = getParameter(parameter); if (s == null) { System.out.println("*** Applet parameter " + parameter + " is missing - defaulting to " + standby); i = standby; } else try { i = Short.parseShort(s); if (i < min) { System.out.println("*** Applet parameter " + parameter + " too small (" + i + ") - defaulting to " + min); i = min; } else if (i > max) { System.out.println("*** Applet parameter " + parameter + " too large (" + i + ") - defaulting to " + max); i = max; } } catch (NumberFormatException e) { System.out.println("*** Applet parameter " + parameter + " is not a short (" + s + ") - defaulting to " + standby); i = standby; } return i; } /** * This looks for the named parameter in the HTML applet source code * and attempts to parse it into a long. If all is well, the value is * checked that it lies between min and max inclusive and * then returned. If the parameter is not present or doesn't parse, * the standby value is returned. If the checks fail, the value * is truncated to either min or max (depending on the direction * of the error) and returned. * * @param parameter the applet parameter name. * @param min the minimum acceptable parameter value. * @param max the maximum acceptable parameter value. * @param standby the value to retun in case the applet parameter is bad. * * @return either the value of the named parameter or standby. */ public long getAppletLong(String parameter, long min, long max, long standby) { long i; final String s = getParameter(parameter); if (s == null) { System.out.println("*** Applet parameter " + parameter + " is missing - defaulting to " + standby); i = standby; } else try { i = Long.parseLong(s); if (i < min) { System.out.println("*** Applet parameter " + parameter + " too small (" + i + ") - defaulting to " + min); i = min; } else if (i > max) { System.out.println("*** Applet parameter " + parameter + " too large (" + i + ") - defaulting to " + max); i = max; } } catch (NumberFormatException e) { System.out.println("*** Applet parameter " + parameter + " is not a long (" + s + ") - defaulting to " + standby); i = standby; } return i; } /** * This looks for the named parameter in the HTML applet source code * and attempts to parse it into a float. If all is well, the value is * checked that it lies between min and max inclusive and * then returned. If the parameter is not present or doesn't parse, * the standby value is returned. If the checks fail, the value * is truncated to either min or max (depending on the direction * of the error) and returned. * * @param parameter the applet parameter name. * @param min the minimum acceptable parameter value. * @param max the maximum acceptable parameter value. * @param standby the value to retun in case the applet parameter is bad. * * @return either the value of the named parameter or standby. */ public float getAppletFloat(String parameter, float min, float max, float standby) { float i; final String s = getParameter(parameter); if (s == null) { System.out.println("*** Applet parameter " + parameter + " is missing - defaulting to " + standby); i = standby; } else try { i = Float.valueOf(s).floatValue(); if (i < min) { System.out.println("*** Applet parameter " + parameter + " too small (" + i + ") - defaulting to " + min); i = min; } else if (i > max) { System.out.println("*** Applet parameter " + parameter + " too large (" + i + ") - defaulting to " + max); i = max; } } catch (NumberFormatException e) { System.out.println("*** Applet parameter " + parameter + " is not a float (" + s + ") - defaulting to " + standby); i = standby; } return i; } /** * This looks for the named parameter in the HTML applet source code * and attempts to parse it into a double. If all is well, the value is * checked that it lies between min and max inclusive and * then returned. If the parameter is not present or doesn't parse, * the standby value is returned. If the checks fail, the value * is truncated to either min or max (depending on the direction * of the error) and returned. * * @param parameter the applet parameter name. * @param min the minimum acceptable parameter value. * @param max the maximum acceptable parameter value. * @param standby the value to retun in case the applet parameter is bad. * * @return either the value of the named parameter or standby. */ public double getAppletDouble(String parameter, double min, double max, double standby) { double i; final String s = getParameter(parameter); if (s == null) { System.out.println("*** Applet parameter " + parameter + " is missing - defaulting to " + standby); i = standby; } else try { i = Double.valueOf(s).doubleValue(); if (i < min) { System.out.println("*** Applet parameter " + parameter + " too small (" + i + ") - defaulting to " + min); i = min; } else if (i > max) { System.out.println("*** Applet parameter " + parameter + " too large (" + i + ") - defaulting to " + max); i = max; } } catch (NumberFormatException e) { System.out.println("*** Applet parameter " + parameter + " is not a double (" + s + ") - defaulting to " + standby); i = standby; } return i; } //////////////////////////////////// // ActiveApplet as an ActivePanel // //////////////////////////////////// /** * The Vector construct containing the handlers. */ private Vector vec = new Vector(); /** * The channel from which configuration messages arrive. */ private ChannelInput configure; // /** // * Constructs a new ActiveApplet with no configuration channel. // */ // public ActiveApplet () { // this (null); // } // /** // * Constructs a new ActiveApplet with a configuration channel. // * // * @param configure the channel for configuration events // * -- can be null if no configuration is required. // */ // public ActiveApplet (ChannelInput configure) { // this.configure = configure; // } /** * Sets the configuration channel for this ActiveApplet. * * @param configure the channel for configuration events. * If the channel passed is null, no action will be taken. */ public void setConfigureChannel(ChannelInput configure) { this.configure = configure; } /** * Add a new channel to this component that will be used to notify that * a ContainerEvent has occurred. This should be used * instead of registering a ContainerListener with the component. It is * possible to add more than one Channel by calling this method multiple times. * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param containerEvent the channel down which to send ContainerEvents. */ public void addContainerEventChannel(ChannelOutput containerEvent) { if (containerEvent != null) { ContainerEventHandler handler = new ContainerEventHandler(containerEvent); addContainerListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a ComponentEvent has occurred. This should be used * instead of registering a ComponentListener with the component. It is * possible to add more than one Channel by calling this method multiple times. * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param componentEvent the channel down which to send ComponentEvents. */ public void addComponentEventChannel(ChannelOutput componentEvent) { if (componentEvent != null) { ComponentEventHandler handler = new ComponentEventHandler(componentEvent); addComponentListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a FocusEvent has occurred. This should be used * instead of registering a FocusListener with the component. It is * possible to add more than one Channel by calling this method multiple times. * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param focusEvent the channel down which to send FocusEvents. */ public void addFocusEventChannel(ChannelOutput focusEvent) { if (focusEvent != null) { FocusEventHandler handler = new FocusEventHandler(focusEvent); addFocusListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a KeyEvent has occurred. This should be used * instead of registering a KeyListener with the component. It is * possible to add more than one Channel by calling this method multiple times. * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param keyEvent the channel down which to send KeyEvents. */ public void addKeyEventChannel(ChannelOutput keyEvent) { if (keyEvent != null) { KeyEventHandler handler = new KeyEventHandler(keyEvent); addKeyListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseEvent has occurred. This should be used * instead of registering a MouseListener with the component. It is * possible to add more than one Channel by calling this method multiple times. * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseEvent the channel down which to send MouseEvents. */ public void addMouseEventChannel(ChannelOutput mouseEvent) { if (mouseEvent != null) { MouseEventHandler handler = new MouseEventHandler(mouseEvent); addMouseListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseMotionEvent has occurred. This should be used * instead of registering a MouseMotionListener with the component. It is * possible to add more than one Channel by calling this method multiple times. * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseMotionEvent the channel down which to send MouseMotionEvents. */ public void addMouseMotionEventChannel(ChannelOutput mouseMotionEvent) { if (mouseMotionEvent != null) { MouseMotionEventHandler handler = new MouseMotionEventHandler(mouseMotionEvent); addMouseMotionListener(handler); vec.addElement(handler); } } /** * This enables general configuration of this component. Any object implementing * this interface and sent down the configure channel to this component will * have its configure method invoked on this component. *
* For example, to set the foreground/background colours, first define: *
* private class AppletColours implements ActiveApplet.Configure {
*
* private Color foreground = Color.white;
* private Color background = Color.black;
*
* public void setColour (Color foreground, Color background) {
* this.foreground = foreground;
* this.background = background;
* }
*
* public void configure (java.applet.Applet applet) {
* applet.setForeground (foreground);
* applet.setBackground (background);
* }
*
* }
*
* Then, construct an instance of AppletColours, set its foreground/background
* colours as required and send it down the configure channel when appropriate.
* * Note that an instance of the above AppletColours may have its colours reset * and may be resent down the channel. To ensure against race-hazards, construct * at least two instances and use them alternately. Acceptance of one of them by the * ActiveApplet means that it has finished using the other and, therefore, * the other may be safely reset. So long as the configure channel is * unbuffered, completion of the write method means that the message has been * read (i.e. accepted) by the receiving process. */ static public interface Configure { /** * @param applet the Applet being configured. */ public void configure(final Applet applet); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message instanceof Configure) { ((Configure) message).configure(this); } } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveTextEnterArea.java 0000644 0000000 0000000 00000046052 11105701167 020455 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import org.jcsp.lang.*; import org.jcsp.util.*; import org.jcsp.plugNplay.*; import java.awt.event.*; /** * A specialisation of {@link ActiveTextArea} that writes text to * the event channel only when ESCAPE is pressed. *
Process Diagram
*
*
Description
* ActiveTextEnterArea is a process containing an {@link ActiveTextArea ActiveTextArea}, * configured with channels for event notification and configuration. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure and event channels are * settable from a constructor. *
* The difference between this class and ActiveTextArea is that text * is only written to the event channel when ESCAPE is pressed on * the text area (not on every keystroke). When this happens, the text area * is temporarilly disabled for (by default) half a second; this is to give * feedback to the user. The disable period can be changed by calling the * setDisableTime method before the process is run. *
* The internal ActiveTextArea can be extracted with the getActiveTextArea method. * Channels can then be added to notify the occurrence of any other type of Event * the ActiveFrame generates. This is done by calling its appropriate * addXXXEventChannel method (before the process * is run). As many channels can be added as are needed. *
* Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that the output channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. The simplest way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myTextAreaEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveTextEnterArea myTextEnterArea = * new ActiveTextEnterArea (null, myTextAreaEvent.out (), "Edit Me", 5, 20); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *String | *Append the string to the text in this ActiveTextEnterArea | *
| Boolean | *
*
|
* |
| ActiveTextArea.Configure | *Invoke the user-defined Configure.configure method on the textArea. | *|
| otherwise | *Append the toString form of the object to the text in this ActiveTextArea. | *|
| Output Channels | *||
| event | *String | *The text in the ActiveTextEnterArea (whenever ESCAPE is pressed) | *
| componentEvent | *ComponentEvent | *See the * {@link #getActiveTextArea getActiveTextArea}.{@link ActiveTextArea#addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the * {@link #getActiveTextArea getActiveTextArea}.{@link ActiveTextArea#addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the * {@link #getActiveTextArea getActiveTextArea}.{@link ActiveTextArea#addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the * {@link #getActiveTextArea getActiveTextArea}.{@link ActiveTextArea#addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the * {@link #getActiveTextArea getActiveTextArea}.{@link ActiveTextArea#addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
* import java.awt.*;
*
* public class ActiveTextEnterAreaExample {
*
* public static void main (String argv[]) {
*
* final ActiveClosingFrame frame =
* new ActiveClosingFrame ("ActiveTextEnterArea Example");
*
* final Any2OneChannel event = Channel.any2one (new OverWriteOldestBuffer (10));
*
* final String[] string =
* {"Entia Non Sunt Multiplicanda Praeter Necessitatem",
* "Everything we do, we do it to you",
* "Race Hazards - What Rice Hozzers?",
* "Cogito Ergo Occam"};
*
* final String goodbye = "Goodbye World";
*
* final ActiveTextEnterArea[] activeText =
* new ActiveTextEnterArea[string.length];
*
* for (int i = 0; i < string.length; i++) {
* activeText[i] = new ActiveTextEnterArea (null, event.out (), string[i], 5, 40);
* }
*
* Panel panel = new Panel (new GridLayout (string.length/2, 2));
* for (int i = 0; i < string.length; i++) {
* panel.add (activeText[i].getActiveTextArea ());
* }
*
* final Frame realFrame = frame.getActiveFrame ();
* realFrame.setBackground (Color.green);
* realFrame.add (panel);
* realFrame.pack ();
* realFrame.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* frame,
* new Parallel (activeText),
* new CSProcess () {
* public void run () {
* boolean running = true;
* while (running) {
* String s = (String) event.in ().read ();
* System.out.println (s);
* running = (! s.equals (goodbye));
* }
* realFrame.setVisible (false);
* System.exit (0);
* }
* }
* }
* ).run ();
* }
*
* }
*
*
* @see org.jcsp.awt.ActiveTextArea
* @see java.awt.TextArea
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveTextEnterArea implements CSProcess
{
private AltingChannelInput configure;
private ChannelOutput event;
private String s;
private int rows;
private int columns;
private int scrollbars;
private long disableTime = 500;
private ActiveTextArea area;
private One2OneChannel keyEvent = Channel.one2one(new OverWriteOldestBuffer(10));
private One2OneChannel textEvent = Channel.one2one(new OverWriteOldestBuffer(10));
private One2OneChannel configureA = Channel.one2one();
private One2OneChannel configureB = Channel.one2one();
/**
* Constructs a new ActiveTextEnterArea with scrollbars, but with no configuration
* or event channels or initial text or size.
*/
public ActiveTextEnterArea()
{
this(null, null, "", 0, 0, java.awt.TextArea.SCROLLBARS_BOTH);
}
/**
* Constructs a new ActiveTextEnterArea with scrollbars and initial text,
* but with no configuration or event channels or initial size.
*
* @param s the initial text displayed in the area.
*/
public ActiveTextEnterArea(String s)
{
this(null, null, s, 0, 0, java.awt.TextArea.SCROLLBARS_BOTH);
}
/**
* Constructs a new ActiveTextEnterArea with scrollbars and initial text and size,
* but with no configuration or event channels.
*
* @param s the initial text displayed in the area.
* @param rows the rows of the area.
* @param columns the columns of the area.
*/
public ActiveTextEnterArea(String s, int rows, int columns)
{
this(null, null, s, rows, columns, java.awt.TextArea.SCROLLBARS_BOTH);
}
/**
* Constructs a new ActiveTextEnterArea with user-defined scrollbars and initial text and size,
* but with no configuration or event channels.
*
* @param s the initial text displayed in the area.
* @param rows the rows of the area.
* @param columns the columns of the area.
* @param scrollbars the columns of the area (java.awt.TextArea.SCROLLBARS_BOTH,
* java.awt.TextArea.SCROLLBARS_VERTICAL_ONLY,
* java.awt.TextArea.SCROLLBARS_HORIZONTAL_ONLY
* or java.awt.TextArea.SCROLLBARS_NONE).
*/
public ActiveTextEnterArea(String s, int rows, int columns, int scrollbars)
{
this(null, null, s, rows, columns, scrollbars);
}
/**
* Constructs a new ActiveTextEnterArea with configuration and event channels and scrollbars,
* but with no initial text or size.
*
* @param configure the AltingChannelInput for configuration events
* -- can be null if no configuration is required.
* @param event the current text will be output when the text area is changed
* -- can be null if no notification is required.
*/
public ActiveTextEnterArea(AltingChannelInput configure, ChannelOutput event)
{
this(configure, event, "", 0, 0, java.awt.TextArea.SCROLLBARS_BOTH);
}
/**
* Constructs a new ActiveTextEnterArea with configuration and event channels
* and scrollbars and initial text, but with no initial size.
*
* @param configure the AltingChannelInput for configuration events
* -- can be null if no configuration is required.
* @param event the current text will be output when the text area is changed
* -- can be null if no notification is required.
* @param s the initial text displayed in the area.
*/
public ActiveTextEnterArea(AltingChannelInput configure, ChannelOutput event, String s)
{
this(configure, event, s, 0, 0, java.awt.TextArea.SCROLLBARS_BOTH);
}
/**
* Constructs a new ActiveTextEnterArea with configuration and event channels
* and scrollbars and initial text and size.
*
* @param configure the AltingChannelInput for configuration events
* -- can be null if no configuration is required.
* @param event the current text will be output when the text area is changed
* -- can be null if no notification is required.
* @param s the initial text displayed in the area.
* @param rows the rows of the area.
* @param columns the columns of the area.
*/
public ActiveTextEnterArea(AltingChannelInput configure, ChannelOutput event,
String s, int rows, int columns)
{
this(configure, event, s, rows, columns, java.awt.TextArea.SCROLLBARS_BOTH);
}
/**
* Constructs a new ActiveTextEnterArea with configuration and event channels
* and user-defined scrollbars and initial text and size.
*
* @param configure the AltingChannelInput for configuration events
* -- can be null if no configuration is required.
* @param event the current text will be output when the text area is changed
* -- can be null if no notification is required.
* @param s the initial text displayed in the area.
* @param rows the rows of the area.
* @param columns the columns of the area.
* @param scrollbars the columns of the area (java.awt.TextArea.SCROLLBARS_BOTH,
* java.awt.TextArea.SCROLLBARS_VERTICAL_ONLY,
* java.awt.TextArea.SCROLLBARS_HORIZONTAL_ONLY
* or java.awt.TextArea.SCROLLBARS_NONE).
*/
public ActiveTextEnterArea(AltingChannelInput configure, ChannelOutput event,
String s, int rows, int columns, int scrollbars)
{
if (configure == null)
this.configure = Channel.one2one().in(); // the Plex2 process must have non-null channels
else
this.configure = configure;
this.event = event;
this.s = s;
this.rows = rows;
this.columns = columns;
this.scrollbars = scrollbars;
this.area = new ActiveTextArea(configureB.in(), textEvent.out(), s, rows, columns, scrollbars);
}
/**
* Sets the configuration channel for this ActiveTextEnterArea.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public void setConfigureChannel(AltingChannelInput configure)
{
if (configure != null)
this.configure = configure; // the Plex2 process must have non-null channels
}
/**
* This is used to set the time during which the text area is disabled
* after an ESCAPE has been entered.
* * NOTE: This may only be called before this process is run. * * @param disableTime the disable time after an ESCAPE. */ public void setDisableTime(final long disableTime) { this.disableTime = disableTime; } /** * This is used to get the ActiveTextArea within this component * so that it can be configured (using {@link java.awt.TextArea} or * {@link org.jcsp.awt.ActiveTextArea} methods) or added to some container. * For example, event channels can be added by invoking * getActiveTextArea().addXXXEventChannel(...). *
* NOTE: such configuration must be finished before this process is run. *
* NOTE: do not use this method to set a configure channel - use an appropriate * constructor or {@link #setConfigureChannel setConfigureChannel}. * * @return the ActiveTextArea within this component. */ public ActiveTextArea getActiveTextArea() { return area; } /** * The main body of this process. */ public void run() { area.addKeyEventChannel(keyEvent.out()); new Parallel(new CSProcess[] { new Plex2(configure, configureA.in(), configureB.out()), area, new CSProcess() { public void run() { CSTimer tim = new CSTimer(); Guard[] guard = {keyEvent.in(), textEvent.in()}; Alternative alt = new Alternative(guard); String text = s; ChannelInput keyEventIn = keyEvent.in(); ChannelInput textEventIn = textEvent.in(); ChannelOutput configureAOut = configureA.out(); while (true) { switch (alt.priSelect()) { case 0: final KeyEvent key = (KeyEvent) keyEventIn.read(); switch (key.getKeyCode()) { case KeyEvent.VK_ESCAPE: switch (key.getID()) { case KeyEvent.KEY_PRESSED: if (event != null) event.write(text); configureAOut.write(Boolean.FALSE); tim.after(tim.read() + disableTime); configureAOut.write(Boolean.TRUE); break; } break; } break; case 1: text = (String) textEventIn.read(); break; } } } } }).run(); } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveButton.java 0000644 0000000 0000000 00000041727 11105701167 017221 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.Button java.awt.Button} * with a channel interface. *
Process Diagram
*
Description
* ActiveButton is a process extension of java.awt.Button * with channels for run-time configuration and event notification. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure and event channels are * settable from a constructor. * The event channel delivers the current button label whenever * the ActiveButton is pressed. * Other event channels can be added to notify the occurrence of any other events * the component generates (by calling the appropriate * addXXXEventChannel method before the process is run). * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myButtonEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveButton myButton = * new ActiveButton (null, myButtonEvent.out (), "Press Me"); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *String | *Change the label on the ActiveButton to the value of the String. | *
| Boolean | *
*
|
* |
| ActiveButton.Configure | *Invoke the user-defined Configure.configure method on the button. | *|
| Output Channels | *||
| event | *String | *The label on the ActiveButton (when the button is pressed and released). | *
| componentEvent | *ComponentEvent | *See the {@link #addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the {@link #addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the {@link #addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the {@link #addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the {@link #addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import java.awt.*;
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
*
* public class ActiveButtonExample {
*
* public static void main (String argv[]) {
*
* final Frame root = new Frame ("ActiveButton Example");
*
* final String[] label = {"Hello World", "Rocket Science", "CSP",
* "Monitors", "Ignore Me", "Goodbye World"};
*
* final Any2OneChannel event = Channel.any2one (new OverWriteOldestBuffer (10));
*
* final ActiveButton[] button = new ActiveButton[label.length];
* for (int i = 0; i < label.length; i++) {
* button[i] = new ActiveButton (null, event.out (), label[i]);
* button[i].setBackground (Color.green);
* }
*
* root.setSize (300, 200);
* root.setLayout (new GridLayout (label.length/2, 2));
* for (int i = 0; i < label.length; i++) {
* root.add (button[i]);
* }
* root.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* new Parallel (button),
* new CSProcess () {
* public void run () {
* boolean running = true;
* while (running) {
* final String s = (String) event.in ().read ();
* System.out.println ("Button `" + s + "' pressed ...");
* running = (s != label[label.length - 1]);
* }
* root.setVisible (false);
* System.exit (0);
* }
* }
* }
* ).run ();
* }
*
* }
*
*
* @see java.awt.Button
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveButton extends Button implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The Configurer.
*/
// private Configurer configurer = null;
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* Constructs a new ActiveButton with no label, configuration or
* event channels.
*/
public ActiveButton()
{
this("");
}
/**
* Constructs a new ActiveButton with no configuration or
* event channels.
*
* @param s the initial label displayed on the button.
*/
public ActiveButton(String s)
{
this(null, null, s);
}
/**
* Constructs a new ActiveButton with no initial label.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the current label will be output when the button is pressed
* -- can be null if no notification is required.
*/
public ActiveButton(ChannelInput configure, ChannelOutput event)
{
this(configure, event, "");
}
/**
* Constructs a new ActiveButton.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the current label will be output when the button is pressed
* -- can be null if no notification is required.
* @param s the initial label displayed on the button.
*/
public ActiveButton(ChannelInput configure, ChannelOutput event, String s)
{
super(s);
// Only create an event handler if the event Channel is not null.
if (event != null)
{
ActionEventHandler handler = new ActionEventHandler(event);
addActionListener(handler);
vec.addElement(handler);
}
this.configure = configure;
}
/**
* Sets the configuration channel for this ActiveButton.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* Add a new channel to this component that will be used to notify that
* the button has been pressed. This should be used
* instead of registering an ActionListener with the component. It is
* possible to add more than one channel by calling this method multiple times.
* If the channel passed is null, no action will be taken.
* This method is an alternative to setting such a channel in the constructor.
* * NOTE: This method must be called before this process is run. * * @param event the channel down which to send the current label * when the button is pressed. */ public void addEventChannel(ChannelOutput event) { if (event != null) { ActionEventHandler handler = new ActionEventHandler(event); addActionListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a ComponentEvent has occurred. This should be used * instead of registering a ComponentListener with the component. It is * possible to add more than one channel by calling this method multiple times. * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param componentEvent the channel down which to send ComponentEvents. */ public void addComponentEventChannel(ChannelOutput componentEvent) { if (componentEvent != null) { ComponentEventHandler handler = new ComponentEventHandler(componentEvent); addComponentListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a FocusEvent has occurred. This should be used * instead of registering a FocusListener with the component. It is * possible to add more than one channel by calling this method multiple times. * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param focusEvent the channel down which to send FocusEvents. */ public void addFocusEventChannel(ChannelOutput focusEvent) { if (focusEvent != null) { FocusEventHandler handler = new FocusEventHandler(focusEvent); addFocusListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a KeyEvent has occurred. This should be used * instead of registering a KeyListener with the component. It is * possible to add more than one channel by calling this method multiple times. * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param keyEvent the channel down which to send KeyEvents. */ public void addKeyEventChannel(ChannelOutput keyEvent) { if (keyEvent != null) { KeyEventHandler handler = new KeyEventHandler(keyEvent); addKeyListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseEvent has occurred. This should be used * instead of registering a MouseListener with the component. It is * possible to add more than one channel by calling this method multiple times. * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseEvent the channel down which to send MouseEvents. */ public void addMouseEventChannel(ChannelOutput mouseEvent) { if (mouseEvent != null) { MouseEventHandler handler = new MouseEventHandler(mouseEvent); addMouseListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseMotionEvent has occurred. This should be used * instead of registering a MouseMotionListener with the component. It is * possible to add more than one channel by calling this method multiple times. * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseMotionEvent the channel down which to send MouseMotionEvents. */ public void addMouseMotionEventChannel(ChannelOutput mouseMotionEvent) { if (mouseMotionEvent != null) { MouseMotionEventHandler handler = new MouseMotionEventHandler(mouseMotionEvent); addMouseMotionListener(handler); vec.addElement(handler); } } /** * This enables general configuration of this component. Any object implementing * this interface and sent down the configure channel to this component * will have its configure method invoked on this component. *
* For an example, see {@link ActiveApplet.Configure}. */ static public interface Configure { /** * @param button the Button being configured. */ public void configure(final Button button); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message == null) { break; } else if (message instanceof String) { setLabel((String) message); } else if (message instanceof Boolean) { if (message == Boolean.TRUE) { setEnabled(true); } else if (message == Boolean.FALSE) { setEnabled(false); } } else if (message instanceof Color) { setBackground((Color) message); } else if (message instanceof Configure) { ((Configure) message).configure(this); } } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActionEventHandler.java 0000644 0000000 0000000 00000005606 11105701167 020323 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.event.*; import org.jcsp.lang.*; /** * @author P.D. Austin and P.H. Welch */ class ActionEventHandler implements ActionListener { /** The Channel down which ActionEvent commands are sent. */ private ChannelOutput event; /** * constructs a new ActionEventHandler with the specified output Channel. * * @param event The Channel to send the event notification down */ public ActionEventHandler(ChannelOutput event) { this.event = event; } /** * Invoked when an action occurs on the component. It assumes the * event channel is being serviced (e.g. by an overwriting channel). * * @param e the parameter associated with this event */ public void actionPerformed(ActionEvent e) { event.write(e.getActionCommand()); } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveChoice.java 0000644 0000000 0000000 00000036254 11105701167 017137 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.Choice java.awt.Choice} * with a channel interface. *
Process Diagram
*
Description
* ActiveChoice is a process extension of java.awt.Choice * with channels for run-time configuration and event notification. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure and event channels are * settable from a constructor. * The event channel delivers the generated java.awt.ItemEvent whenever * an item from the ActiveChoice is selected. * Other event channels can be added to notify the occurrence of any other events * the component generates (by calling the appropriate * addXXXEventChannel method before the process is run). * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myChoiceEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveChoice myChoice = * new ActiveChoice (null, myChoiceEvent.out ()); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *String | ** Sets the selected item in this ActiveChoice menu to be the item * whose name is equal to the specified ActiveChoice. If more than * one item matches, the one with the smallest index is selected. * | *
| Integer | ** Sets the selected item in this ActiveChoice menu to be the item * at the specified position. * | *|
| Boolean | *
*
|
* |
| ActiveChoice.Configure | *Invoke the user-defined Configure.configure method on the choice. | *|
| Output Channels | *||
| event | *ItemEvent | ** When the ActiveChoice is operated, * the generated java.awt.ItemEvent is written down this channel. * | *
| componentEvent | *ComponentEvent | *See the {@link #addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the {@link #addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the {@link #addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the {@link #addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the {@link #addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import java.awt.*;
* import java.awt.event.*;
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
*
* public class ActiveChoiceExample {
*
* public static void main (String argv[]) {
*
* final Frame root = new Frame ("ActiveChoice Example");
*
* final One2OneChannel close = Channel.one2one (new OverWriteOldestBuffer (1));
*
* final ActiveChoice choice = new ActiveChoice (null, close.out ());
*
* final String[] menu = {"Hello World", "Rocket Science", "CSP",
* "Monitors", "Ignore Me", "Goodbye World"};
*
* for (int i = 0; i < menu.length; i++) {
* choice.add (menu[i]);
* }
*
* root.setSize (200, 100);
* root.add (choice);
* root.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* choice,
* new CSProcess () {
* public void run () {
* boolean running = true;
* while (running) {
* ItemEvent e = (ItemEvent) close.in ().read ();
* String item = (String) e.getItem ();
* System.out.println ("Selected ==> `" + item + "'");
* running = (item != menu[menu.length - 1]);
* }
* root.setVisible (false);
* System.exit (0);
* }
* }
* }
* ).run ();
*
* }
*
* }
*
*
* @see java.awt.Choice
* @see java.awt.event.ItemEvent
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveChoice extends Choice implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* Constructs an ActiveChoice with no configuration
* or event channels.
*/
public ActiveChoice()
{
this(null, null);
}
/**
* Constructs an ActiveChoice with configuration and event channels.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the ItemEvent will be output when the choice
* is exercised -- can be null if no notification is required.
*/
public ActiveChoice(ChannelInput configure, ChannelOutput event)
{
if (event != null)
{
ItemEventHandler handler = new ItemEventHandler(event);
addItemListener(handler);
vec.addElement(handler);
}
this.configure = configure;
}
/**
* Sets the configuration channel for this ActiveChoice.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* Add a new channel to this component that will be used to notify that
* a ComponentEvent has occurred. This should be used
* instead of registering a ComponentListener with the component. It is
* possible to add more than one channel by calling this method multiple times
* If the channel passed is null, no action will be taken.
* * NOTE: This method must be called before this process is run. * * @param componentEvent the channel down which to send ComponentEvents. */ public void addComponentEventChannel(ChannelOutput componentEvent) { if (componentEvent != null) { ComponentEventHandler handler = new ComponentEventHandler(componentEvent); addComponentListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a FocusEvent has occurred. This should be used * instead of registering a FocusListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param focusEvent the channel down which to send FocusEvents. */ public void addFocusEventChannel(ChannelOutput focusEvent) { if (focusEvent != null) { FocusEventHandler handler = new FocusEventHandler(focusEvent); addFocusListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a KeyEvent has occurred. This should be used * instead of registering a KeyListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param keyEvent the channel down which to send KeyEvents. */ public void addKeyEventChannel(ChannelOutput keyEvent) { if (keyEvent != null) { KeyEventHandler handler = new KeyEventHandler(keyEvent); addKeyListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseEvent has occurred. This should be used * instead of registering a MouseListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseEvent the channel down which to send MouseEvents. */ public void addMouseEventChannel(ChannelOutput mouseEvent) { if (mouseEvent != null) { MouseEventHandler handler = new MouseEventHandler(mouseEvent); addMouseListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseMotionEvent has occurred. This should be used * instead of registering a MouseMotionListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseMotionEvent the channel down which to send MouseMotionEvents. */ public void addMouseMotionEventChannel(ChannelOutput mouseMotionEvent) { if (mouseMotionEvent != null) { MouseMotionEventHandler handler = new MouseMotionEventHandler(mouseMotionEvent); addMouseMotionListener(handler); vec.addElement(handler); } } /** * This enables general configuration of this component. Any object implementing * this interface and sent down the configure channel to this component will have its * configure method invoked on this component. *
* For an example, see {@link ActiveApplet.Configure}. */ static public interface Configure { /** * @param choice the Choice being configured. */ public void configure(final Choice choice); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message instanceof String) select((String) message); else if (message instanceof Integer) select(((Integer) message).intValue()); else if (message instanceof Boolean) { if (message == Boolean.TRUE) setEnabled(true); else if (message == Boolean.FALSE) setEnabled(false); } else if (message instanceof Configure) ((Configure) message).configure(this); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveDialog.java 0000644 0000000 0000000 00000044266 11105701167 017146 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.Dialog java.awt.Dialog} * with a channel interface. *
Process Diagram
*
Description
* ActiveDialog is a process extension of java.awt.Dialog * with channels for run-time configuration and event notification. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure and event channels are * settable from a constructor. * The event channel delivers a WindowEvent whenever one is generated * on the ActiveDialog. * Other event channels can be added to notify the occurrence of any other events * the component generates (by calling the appropriate * addXXXEventChannel method before the process is run). * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component – no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced – otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myMouseEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveDialog myDialog = new ActiveDialog (); * myDialog.addMouseEventChannel (myMouseEvent.out ()); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *Boolean | *
*
|
*
| ActiveDialog.Configure | *Invoke the user-defined Configure.configure method on the dialog. | *|
| Output Channels | *||
| event | *WindowEvent | *The WindowEvent generated by the component | *
| containerEvent | *ContainerEvent | *See the {@link #addContainerEventChannel * addContainerEventChannel} method. | *
| componentEvent | *ComponentEvent | *See the {@link #addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the {@link #addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the {@link #addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the {@link #addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the {@link #addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import java.awt.*;
* import java.awt.event.*;
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
*
* public class ActiveDialogExample {
*
* public static void main (String argv[]) {
*
* final Frame root = new Frame ();
*
* final One2OneChannel event = Channel.one2one (new OverWriteOldestBuffer (10));
*
* final ActiveDialog dialog = new ActiveDialog (null, event.out (), root, "ActiveDialog Example");
*
* dialog.setSize (300, 200);
* dialog.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* dialog,
* new CSProcess () {
* public void run () {
* while (true) {
* WindowEvent w = (WindowEvent) event.in ().read ();
* System.out.println (w);
* }
* }
* }
* }
* ).run ();
* }
*
* }
*
*
* @see java.awt.Dialog
* @see java.awt.event.ContainerEvent
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveDialog extends Dialog implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* Constructs a new non-modal ActiveDialog with a blank title
* and no configuration or event channels.
*
* @param parent the parent frame for the dialog.
*/
public ActiveDialog(Frame parent)
{
this(null, null, parent, "", false);
}
/**
* Constructs a new ActiveDialog with a blank title
* and no configuration or event channels.
*
* @param parent the parent frame for the dialog.
* @param modal if true, dialog blocks input to the parent window when shown.
*/
public ActiveDialog(Frame parent, boolean modal)
{
this(null, null, parent, "", modal);
}
/**
* Constructs a new non-modal ActiveDialog
* with no configuration or event channels.
*
* @param parent the parent frame for the dialog.
* @param title the title of the dialog.
*/
public ActiveDialog(Frame parent, String title)
{
this(null, null, parent, title, false);
}
/**
* Constructs a new ActiveDialog
* with no configuration or event channels.
*
* @param parent the parent frame for the dialog.
* @param title the title of the dialog.
* @param modal if true, dialog blocks input to the parent window when shown.
*/
public ActiveDialog(Frame parent, String title, boolean modal)
{
this(null, null, parent, title, false);
}
/**
* Constructs a new non-modal ActiveDialog with a blank title.
*
* @param configure the channel for configuration events
* (can be null if no configuration is required).
* @param event the WindowEvent will be output whenever it occurs
* (can be null if no notification is required).
* @param parent the parent frame for the dialog.
*/
public ActiveDialog(ChannelInput configure, ChannelOutput event, Frame parent)
{
this(configure, event, parent, "", false);
}
/**
* Constructs a new ActiveDialog with a blank title.
*
* @param configure the channel for configuration events
* (can be null if no configuration is required).
* @param event the WindowEvent will be output whenever it occurs
* (can be null if no notification is required).
* @param parent the parent frame for the dialog.
* @param modal if true, dialog blocks input to the parent window when shown.
*/
public ActiveDialog(ChannelInput configure, ChannelOutput event, Frame parent, boolean modal)
{
this(configure, event, parent, "", modal);
}
/**
* Constructs a new non-modal ActiveDialog.
*
* @param configure the channel for configuration events
* (can be null if no configuration is required).
* @param event the WindowEvent will be output whenever it occurs
* (can be null if no notification is required).
* @param parent the parent frame for the dialog.
* @param title the title of the dialog.
*/
public ActiveDialog(ChannelInput configure, ChannelOutput event, Frame parent, String title)
{
this(configure, event, parent, title, false);
}
/**
* Constructs a new ActiveDialog.
*
* @param configure the channel for configuration events
* (can be null if no configuration is required).
* @param event the WindowEvent will be output whenever it occurs
* (can be null if no notification is required).
* @param parent the parent frame for the dialog.
* @param title the title of the dialog.
* @param modal if true, dialog blocks input to the parent window when shown.
*/
public ActiveDialog(ChannelInput configure, ChannelOutput event, Frame parent, String title, boolean modal)
{
super(parent, title, modal);
if (event != null)
{
WindowEventHandler handler = new WindowEventHandler(event);
addWindowListener(handler);
vec.addElement(handler);
}
this.configure = configure;
}
/**
* Sets the configuration channel for this ActiveDialog.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* (can be null if no configuration is required).
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* Add a new channel to this component that will be used to notify that
* a ContainerEvent has occurred. This should be used
* instead of registering a ContainerListener with the component. It is
* possible to add more than one Channel by calling this method multiple times
* If the channel passed is null, no action will be taken.
* * NOTE: This method must be called before this process is run. * * @param containerEvent the channel down which to send ContainerEvents. */ public void addContainerEventChannel(ChannelOutput containerEvent) { if (containerEvent != null) { ContainerEventHandler handler = new ContainerEventHandler(containerEvent); addContainerListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a ComponentEvent has occurred. This should be used * instead of registering a ComponentListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param componentEvent the channel down which to send ComponentEvents. */ public void addComponentEventChannel(ChannelOutput componentEvent) { if (componentEvent != null) { ComponentEventHandler handler = new ComponentEventHandler(componentEvent); addComponentListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a FocusEvent has occurred. This should be used * instead of registering a FocusListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param focusEvent the channel down which to send FocusEvents. */ public void addFocusEventChannel(ChannelOutput focusEvent) { if (focusEvent != null) { FocusEventHandler handler = new FocusEventHandler(focusEvent); addFocusListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a KeyEvent has occurred. This should be used * instead of registering a KeyListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param keyEvent the channel down which to send KeyEvents. */ public void addKeyEventChannel(ChannelOutput keyEvent) { if (keyEvent != null) { KeyEventHandler handler = new KeyEventHandler(keyEvent); addKeyListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseEvent has occurred. This should be used * instead of registering a MouseListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseEvent the channel down which to send MouseEvents. */ public void addMouseEventChannel(ChannelOutput mouseEvent) { if (mouseEvent != null) { MouseEventHandler handler = new MouseEventHandler(mouseEvent); addMouseListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseMotionEvent has occurred. This should be used * instead of registering a MouseMotionListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseMotionEvent the channel down which to send MouseMotionEvents. */ public void addMouseMotionEventChannel(ChannelOutput mouseMotionEvent) { if (mouseMotionEvent != null) { MouseMotionEventHandler handler = new MouseMotionEventHandler(mouseMotionEvent); addMouseMotionListener(handler); vec.addElement(handler); } } /** * This enables general configuration of this component. Any object implementing * this interface and sent down the configure channel to this component will have its * configure method invoked on this component. *
* For an example, see {@link ActiveApplet.Configure}. */ static public interface Configure { /** * @param dialog the Dialog being configured. */ public void configure(final Dialog dialog); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message instanceof Boolean) { if (message == Boolean.TRUE) setVisible(true); else if (message == Boolean.FALSE) setVisible(false); } else if (message instanceof Configure) ((Configure) message).configure(this); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveWindow.java 0000644 0000000 0000000 00000036104 11105701167 017206 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.Window java.awt.Window} * with a channel interface. *
Process Diagram
*
Description
* ActiveWindow is a process extension of java.awt.Window * with channels for run-time configuration and event notification. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure and event channels are * settable from a constructor. * The event channel delivers a WindowEvent whenever one is generated * on the ActiveWindow. * Other event channels can be added to notify the occurrence of any other events * the component generates (by calling the appropriate * addXXXEventChannel method before the process is run). * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myMouseEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveWindow myWindow = new ActiveWindow (); * myWindow.addMouseEventChannel (myMouseEvent.out ()); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *Boolean | *
*
|
*
| ActiveWindow.Configure | *Invoke the user-defined Configure.configure method on the window. | *|
| Output Channels | *||
| event | *WindowEvent | *The WindowEvent generated by the component | *
| containerEvent | *ContainerEvent | *See the {@link #addContainerEventChannel * addContainerEventChannel} method. | *
| componentEvent | *ComponentEvent | *See the {@link #addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the {@link #addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the {@link #addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the {@link #addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the {@link #addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import java.awt.*;
* import java.awt.event.*;
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
*
* public class ActiveWindowExample {
*
* public static void main (String argv[]) {
*
* final Frame root = new Frame ("ActiveWindow Example");
*
* final One2OneChannel event = Channel.one2one (new OverWriteOldestBuffer (10));
*
* final ActiveWindow window = new ActiveWindow (null, event.out (), root);
*
* root.setSize (400, 400);
* root.setVisible (true);
* window.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* window,
* new CSProcess () {
* public void run () {
* while (true) {
* WindowEvent w = (WindowEvent) event.in ().read ();
* System.out.println (w);
* }
* }
* }
* }
* ).run ();
* }
*
* }
*
*
* @see java.awt.Window
* @see java.awt.event.ContainerEvent
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveWindow extends Window implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* Constructs a new ActiveWindow.
*
* @param f the parent frame for the window.
*/
public ActiveWindow(Frame f)
{
this(null, null, f);
}
/**
* Constructs a new ActiveWindow.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the WindowEvent will be output whenever it occurs
* -- can be null if no notification is required.
* @param f the parent frame for the window.
*/
public ActiveWindow(ChannelInput configure, ChannelOutput event, Frame f)
{
super(f);
if (event != null)
{
WindowEventHandler handler = new WindowEventHandler(event);
addWindowListener(handler);
vec.addElement(handler);
}
this.configure = configure;
}
/**
* Sets the configuration channel for this ActiveWindow.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events.
* If the channel passed is null, no action will be taken.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* Add a new channel to this component that will be used to notify that
* a ContainerEvent has occurred. This should be used
* instead of registering a ContainerListener with the component. It is
* possible to add more than one Channel by calling this method multiple times
* If the channel passed is null, no action will be taken.
* * NOTE: This method must be called before this process is run. * * @param containerEvent the channel down which to send ContainerEvents. */ public void addContainerEventChannel(ChannelOutput containerEvent) { if (containerEvent != null) { ContainerEventHandler handler = new ContainerEventHandler(containerEvent); addContainerListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a ComponentEvent has occurred. This should be used * instead of registering a ComponentListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param componentEvent the channel down which to send ComponentEvents. */ public void addComponentEventChannel(ChannelOutput componentEvent) { if (componentEvent != null) { ComponentEventHandler handler = new ComponentEventHandler(componentEvent); addComponentListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a FocusEvent has occurred. This should be used * instead of registering a FocusListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param focusEvent the channel down which to send FocusEvents. */ public void addFocusEventChannel(ChannelOutput focusEvent) { if (focusEvent != null) { FocusEventHandler handler = new FocusEventHandler(focusEvent); addFocusListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a KeyEvent has occurred. This should be used * instead of registering a KeyListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param keyEvent the channel down which to send KeyEvents. */ public void addKeyEventChannel(ChannelOutput keyEvent) { if (keyEvent != null) { KeyEventHandler handler = new KeyEventHandler(keyEvent); addKeyListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseEvent has occurred. This should be used * instead of registering a MouseListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseEvent the channel down which to send MouseEvents. */ public void addMouseEventChannel(ChannelOutput mouseEvent) { if (mouseEvent != null) { MouseEventHandler handler = new MouseEventHandler(mouseEvent); addMouseListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseMotionEvent has occurred. This should be used * instead of registering a MouseMotionListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseMotionEvent the channel down which to send MouseMotionEvents. */ public void addMouseMotionEventChannel(ChannelOutput mouseMotionEvent) { if (mouseMotionEvent != null) { MouseMotionEventHandler handler = new MouseMotionEventHandler(mouseMotionEvent); addMouseMotionListener(handler); vec.addElement(handler); } } /** * This enables general configuration of this component. Any object implementing * this interface and sent down the configure channel to this component will have its * configure method invoked on this component. *
* For an example, see {@link ActiveApplet.Configure}. */ static public interface Configure { /** * @param window the Window being configured. */ public void configure(final Window window); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message instanceof Boolean) { if (message == Boolean.TRUE) setVisible(true); else if (message == Boolean.FALSE) setVisible(false); } else if (message instanceof Configure) ((Configure) message).configure(this); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ContainerEventHandler.java 0000644 0000000 0000000 00000006726 11105701167 021034 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.event.*; import org.jcsp.lang.*; /** * @author P.D. Austin and P.H. Welch */ class ContainerEventHandler implements ContainerListener { /** * The Channel action event notifications are sent down. */ private ChannelOutput event; /** * constructs a new ContainerEventHandler with the specified event output * Channel. * * @param event The Channel to send the event notification down */ public ContainerEventHandler(ChannelOutput event) { this.event = event; } /** * Invoked when the Container the event handler is listening to has a new * Component added to it. Notifies the event process that a * ContainerEvent has occurred by sending the ContainerEvent Object. * Some notifications will be lost so there are no guarantees that all * events generated will be processed. * * @param e The parameters associated with this event */ public void componentAdded(ContainerEvent e) { event.write(e); } /** * Invoked when the Container the event handler is listening to has a new * Component removed from it. Notifies the event process that a * ContainerEvent has occurred by sending the ContainerEvent Object. * Some notifications will be lost so there are no guarantees that all * events generated will be processed. * * @param e The parameters associated with this event */ public void componentRemoved(ContainerEvent e) { event.write(e); } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveComponent.java 0000644 0000000 0000000 00000033635 11105701167 017707 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.Component java.awt.Component} * with a channel interface. *
Process Diagram
*
Description
* ActiveComponent is a process extension of java.awt.Component * with channels for run-time configuration and event notification. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure channel is settable from a constructor. * Event channels can be added to notify the occurrence of any type of Event * the component generates (by calling the appropriate * addXXXEventChannel method before the process is run). * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myMouseEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveComponent myComponent = new ActiveComponent (); * myComponent.addMouseEventChannel (myMouseEvent.out ()); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *ActiveComponent.Configure | *Invoke the user-defined Configure.configure method on the component. | *
| Output Channels | *||
| componentEvent | *ComponentEvent | *See the {@link #addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the {@link #addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the {@link #addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the {@link #addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the {@link #addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import java.awt.*;
* import java.awt.event.*;
* import org.jcsp.util.*;
* import org.jcsp.lang.*;
* import org.jcsp.awt.*;
*
* public class ActiveComponentExample {
*
* public static void main (String argv[]) {
*
* final Frame root = new Frame ("ActiveComponent Example");
*
* final One2OneChannel mouseEvent = Channel.one2one (new OverWriteOldestBuffer (10));
*
* final ActiveComponent component = new ActiveComponent ();
* component.addMouseEventChannel (mouseEvent.out ());
*
* root.add (component);
* root.setSize (400, 400);
* root.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* component,
* new CSProcess () {
* public void run () {
* boolean running = true;
* while (running) {
* final MouseEvent event = (MouseEvent) mouseEvent.in ().read ();
* switch (event.getID ()) {
* case MouseEvent.MOUSE_ENTERED:
* System.out.println ("MOUSE_ENTERED");
* break;
* case MouseEvent.MOUSE_EXITED:
* System.out.println ("MOUSE_EXITED");
* break;
* case MouseEvent.MOUSE_PRESSED:
* System.out.println ("MOUSE_PRESSED");
* break;
* case MouseEvent.MOUSE_RELEASED:
* System.out.println ("MOUSE_RELEASED");
* break;
* case MouseEvent.MOUSE_CLICKED:
* if (event.getClickCount() > 1) {
* System.out.println ("MOUSE_DOUBLE_CLICKED ... goodbye!");
* running = false;
* } else {
* System.out.println ("MOUSE_CLICKED ... *double* click to quit!");
* }
* break;
* }
* }
* root.setVisible (false);
* System.exit (0);
* }
* }
* }
* ).run ();
* }
*
* }
*
*
* @see java.awt.Component
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveComponent extends Component implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* Constructs a new ActiveComponent with no configuration channel.
*/
public ActiveComponent()
{
this(null);
}
/**
* Constructs a new ActiveComponent with a configuration channel.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public ActiveComponent(ChannelInput configure)
{
this.configure = configure;
}
/**
* Sets the configuration channel for this ActiveComponent.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* Add a new channel to this component that will be used to notify that
* a ComponentEvent has occurred. This should be used
* instead of registering a ComponentListener with the component. It is
* possible to add more than one Channel by calling this method multiple times
* If the channel passed is null, no action will be taken.
* * NOTE: This method must be called before this process is run. * * @param componentEvent the channel down which ComponentEvents will be sent. */ public void addComponentEventChannel(ChannelOutput componentEvent) { if (componentEvent != null) { ComponentEventHandler handler = new ComponentEventHandler(componentEvent); addComponentListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a FocusEvent has occurred. This should be used * instead of registering a FocusListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param focusEvent the channel down which FocusEvents will be sent. */ public void addFocusEventChannel(ChannelOutput focusEvent) { if (focusEvent != null) { FocusEventHandler handler = new FocusEventHandler(focusEvent); addFocusListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a KeyEvent has occurred. This should be used * instead of registering a KeyListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param keyEvent the channel down which KeyEvents will be sent. */ public void addKeyEventChannel(ChannelOutput keyEvent) { if (keyEvent != null) { KeyEventHandler handler = new KeyEventHandler(keyEvent); addKeyListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseEvent has occurred. This should be used * instead of registering a MouseListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseEvent the channel down which MouseEvents will be sent. */ public void addMouseEventChannel(ChannelOutput mouseEvent) { if (mouseEvent != null) { MouseEventHandler handler = new MouseEventHandler(mouseEvent); addMouseListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseMotionEvent has occurred. This should be used * instead of registering a MouseMotionListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseMotionEvent the channel down which MouseMotionEvents will be sent. */ public void addMouseMotionEventChannel(ChannelOutput mouseMotionEvent) { if (mouseMotionEvent != null) { MouseMotionEventHandler handler = new MouseMotionEventHandler(mouseMotionEvent); addMouseMotionListener(handler); vec.addElement(handler); } } /** * This enables general configuration of this component. Any object * implementing this interface and sent down the configure channel to * this component will have its configure method invoked on this component. *
* For an example, see {@link ActiveApplet.Configure}. */ static public interface Configure { /** * @param component the Component being configured. */ public void configure(final Component component); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message instanceof Configure) ((Configure) message).configure(this); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/AdjustmentEventHandler.java 0000644 0000000 0000000 00000006000 11105701167 021211 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.event.*; import org.jcsp.lang.*; /** * @author P.D. Austin and P.H. Welch */ class AdjustmentEventHandler implements AdjustmentListener { /** * The Channel AdjustmentEvent notifications are sent down. */ private ChannelOutputInt event; /** * Constructs a new AdjustmentEventHandler with the specified event Channel. * * @param event The Channel AdjustmentEvent notifications are sent down. */ public AdjustmentEventHandler(ChannelOutputInt event) { this.event = event; } /** * Invoked when an adjustment occurs on the component the event handler is * listening to. Notifies the event process that an AdjustmentEvent has * occurred. Some notifications will be lost so there are no guarantees * that all events generated will be processed. Sets the value to the * current value of the component. * * @param e The parameters associated with this event */ public void adjustmentValueChanged(AdjustmentEvent e) { event.write(e.getValue()); } }jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveCanvas.java 0000644 0000000 0000000 00000054343 11105701167 017157 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.Canvas java.awt.Canvas} * with a channel interface. *
Process Diagram
*
Description
* ActiveCanvas is a process extension of java.awt.Canvas * with channels for run-time configuration/interrogation and event notification. * The event channels should be connected to one or more application-specific server. * processes (instead of registering a passive object as a Listener * to this component). ** All channels are optional. The toGraphics/fromGraphics channels are * set by calling the {@link ActiveCanvas#setGraphicsChannels setGraphicsChannels} method. * Event channels can be added to notify the occurrence of any type of Event * the component generates by calling the appropriate * addXXXEventChannel method. * All channel connections must be made before the process is run. *
* Messages can be sent down the toGraphics channel at any time to configure * or interrogate the component. A reply or acknowledgment is returned down * the fromGraphics channel and must be read. * See the table below and {@link GraphicsProtocol} for details. *
* Graphics operations on an ActiveCanvas are most conveniently managed * by attaching, and then setting {@link GraphicsCommand}s on, a {@link DisplayList} * (or any user-defined object implementing the {@link Paintable} interface). * This can be done either statically via the {@link #setPaintable setPaintable} * method, or dynamically * via the {@link #setGraphicsChannels toGraphics/fromGraphics} channels * (see {@link GraphicsProtocol.SetPaintable}). *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myMouseEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveCanvas myCanvas = new ActiveCanvas (); * myCanvas.addMouseEventChannel (myMouseEvent.out ()); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| displayList | *GraphicsCommand[] | *See {@link org.jcsp.awt.DisplayList} and {@link org.jcsp.awt.GraphicsCommand}. | *
| toGraphics | *GraphicsProtocol | *See {@link org.jcsp.awt.GraphicsProtocol}. | *
| Output Channels | *||
| fromGraphics | *Object | *Response to the fromGraphics message. See the documentation on * {@link org.jcsp.awt.GraphicsProtocol}. * | *
| componentEvent | *ComponentEvent | *See the {@link #addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the {@link #addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the {@link #addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the {@link #addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the {@link #addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import java.awt.*;
* import java.awt.event.*;
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
*
* public class ActiveCanvasExample {
*
* public static void main (String argv[]) {
*
* final ActiveClosingFrame activeClosingFrame =
* new ActiveClosingFrame ("ActiveCanvas Example");
* final Frame frame = activeClosingFrame.getActiveFrame ();
*
* final One2OneChannel mouseEvent = Channel.one2one (new OverWriteOldestBuffer (10));
*
* final DisplayList displayList = new DisplayList ();
*
* final ActiveCanvas canvas = new ActiveCanvas ();
* canvas.addMouseEventChannel (mouseEvent.out ());
* canvas.setPaintable (displayList);
* canvas.setSize (600, 400);
*
* frame.add (canvas);
* frame.pack ();
* frame.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* activeClosingFrame,
* canvas,
* new CSProcess () {
* public void run () {
* final String clickMessage = "D O U B L E - C L I C K T H E M O U S E T O E X I T";
* final String clickPlea = " P L E A S E M O V E T H E M O U S E B A C K ";
* final GraphicsCommand[] mouseEntered =
* {new GraphicsCommand.SetColor (Color.cyan),
* new GraphicsCommand.FillRect (0, 0, 600, 400),
* new GraphicsCommand.SetColor (Color.black),
* new GraphicsCommand.DrawString (clickMessage, 140, 200)};
* final GraphicsCommand[] mouseExited =
* {new GraphicsCommand.SetColor (Color.pink),
* new GraphicsCommand.FillRect (0, 0, 600, 400),
* new GraphicsCommand.SetColor (Color.black),
* new GraphicsCommand.DrawString (clickPlea, 140, 200)};
* final GraphicsCommand mousePressed =
* new GraphicsCommand.DrawString (clickMessage, 160, 220);
* final GraphicsCommand mouseReleased =
* new GraphicsCommand.DrawString (clickMessage, 140, 200);
* displayList.set (mouseExited);
* boolean running = true;
* while (running) {
* final MouseEvent event = (MouseEvent) mouseEvent.in ().read ();
* switch (event.getID ()) {
* case MouseEvent.MOUSE_ENTERED:
* System.out.println ("MOUSE_ENTERED");
* displayList.set (mouseEntered);
* break;
* case MouseEvent.MOUSE_EXITED:
* System.out.println ("MOUSE_EXITED");
* displayList.set (mouseExited);
* break;
* case MouseEvent.MOUSE_PRESSED:
* System.out.println ("MOUSE_PRESSED");
* displayList.change (mousePressed, 3);
* break;
* case MouseEvent.MOUSE_RELEASED:
* System.out.println ("MOUSE_RELEASED");
* displayList.change (mouseReleased, 3);
* break;
* case MouseEvent.MOUSE_CLICKED:
* if (event.getClickCount() > 1) {
* System.out.println ("MOUSE_DOUBLE_CLICKED ... goodbye!");
* running = false;
* }
* break;
* }
* }
* frame.setVisible (false);
* System.exit (0);
* }
* }
* }
* ).run ();
* }
*
* }
*
*
* @see org.jcsp.awt.DisplayList
* @see org.jcsp.awt.Display
* @see org.jcsp.awt.GraphicsCommand
* @see org.jcsp.awt.Paintable
* @see org.jcsp.awt.GraphicsProtocol
* @see org.jcsp.util.OverWriteOldestBuffer
* @see java.awt.Canvas
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveCanvas extends Canvas implements CSProcess
{
private ChannelInput toGraphics;
private ChannelOutput fromGraphics;
/**
* Set the toGraphics/fromGraphics channels for configuring
* and/or examining this component.
* A {@link GraphicsProtocol org.jcsp.awt.GraphicsProtocol} object sent down
* the toGraphics channel generates the appropriate configuration or enquiry
* action. A reply object is always returned down the fromGraphics channel.
* * NOTE: This method must be called before this process is run. *
* * @param toGraphics the channel down which GraphicsProtocol objects are sent. * @param fromGraphics the reply/acknowledgement channel responding to the GraphicsProtocol object. */ public void setGraphicsChannels(ChannelInput toGraphics, ChannelOutput fromGraphics) { this.toGraphics = toGraphics; this.fromGraphics = fromGraphics; } private Paintable paintable; /** * Set the {@link Paintable Paintable} object that will be used by the {@link ActiveCanvas#paint paint} * and {@link ActiveCanvas#update update} methods of this canvas. If paintable is * null, the paint/update methods will not be overriden. *
* JCSP provides a {@link DisplayList} as an example Paintable class. * This can be thought of as a special form of channel. A user process at the other * end writes to it by setting up and/or editing an ordered list of * {@link GraphicsCommand}s. This method may be used to connect the DisplayList * to this ActiveCanvas. For example: *
* final ActiveCanvas myActiveCanvas = new ActiveCanvas ();
*
* final DisplayList draw = new DisplayList ();
* myActiveCanvas.setPaintable (draw);
*
* ... connect other channels (toGraphics, fromGraphics, mouseEvent, etc.)
*
* // myActiveCanvas is now ready to run
*
* * NOTE: If setPaintable is going to be invoked, this must happen * before this process is run. *
* Alternatively, the {@link Paintable Paintable} object may be set dynamically * by sending an appropriate {@link GraphicsProtocol.SetPaintable} object down the * {@link ActiveCanvas#setGraphicsChannels(org.jcsp.lang.ChannelInput,org.jcsp.lang.ChannelOutput) toGraphics} * channel. *
* * @param paintable the object to be used for painting/updating the canvas. */ public void setPaintable(Paintable paintable) { this.paintable = paintable; paintable.register(this); } /** * This method is used by the JVM event thread -- it is not really for public * consumption. If {@link ActiveCanvas#setPaintable setPaintable} has been invoked * on this canvas or a {@link GraphicsProtocol.SetPaintable} object has been sent down * the {@link ActiveCanvas#setGraphicsChannels(org.jcsp.lang.ChannelInput,org.jcsp.lang.ChannelOutput) toGraphics} * channel, this method uses the supplied {@link Paintable Paintable} object * to do the painting. *
*/ public void paint(Graphics g) { if (paintable == null) super.paint(g); else paintable.paint(g); } /** * This method is used by the JVM event thread -- it is not really for public * consumption. If {@link ActiveCanvas#setPaintable setPaintable} has been invoked * on this canvas or a {@link GraphicsProtocol.SetPaintable} object has been sent down * the {@link ActiveCanvas#setGraphicsChannels(org.jcsp.lang.ChannelInput,org.jcsp.lang.ChannelOutput) toGraphics} * channel, this method uses the supplied {@link Paintable Paintable} object * to do the updating. *
*/ public void update(Graphics g) { if (paintable == null) super.update(g); else paintable.update(g); } /** * The Vector construct containing the handlers. */ private Vector vec = new Vector(); /** * Add a new channel to this component that will be used to notify that * a ComponentEvent has occurred. This should be used * instead of registering a ComponentListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. *
* * @param componentEvent the channel down which to send ComponentEvents. */ public void addComponentEventChannel(ChannelOutput componentEvent) { if (componentEvent != null) { ComponentEventHandler handler = new ComponentEventHandler(componentEvent); addComponentListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a FocusEvent has occurred. This should be used * instead of registering a FocusListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. *
* * @param focusEvent the channel down which to send FocusEvents. */ public void addFocusEventChannel(ChannelOutput focusEvent) { if (focusEvent != null) { FocusEventHandler handler = new FocusEventHandler(focusEvent); addFocusListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a KeyEvent has occurred. This should be used * instead of registering a KeyListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. *
* * @param keyEvent the channel down which to send KeyEvents. */ public void addKeyEventChannel(ChannelOutput keyEvent) { if (keyEvent != null) { KeyEventHandler handler = new KeyEventHandler(keyEvent); addKeyListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseEvent has occurred. This should be used * instead of registering a MouseListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. *
* * @param mouseEvent the channel down which to send MouseEvents. */ public void addMouseEventChannel(ChannelOutput mouseEvent) { if (mouseEvent != null) { MouseEventHandler handler = new MouseEventHandler(mouseEvent); addMouseListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseMotionEvent has occurred. This should be used * instead of registering a MouseMotionListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. *
* * @param mouseMotionEvent the channel down which to send MouseMotionEvents. */ public void addMouseMotionEventChannel(ChannelOutput mouseMotionEvent) { if (mouseMotionEvent != null) { MouseMotionEventHandler handler = new MouseMotionEventHandler(mouseMotionEvent); addMouseMotionListener(handler); vec.addElement(handler); } } private int requestedWidth, requestedHeight; /** * Request that the canvas takes the size given by the parameters. * The methods {@link #getPreferredSize getPreferredSize} * and {@link #getMinimumSize getMinimumSize} are * overridden to return these dimensions. *
* NOTE: This method must be called before this process is run. *
* * @param requestedWidth the requested width for the canvas. * @param requestedHeight the requested height for the canvas. */ public void setSize(int requestedWidth, int requestedHeight) { this.requestedWidth = requestedWidth; this.requestedHeight = requestedHeight; } /** * This method is used by system classes -- it is not really for public consumption! *
*/ public Dimension getPreferredSize() { return new Dimension(requestedWidth, requestedHeight); } /** * This method is used by system classes -- it is not really for public consumption! *
*/ public Dimension getMinimumSize() { return new Dimension(requestedWidth, requestedHeight); } /** * The main body of this process. */ public void run() { if (toGraphics != null) { while (true) { final GraphicsProtocol gp = (GraphicsProtocol) toGraphics.read(); if (gp == null) break; else { switch (gp.tag) { case GraphicsProtocol.GET_DIMENSION_TAG: fromGraphics.write(getSize()); break; case GraphicsProtocol.GET_COMPONENT_TAG: fromGraphics.write(this); break; case GraphicsProtocol.GET_BACKGROUND_TAG: fromGraphics.write(getBackground()); break; case GraphicsProtocol.SET_BACKGROUND_TAG: final GraphicsProtocol.SetBackground sbc = (GraphicsProtocol.SetBackground) gp; setBackground(sbc.color); fromGraphics.write(Boolean.TRUE); break; case GraphicsProtocol.REQUEST_FOCUS_TAG: requestFocus(); fromGraphics.write(Boolean.TRUE); break; case GraphicsProtocol.MAKE_MIS_IMAGE_TAG: final GraphicsProtocol.MakeMISImage mmi = (GraphicsProtocol.MakeMISImage) gp; fromGraphics.write(createImage(mmi.mis)); break; case GraphicsProtocol.SET_PAINTABLE_TAG: final GraphicsProtocol.SetPaintable sp = (GraphicsProtocol.SetPaintable) gp; paintable = sp.paintable; paintable.register(this); fromGraphics.write(Boolean.TRUE); break; case GraphicsProtocol.GENERAL_TAG: final GraphicsProtocol.General general = (GraphicsProtocol.General) gp; fromGraphics.write(general.c.configure(this)); break; } } } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/Display.java 0000644 0000000 0000000 00000011536 11105701167 016212 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; /** * Objects implementing this interface provide graphics services to a {@link org.jcsp.lang.CSProcess}. *
Description
* Display is an interface to a passive object providing graphics * services on behalf of a {@link org.jcsp.lang.CSProcess}. Such an object provides * an occam3-like CALL channel between the application * CSProcess and the active graphics component (such as * {@link ActiveCanvas ActiveCanvas}) on which it wishes to draw. * * @see org.jcsp.awt.DisplayList * * @author P.H. Welch */ public interface Display { /** * Sets the array of GraphicsCommands to be interpreted. The commands will * be interpreted in ascending order of index. ** * @param c the array of GraphicsCommands to be interpreted. */ public void set (final GraphicsCommand[] c); /** * Sets the GraphicsCommand to be interpreted. *
* * @param c the array of GraphicsCommands to be interpreted. */ public void set (final GraphicsCommand c); /** * Extends the array of GraphicsCommands to be interpreted. *
* * @param c the extra GraphicsCommands to be interpreted. * @return the start index of the extension. */ public int extend (final GraphicsCommand[] c); /** * Extends the array of GraphicsCommands to be executed by one command. *
* * @param c the extra GraphicsCommand to be interpreted. * @return the start index of the extension. */ public int extend (final GraphicsCommand c); /** * Changes the array of GraphicsCommands to be interpreted by replacing elements * i onwards with the new ones. There must be at least (i + c.length) * elements in the original array -- else this method will not change anything and will * return false. *
* * @param c the new GraphicsCommands to be interpreted. * @param i the start index for the replacement. * @return true if and only if the changes are successfully made. */ public boolean change (final GraphicsCommand[] c, final int i); /** * Changes the array of GraphicsCommands to be executed by replacing element * i with the new one. There must be at least (i + 1) * elements in the original array -- else this method will not change anything and will * return false. *
* * @param c the new GraphicsCommand to be interpreted. * @param i the index for the replacement. * @return true if and only if the changes are successfully made. */ public boolean change (final GraphicsCommand c, final int i); /** * Returns a copy of the array of GraphicsCommands currently held. *
* * @return a copy of the array of GraphicsCommands currently held. */ public GraphicsCommand[] get (); } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveMenuItem.java 0000644 0000000 0000000 00000031313 11105701167 017457 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.MenuItem java.awt.MenuItem} * with a channel interface. *
Process Diagram
*
*
Description
* ActiveMenuItem is a process extension of java.awt.MenuItem * with channels for run-time configuration and event notification. The event channel * should be connected to an application-specific server process (instead * of registering a passive object as a Listener to this component). ** The configure and event channels are * settable from a constructor. * The event channel delivers the current label on the * ActiveMenuItem whenever it is selected. * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service the event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that a (non-null) event channel from this process is * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myMenuItemEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveMenuItem myMenuItem = * new ActiveMenuItem (null, myMenuItemEvent.out (), "Choose Me"); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *String | *Change the label on the ActiveMenuItem to the value of the String | *
| java.awt.MenuShortcut | *Sets the MenuShortcut for the ActiveMenuItem | *|
| Boolean | *
*
|
* |
| ActiveMenuItem.Configure | *Invoke the user-defined Configure.configure method on the menuItem. | *|
| Output Channels | *||
| event | *String | *The label on the ActiveMenuItem (when the item is selected) | *
Example
*
* import java.awt.*;
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
*
* public class ActiveMenuItemExample {
*
* public static void main (String argv[]) {
*
* final ActiveClosingFrame activeClosingFrame =
* new ActiveClosingFrame ("ActiveMenuItem Example");
*
* final ActiveFrame frame = activeClosingFrame.getActiveFrame ();
*
* final MenuBar menuBar = new MenuBar ();
* frame.setMenuBar (menuBar);
*
* final Menu fileMenu = new Menu ("File");
* final Menu langMenu = new Menu ("Language");
* menuBar.add (fileMenu);
* menuBar.add (langMenu);
*
* final String[] fileOptions = {"Hello World", "Rocket Science", "CSP",
* "Monitors", "Ignore Me", "Goodbye World"};
* final String[] langOptions = {"occam-pi", "Java", "Smalltalk", "Algol-60",
* "Pascal", "Haskell", "SML", "Lisp"};
*
* final Any2OneChannel event[] = Channel.any2oneArray (2, new OverWriteOldestBuffer (10));
*
* final ActiveMenuItem[] fileMenuItem = new ActiveMenuItem[fileOptions.length];
* for (int i = 0; i < fileOptions.length; i++) {
* fileMenuItem[i] = new ActiveMenuItem (null, event[0].out (), fileOptions[i]);
* fileMenu.add (fileMenuItem[i]);
* }
*
* final ActiveMenuItem[] langMenuItem = new ActiveMenuItem[langOptions.length];
* for (int i = 0; i < langOptions.length; i++) {
* langMenuItem[i] = new ActiveMenuItem (null, event[1].out (), langOptions[i]);
* langMenu.add (langMenuItem[i]);
* }
*
* frame.setSize (300, 200);
* frame.setBackground (Color.green);
* frame.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* activeClosingFrame,
* new Parallel (fileMenuItem),
* new Parallel (langMenuItem),
* new CSProcess () {
* public void run () {
* boolean running = true;
* while (running) {
* final String s = (String) event[0].in ().read ();
* System.out.println ("File ==> `" + s + "' selected ...");
* running = (s != fileOptions[fileOptions.length - 1]);
* }
* frame.setVisible (false);
* System.exit (0);
* }
* },
* new CSProcess () {
* public void run () {
* while (true) {
* final String s = (String) event[1].in ().read ();
* System.out.println ("Language ==> `" + s + "' selected ...");
* }
* }
* }
* }
* ).run ();
*
* }
*
* }
*
*
* @see java.awt.MenuItem
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveMenuItem extends MenuItem implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* Constructs a new ActiveMenuItem with no label and no shortcut
* and no configuration or event channels.
*
*/
public ActiveMenuItem()
{
this(null, null, "", null);
}
/**
* Constructs a new ActiveMenuItem with no shortcut
* and no configuration or event channels.
*
* @param s the initial label displayed on the menuItem.
*/
public ActiveMenuItem(String s)
{
this(null, null, s, null);
}
/**
* Constructs a new ActiveMenuItem
* with no configuration or event channels.
*
* @param s the initial label displayed on the menuItem.
* @param ms the MenuShortcut for the menuItem.
*/
public ActiveMenuItem(String s, MenuShortcut ms)
{
this(null, null, s, ms);
}
/**
* Constructs a new ActiveMenuItem with no label and no shortcut.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the current label will be output when the menuItem is selected
* -- can be null if no notification is required.
*/
public ActiveMenuItem(ChannelInput configure, ChannelOutput event)
{
this(configure, event, "", null);
}
/**
* Constructs a new ActiveMenuItem with no shortcut.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the current label will be output when the menuItem is selected
* -- can be null if no notification is required.
* @param s the initial label displayed on the menuItem.
*/
public ActiveMenuItem(ChannelInput configure, ChannelOutput event, String s)
{
this(configure, event, s, null);
}
/**
* Constructs a new ActiveMenuItem.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the current label will be output when the menuItem is selected
* -- can be null if no notification is required.
* @param s the initial label displayed on the menuItem.
* @param ms the MenuShortcut for the menuItem.
*/
public ActiveMenuItem(ChannelInput configure, ChannelOutput event, String s, MenuShortcut ms)
{
super(s, ms);
if (event != null)
{
ActionEventHandler handler = new ActionEventHandler(event);
addActionListener(handler);
vec.addElement(handler);
}
this.configure = configure;
}
/**
* Sets the configuration channel for this ActiveMenuItem.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* This enables general configuration of this component. Any object implementing
* this interface and sent down the configure channel to this component will have its
* configure method invoked on this component.
* * For an example, see {@link ActiveApplet.Configure}. */ static public interface Configure { /** * @param menuItem the MenuItem being configured. */ public void configure(final MenuItem menuItem); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message instanceof String) setLabel((String) message); else if (message instanceof MenuShortcut) setShortcut((MenuShortcut) message); else if (message instanceof Boolean) { if (message == Boolean.TRUE) setEnabled(true); else if (message == Boolean.FALSE) setEnabled(false); } else if (message instanceof Configure) ((Configure) message).configure(this); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/MouseMotionEventHandler.java 0000644 0000000 0000000 00000006623 11105701167 021364 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import org.jcsp.lang.*; import java.awt.event.*; /** * @author P.D. Austin and P.H. Welch */ class MouseMotionEventHandler implements MouseMotionListener { /** * The Channel action event notifications are sent down. */ private ChannelOutput event; /** * constructs a new MouseMotionEventHandler with the specified output Channel. * * @param event The Channel to send the event notification down */ public MouseMotionEventHandler(ChannelOutput event) { this.event = event; } /** * Invoked when the Component the event handler is listening to has a mouse * dragged. Notifies the event process that a MouseEvent has * occurred by sending the MouseEvent Object. Some notifications will be * lost so there are no guarantees that all events generated will be * processed. * * @param e The parameters associated with this event */ public void mouseDragged(MouseEvent e) { event.write(e); } /** * Invoked when the Component the event handler is listening to has a mouse * moved. Notifies the event process that a MouseEvent has * occurred by sending the MouseEvent Object. Some notifications will be * lost so there are no guarantees that all events generated will be * processed. * * @param e The parameters associated with this event */ public void mouseMoved(MouseEvent e) { event.write(e); } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/GraphicsProtocol.java 0000644 0000000 0000000 00000020774 11105701167 020073 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.awt.image.*; import org.jcsp.lang.TaggedProtocol; /** * This is the tagged protocol for use over the toGraphics * configuration channel of an active graphics component. *
Description
* GraphicsProtocol is the tagged protocol for use over the toGraphics * configuration channel of an active graphics component (for example, see * {@link ActiveCanvas#setGraphicsChannels ActiveCanvas.setGraphicsChannels}). ** It is a collection of static immutable enquiry/configuration * objects and static configuration classes. An enquiry sent down the toGraphics * channel generates an appropriate reply on the fromGraphics channel. * A configuration class may be used to construct an immutable configuration object * that may be sent down the toGraphics channel to configure some property of the graphics * component. A configuration message is always acknowledged with a Boolean.TRUE * returned on the fromGraphics channel (once the configuration has happened). * * @see org.jcsp.awt.ActiveCanvas * @see org.jcsp.lang.TaggedProtocol * * @author P.H. Welch */ public abstract class GraphicsProtocol extends TaggedProtocol { GraphicsProtocol(final int tag) { super(tag); } static final int GET_DIMENSION_TAG = 0; static final int GET_COMPONENT_TAG = 1; static final int GET_BACKGROUND_TAG = 2; static final int SET_BACKGROUND_TAG = 3; static final int REQUEST_FOCUS_TAG = 4; static final int MAKE_MIS_IMAGE_TAG = 5; static final int SET_PAINTABLE_TAG = 6; static final int GENERAL_TAG = 7; static private final class GetDimension extends GraphicsProtocol { public GetDimension() { super(GET_DIMENSION_TAG); } } /** * This is an enquiry object to find the size of the active graphics component. * The java.awt.Dimension * will be returned down the fromGraphics channel. */ static public final GraphicsProtocol GET_DIMENSION = new GetDimension(); static private final class GetComponent extends GraphicsProtocol { public GetComponent() { super(GET_COMPONENT_TAG); } } /** * This is an enquiry object to obtain the active graphics component. * The java.awt.Component * will be returned down the fromGraphics channel. */ static public final GraphicsProtocol GET_COMPONENT = new GetComponent(); static private final class GetBackground extends GraphicsProtocol { public GetBackground() { super(GET_BACKGROUND_TAG); } } /** * This is an enquiry object to find the background colour of the active graphics component. * The background java.awt.Color * will be returned down the fromGraphics channel. */ static public final GraphicsProtocol GET_BACKGROUND = new GetBackground(); /** * This is a configuration class for setting the background java.awt.Color * of the active graphics component. A Boolean.TRUE will be returned down * the fromGraphics channel. */ static public final class SetBackground extends GraphicsProtocol { final Color color; /** * * @param color the new background colour for the graphics component. */ public SetBackground(final Color color) { super(SET_BACKGROUND_TAG); this.color = color; } } static private final class RequestFocus extends GraphicsProtocol { public RequestFocus() { super(REQUEST_FOCUS_TAG); } } /** * This is a configuration object to request input focus on the graphics component * for keyboard and mouse evnts. A Boolean.TRUE will be returned down * the fromGraphics channel. */ static public final GraphicsProtocol REQUEST_FOCUS = new RequestFocus(); /** * This is a configuration class to associate a java.awt.image.MemoryImageSource * with the graphics component. The component uses this to create a java.awt.Image, * which is returned down the fromGraphics channel. */ static public final class MakeMISImage extends GraphicsProtocol { final MemoryImageSource mis; /** * @param mis the MemoryImageSource for the graphics component. */ public MakeMISImage(final MemoryImageSource mis) { super(MAKE_MIS_IMAGE_TAG); this.mis = mis; } } /** * This is a configuration class to register a org.jcsp.awt.Paintable object * with the graphics component. A Boolean.TRUE will be returned down * the fromGraphics channel. */ static public final class SetPaintable extends GraphicsProtocol { final Paintable paintable; /** * @param paintable the Paintable object to which the graphics component * will delegate its paint/update methods. */ public SetPaintable(final Paintable paintable) { super(SET_PAINTABLE_TAG); this.paintable = paintable; } } /** * This is the interface for general configuration of the graphics component. * See the {@link GraphicsProtocol.General General} class. */ static public interface Configure { /** * @param c the Component being configured. */ public Object configure(final Component c); } /** * This is a general configuration class for the graphics component. * The user constructs an instance of this class, supplying an object * implementing the {@link GraphicsProtocol.Configure Configure} * interface, and writes it down the toGraphics channel. * The graphics component invokes the configure method * of the enclosed Configure object and * returns the Object result down the fromGraphics channel. */ static public final class General extends GraphicsProtocol { final Configure c; /** * @param c the object implementing the user's configuration requirements * for the graphics component. */ public General(final Configure c) { super(GENERAL_TAG); this.c = c; } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActivePanel.java 0000644 0000000 0000000 00000035520 11105701167 016777 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.Panel java.awt.Panel} * with a channel interface. *
Process Diagram
*
Description
* ActivePanel is a process extension of java.awt.Panel * with channels for run-time configuration and event notification. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure channel is settable from a constructor. * Event channels can be added to notify the occurrence of any type of Event * the component generates (by calling the appropriate * addXXXEventChannel method before the process is run). * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myMouseEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActivePanel myPanel = new ActivePanel (); * myPanel.addMouseEventChannel (myMouseEvent.out ()); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *ActivePanel.Configure | *Invoke the user-defined Configure.configure method on the panel. | *
| Output Channels | *||
| containerEvent | *ContainerEvent | *See the {@link #addContainerEventChannel * addContainerEventChannel} method. | *
| componentEvent | *ComponentEvent | *See the {@link #addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the {@link #addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the {@link #addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the {@link #addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the {@link #addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import java.awt.*;
* import java.awt.event.*;
* import org.jcsp.util.*;
* import org.jcsp.lang.*;
* import org.jcsp.awt.*;
*
* public class ActivePanelExample {
*
* public static void main (String argv[]) {
*
* final Frame root = new Frame ("ActivePanel Example");
*
* final One2OneChannel mouseEvent = Channel.one2one (new OverWriteOldestBuffer (10));
*
* final ActivePanel panel = new ActivePanel ();
* panel.addMouseEventChannel (mouseEvent.out ());
*
* root.add (panel);
* root.setSize (400, 400);
* root.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* panel,
* new CSProcess () {
* public void run () {
* boolean running = true;
* while (running) {
* final MouseEvent event = (MouseEvent) mouseEvent.in ().read ();
* switch (event.getID ()) {
* case MouseEvent.MOUSE_ENTERED:
* System.out.println ("MOUSE_ENTERED");
* break;
* case MouseEvent.MOUSE_EXITED:
* System.out.println ("MOUSE_EXITED");
* break;
* case MouseEvent.MOUSE_PRESSED:
* System.out.println ("MOUSE_PRESSED");
* break;
* case MouseEvent.MOUSE_RELEASED:
* System.out.println ("MOUSE_RELEASED");
* break;
* case MouseEvent.MOUSE_CLICKED:
* if (event.getClickCount() > 1) {
* System.out.println ("MOUSE_DOUBLE_CLICKED ... goodbye!");
* running = false;
* } else {
* System.out.println ("MOUSE_CLICKED ... *double* click to quit!");
* }
* break;
* }
* }
* root.setVisible (false);
* System.exit (0);
* }
* }
* }
* ).run ();
* }
*
* }
*
*
* @see java.awt.Panel
* @see java.awt.event.ContainerEvent
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActivePanel extends Panel implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* Constructs a new ActivePanel with no configuration channel.
*/
public ActivePanel()
{
this(null);
}
/**
* Constructs a new ActivePanel with a configuration channel.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public ActivePanel(ChannelInput configure)
{
this.configure = configure;
}
/**
* Sets the configuration channel for this ActivePanel.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* Add a new channel to this component that will be used to notify that
* a ContainerEvent has occurred. This should be used
* instead of registering a ContainerListener with the component. It is
* possible to add more than one Channel by calling this method multiple times
* If the channel passed is null, no action will be taken.
* * NOTE: This method must be called before this process is run. * * @param containerEvent the channel down which to send ContainerEvents. */ public void addContainerEventChannel(ChannelOutput containerEvent) { if (containerEvent != null) { ContainerEventHandler handler = new ContainerEventHandler(containerEvent); addContainerListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a ComponentEvent has occurred. This should be used * instead of registering a ComponentListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param componentEvent the channel down which to send ComponentEvents. */ public void addComponentEventChannel(ChannelOutput componentEvent) { if (componentEvent != null) { ComponentEventHandler handler = new ComponentEventHandler(componentEvent); addComponentListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a FocusEvent has occurred. This should be used * instead of registering a FocusListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param focusEvent the channel down which to send FocusEvents. */ public void addFocusEventChannel(ChannelOutput focusEvent) { if (focusEvent != null) { FocusEventHandler handler = new FocusEventHandler(focusEvent); addFocusListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a KeyEvent has occurred. This should be used * instead of registering a KeyListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param keyEvent the channel down which to send KeyEvents. */ public void addKeyEventChannel(ChannelOutput keyEvent) { if (keyEvent != null) { KeyEventHandler handler = new KeyEventHandler(keyEvent); addKeyListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseEvent has occurred. This should be used * instead of registering a MouseListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseEvent the channel down which to send MouseEvents. */ public void addMouseEventChannel(ChannelOutput mouseEvent) { if (mouseEvent != null) { MouseEventHandler handler = new MouseEventHandler(mouseEvent); addMouseListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseMotionEvent has occurred. This should be used * instead of registering a MouseMotionListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseMotionEvent the channel down which to send MouseMotionEvents. */ public void addMouseMotionEventChannel(ChannelOutput mouseMotionEvent) { if (mouseMotionEvent != null) { MouseMotionEventHandler handler = new MouseMotionEventHandler(mouseMotionEvent); addMouseMotionListener(handler); vec.addElement(handler); } } /** * This enables general configuration of this component. Any object implementing * this interface and sent down the configure channel to this component will have its * configure method invoked on this component. *
* For an example, see {@link ActiveApplet.Configure}. */ static public interface Configure { /** * @param panel the Panel being configured. */ public void configure(final Panel panel); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message instanceof Configure) ((Configure) message).configure(this); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveTextField.java 0000644 0000000 0000000 00000042767 11105701167 017643 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.TextField java.awt.TextField} * with a channel interface. *
Process Diagram
*
*
Description
* ActiveTextField is a process extension of java.awt.TextField * with channels for run-time configuration and event notification. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure and event channels are * settable from a constructor. * The event channel delivers updated text whenever * the ActiveTextField is changed. * Other event channels can be added to notify the occurrence of any other events * the component generates (by calling the appropriate * addXXXEventChannel method before the process is run). * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myTextFieldEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveTextField myTextField = * new ActiveTextField (null, myTextFieldEvent.out (), "Edit Me"); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *String | *Set the text in this ActiveTextField to the value of the String | *
| Boolean | *
*
|
* |
| ActiveTextField.Configure | *Invoke the user-defined Configure.configure method on the textField. | *|
| otherwise | *Append the toString form of the object to the text in this ActiveTextField. | *|
| Output Channels | *||
| event | *String | *The text in the ActiveTextField (whenever the text field is altered) | *
| componentEvent | *ComponentEvent | *See the {@link #addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the {@link #addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the {@link #addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the {@link #addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the {@link #addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
* import java.awt.*;
*
* public class ActiveTextFieldExample {
*
* public static void main (String argv[]) {
*
* final ActiveClosingFrame frame =
* new ActiveClosingFrame ("ActiveTextFieldExample Example");
*
* final Any2OneChannel event = Channel.any2one (new OverWriteOldestBuffer (10));
*
* final String[] string =
* {"Entia Non Sunt Multiplicanda Praeter Necessitatem",
* "Less is More ... More or Less",
* "Everything we do, we do it to you",
* "Race Hazards - What Rice Hozzers?",
* "Cogito Ergo Occam"};
*
* final String goodbye = "Goodbye World";
*
* final ActiveTextField[] activeText =
* new ActiveTextField[string.length];
*
* for (int i = 0; i < string.length; i++) {
* activeText[i] = new ActiveTextField (null, event.out (), string[i]);
* }
*
* Panel panel = new Panel (new GridLayout (string.length, 1));
* for (int i = 0; i < string.length; i++) {
* panel.add (activeText[i]);
* }
*
* final Frame realFrame = frame.getActiveFrame ();
* realFrame.setBackground (Color.green);
* realFrame.add (panel);
* realFrame.pack ();
* realFrame.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* frame,
* new Parallel (activeText),
* new CSProcess () {
* public void run () {
* boolean running = true;
* while (running) {
* String s = (String) event.in ().read ();
* System.out.println (s);
* running = (! s.equals (goodbye));
* }
* realFrame.setVisible (false);
* System.exit (0);
* }
* }
* }
* ).run ();
* }
*
* }
*
*
* @see org.jcsp.awt.ActiveTextEnterField
* @see java.awt.TextField
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveTextField extends TextField implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* Constructs a new ActiveTextField with no initial text,
* configuration or event channels.
*
*/
public ActiveTextField()
{
this(null, null, "", 0);
}
/**
* Constructs a new ActiveTextField with initial text and default width,
* but no configuration or event channels.
*
* @param s the initial text displayed in the field.
*/
public ActiveTextField(String s)
{
this(null, null, s, s.length());
}
/**
* Constructs a new ActiveTextField with initial text and width,
* but no configuration or event channels.
*
* @param s the initial text displayed in the field.
* @param columns the width of the field.
*/
public ActiveTextField(String s, int columns)
{
this(null, null, s, columns);
}
/**
* Constructs a new ActiveTextField with configuration and event channels,
* but no initial text.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the current text will be output when the text field is changed
* -- can be null if no notification is required.
*/
public ActiveTextField(ChannelInput configure, ChannelOutput event)
{
this(configure, event, "", 0);
}
/**
* Constructs a new ActiveTextField with configuration and event channels,
* initial text and default width.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the current text will be output when the text field is changed
* -- can be null if no notification is required.
* @param s the initial text displayed in the field.
*/
public ActiveTextField(ChannelInput configure, ChannelOutput event, String s)
{
this(configure, event, s, s.length());
}
/**
* Constructs a new ActiveTextField with configuration and event channels,
* initial text and width.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the current text will be output when the text field is changed
* -- can be null if no notification is required.
* @param s the initial text displayed in the field.
* @param columns the width of the field.
*/
public ActiveTextField(ChannelInput configure, ChannelOutput event, String s, int columns)
{
super(s, columns);
// Only create an event handler if the event Channel is not null.
if (event != null)
{
TextEventHandler handler = new TextEventHandler(event);
addTextListener(handler);
vec.addElement(handler);
}
this.configure = configure;
}
/**
* Sets the configuration channel for this ActiveTextField.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events.
* If the channel passed is null, no action will be taken.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* Add a new channel to this component that will be used to notify that
* a ComponentEvent has occurred. This should be used
* instead of registering a ComponentListener with the component. It is
* possible to add more than one channel by calling this method multiple times
* If the channel passed is null, no action will be taken.
* * NOTE: This method must be called before this process is run. * * @param componentEvent the channel down which to send ComponentEvents. */ public void addComponentEventChannel(ChannelOutput componentEvent) { if (componentEvent != null) { ComponentEventHandler handler = new ComponentEventHandler(componentEvent); addComponentListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a FocusEvent has occurred. This should be used * instead of registering a FocusListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param focusEvent the channel down which to send FocusEvents. */ public void addFocusEventChannel(ChannelOutput focusEvent) { if (focusEvent != null) { FocusEventHandler handler = new FocusEventHandler(focusEvent); addFocusListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a KeyEvent has occurred. This should be used * instead of registering a KeyListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param keyEvent the channel down which to send KeyEvents. */ public void addKeyEventChannel(ChannelOutput keyEvent) { if (keyEvent != null) { KeyEventHandler handler = new KeyEventHandler(keyEvent); addKeyListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseEvent has occurred. This should be used * instead of registering a MouseListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseEvent the channel down which to send MouseEvents. */ public void addMouseEventChannel(ChannelOutput mouseEvent) { if (mouseEvent != null) { MouseEventHandler handler = new MouseEventHandler(mouseEvent); addMouseListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseMotionEvent has occurred. This should be used * instead of registering a MouseMotionListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseMotionEvent the channel down which to send MouseMotionEvents. */ public void addMouseMotionEventChannel(ChannelOutput mouseMotionEvent) { if (mouseMotionEvent != null) { MouseMotionEventHandler handler = new MouseMotionEventHandler(mouseMotionEvent); addMouseMotionListener(handler); vec.addElement(handler); } } /** * This enables general configuration of this component. Any object implementing * this interface and sent down the configure channel to this component will have its * configure method invoked on this component. *
* For an example, see {@link ActiveApplet.Configure}. */ static public interface Configure { /** * @param textField the TextField being configured. */ public void configure(final TextField textField); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message instanceof String) setText((String) message); else if (message instanceof Boolean) { if (message == Boolean.TRUE) setEnabled(true); else if (message == Boolean.FALSE) setEnabled(false); } else if (message instanceof Configure) ((Configure) message).configure(this); else setText(message.toString()); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveCheckbox.java 0000644 0000000 0000000 00000046043 11105701167 017470 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.Checkbox java.awt.Checkbox} * with a channel interface. *
Process Diagram
*
Description
* ActiveCheckbox is a process extension of java.awt.Checkbox * with channels for run-time configuration and event notification. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure and event channels are * settable from a constructor. * The event channel delivers the generated java.awt.ItemEvent whenever * the ActiveCheckbox is operated. * Other event channels can be added to notify the occurrence of any other events * the component generates (by calling the appropriate * addXXXEventChannel method before the process is run). * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myCheckboxEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveCheckbox myCheckbox = * new ActiveCheckbox (null, myCheckboxEvent); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *String | ** Change the label for the ActiveCheckbox to the value of the String. * | *
| Boolean | *
*
|
* |
| ActiveCheckbox.Configure | *Invoke the user-defined Configure.configure method on the checkbox. | *|
| Output Channels | *||
| event | *ItemEvent | ** When the ActiveCheckbox is operated, * the generated java.awt.ItemEvent is written down this channel. * | *
| componentEvent | *ComponentEvent | *See the {@link #addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the {@link #addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the {@link #addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the {@link #addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the {@link #addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import java.awt.*;
* import java.awt.event.*;
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
*
* public class ActiveCheckboxExample {
*
* public static void main (String argv[]) {
*
* final Frame root = new Frame ("ActiveCheckbox Example");
*
* final String[] box = {"Hello World", "Rocket Science", "CSP",
* "Monitors", "Ignore Me", "Goodbye World"};
*
* final Any2OneChannel event = Channel.any2one (new OverWriteOldestBuffer (10));
*
* final ActiveCheckbox[] check = new ActiveCheckbox[box.length];
* for (int i = 0; i < box.length; i++) {
* check[i] = new ActiveCheckbox (null, event.out (), box[i]);
* }
*
* root.setSize (300, 200);
* root.setLayout (new GridLayout (box.length, 1));
* for (int i = 0; i < box.length; i++) {
* root.add (check[i]);
* }
* root.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* new Parallel (check),
* new CSProcess () {
* public void run () {
* boolean running = true;
* while (running) {
* final ItemEvent e = (ItemEvent) event.in ().read ();
* final String item = (String) e.getItem ();
* if (e.getStateChange () == ItemEvent.SELECTED) {
* System.out.println ("Checked ==> `" + item + "'");
* running = (item != box[box.length - 1]);
* } else {
* System.out.println ("Unchecked ==> `" + item + "'");
* }
* }
* root.setVisible (false);
* System.exit (0);
* }
* }
* }
* ).run ();
*
* }
*
* }
*
*
* @see java.awt.Checkbox
* @see java.awt.CheckboxGroup
* @see java.awt.event.ItemEvent
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveCheckbox extends Checkbox implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The Configurer.
*/
// private Configurer configurer = null;
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* Constructs an ActiveCheckbox with no label, initial state false
* and no configuration or event channels.
*/
public ActiveCheckbox()
{
this("");
}
/**
* Constructs an ActiveCheckbox with the label s, initial state false
* and no configuration or event channels.
*
* @param s the label displayed on the ActiveCheckbox.
*/
public ActiveCheckbox(String s)
{
this(s, false);
}
/**
* Constructs an ActiveCheckbox with the label s,
* initial state and no configuration or event channels.
*
* @param s the label displayed on the ActiveCheckbox.
* @param state the initial state of the ActiveCheckbox
* (true => on, false => off).
*/
public ActiveCheckbox(String s, boolean state)
{
this(s, state, null);
}
/**
* Constructs an ActiveCheckbox in the CheckboxGroup
* group with the label s,
* initial state and no configuration or event channels.
*
* @param s the label displayed on the ActiveCheckbox.
* @param state the initial state of the ActiveCheckbox.
* (true => on, false => off)
* @param group the CheckboxGroup for the ActiveCheckbox.
*/
public ActiveCheckbox(String s, boolean state, CheckboxGroup group)
{
this(null, null, s, state, group);
}
/**
* Constructs an ActiveCheckbox with no label, initial state false
* and configuration and event channels.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the ItemEvent will be output when the choice
* is exercised -- can be null if no notification is required.
*/
public ActiveCheckbox(ChannelInput configure, ChannelOutput event)
{
this(configure, event, "");
}
/**
* Constructs a ActiveCheckbox with the label s,
* initial state false and configuration and event channels.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the ItemEvent will be output when the choice
* is exercised -- can be null if no notification is required.
* @param s the label displayed on the ActiveCheckbox.
*/
public ActiveCheckbox(ChannelInput configure, ChannelOutput event, String s)
{
this(configure, event, s, false);
}
/**
* Constructs an ActiveCheckbox with the label s,
* initial state and configuration and event channels.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the ItemEvent will be output when the choice
* is exercised -- can be null if no notification is required.
* @param s the label displayed on the ActiveCheckbox.
* @param state the initial state of the ActiveCheckbox.
* (true => on, false => off)
*/
public ActiveCheckbox(ChannelInput configure, ChannelOutput event, String s, boolean state)
{
this(configure, event, s, state, null);
}
/**
* Constructs an ActiveCheckbox in the CheckboxGroup
* group with the label s, initial state
* and configuration and event channels.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the ItemEvent will be output when the choice
* is exercised -- can be null if no notification is required.
* @param s the label displayed on the ActiveCheckbox.
* @param state the initial state of the ActiveCheckbox.
* (true => on, false => off)
* @param group the CheckboxGroup for the ActiveCheckbox.
*/
public ActiveCheckbox(ChannelInput configure, ChannelOutput event,
String s, boolean state, CheckboxGroup group)
{
super(s, state, group);
if (event !=null)
{
ItemEventHandler handler = new ItemEventHandler(event);
addItemListener(handler);
vec.addElement(handler);
}
this.configure = configure;
}
/**
* Sets the configuration channel for this ActiveCheckbox.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* Add a new channel to this component that will be used to notify that
* a ComponentEvent has occurred. This should be used
* instead of registering a ComponentListener with the component. It is
* possible to add more than one channel by calling this method multiple times
* If the channel passed is null, no action will be taken.
* * NOTE: This method must be called before this process is run. * * @param componentEvent the channel down which to send ComponentEvents. */ public void addComponentEventChannel(ChannelOutput componentEvent) { if (componentEvent != null) { ComponentEventHandler handler = new ComponentEventHandler(componentEvent); addComponentListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a FocusEvent has occurred. This should be used * instead of registering a FocusListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param focusEvent the channel down which to send FocusEvents. */ public void addFocusEventChannel(ChannelOutput focusEvent) { if (focusEvent != null) { FocusEventHandler handler = new FocusEventHandler(focusEvent); addFocusListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a KeyEvent has occurred. This should be used * instead of registering a KeyListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param keyEvent the channel down which to send KeyEvents. */ public void addKeyEventChannel(ChannelOutput keyEvent) { if (keyEvent != null) { KeyEventHandler handler = new KeyEventHandler(keyEvent); addKeyListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseEvent has occurred. This should be used * instead of registering a MouseListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseEvent the channel down which to send MouseEvents. */ public void addMouseEventChannel(ChannelOutput mouseEvent) { if (mouseEvent != null) { MouseEventHandler handler = new MouseEventHandler(mouseEvent); addMouseListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseMotionEvent has occurred. This should be used * instead of registering a MouseMotionListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseMotionEvent the channel down which to send MouseMotionEvents. */ public void addMouseMotionEventChannel(ChannelOutput mouseMotionEvent) { if (mouseMotionEvent != null) { MouseMotionEventHandler handler = new MouseMotionEventHandler(mouseMotionEvent); addMouseMotionListener(handler); vec.addElement(handler); } } /** * This enables general configuration of this component. Any object implementing * this interface and sent down the configure channel to this component will have its * configure method invoked on this component. *
* For an example, see {@link ActiveApplet.Configure}. */ static public interface Configure { /** * @param checkbox the Checkbox being configured. */ public void configure(final Checkbox checkbox); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message instanceof String) setLabel((String) message); else if (message instanceof Boolean) { if (message == Boolean.TRUE) setEnabled(true); else if (message == Boolean.FALSE) setEnabled(false); else setState(((Boolean) message).booleanValue()); } else if (message instanceof Configure) ((Configure) message).configure(this); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ItemEventHandler.java 0000644 0000000 0000000 00000005603 11105701167 020001 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.event.*; import org.jcsp.lang.*; /** * @author P.D. Austin and P.H. Welch */ class ItemEventHandler implements ItemListener { /** * The Channel down which ItemEvent notifications are sent. */ private ChannelOutput event; /** * constructs a new ItemEventHandler with the specified event Channel. * * @param event The Channel ItemEvent notifications are sent down. */ public ItemEventHandler(ChannelOutput event) { this.event = event; } /** * Invoked when an item change occurs on the component the event handler is * listening to. Notifies the event process that an ItemEvent has * occurred. Some notifications will be lost so there are no guarantees * that all events generated will be processed. * * @param e The parameters associated with this event */ public void itemStateChanged(ItemEvent e) { event.write(e); } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveTextArea.java 0000644 0000000 0000000 00000046715 11105701167 017465 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.TextArea java.awt.TextArea} * with a channel interface. *
Process Diagram
*
*
Description
* ActiveTextArea is a process extension of java.awt.TextArea * with channels for run-time configuration and event notification. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure and event channels are * settable from a constructor. * The event channel delivers updated text whenever * the ActiveTextArea is changed. * Other event channels can be added to notify the occurrence of any other events * the component generates (by calling the appropriate * addxxxEventChannel method before the process is run). * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myTextAreaEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveTextArea myTextArea = * new ActiveTextArea (null, myTextAreaEvent.out (), "Edit Me", 5, 20); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *String | *Append the string to the text in this ActiveTextArea | *
| Boolean | *
*
|
* |
| ActiveTextArea.Configure | *Invoke the user-defined Configure.configure method on the textArea. | *|
| otherwise ... | *Append the toString form of the object to the text in this ActiveTextArea. | *|
| Output Channels | *||
| event | *String | *The text in the ActiveTextArea (whenever the text area is altered) | *
| componentEvent | *ComponentEvent | *See the {@link ActiveTextArea#addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the {@link ActiveTextArea#addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the {@link ActiveTextArea#addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the {@link ActiveTextArea#addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the {@link ActiveTextArea#addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
* import java.awt.*;
*
* public class ActiveTextAreaExample {
*
* public static void main (String argv[]) {
*
* final ActiveClosingFrame frame =
* new ActiveClosingFrame ("ActiveTextAreaExample Example");
*
* final Any2OneChannel event = Channel.any2one (new OverWriteOldestBuffer (10));
*
* final String[] string =
* {"Entia Non Sunt Multiplicanda Praeter Necessitatem",
* "Everything we do, we do it to you",
* "Race Hazards - What Rice Hozzers?",
* "Cogito Ergo Occam"};
*
* final String goodbye = "Goodbye World";
*
* final ActiveTextArea[] activeText =
* new ActiveTextArea[string.length];
*
* for (int i = 0; i < string.length; i++) {
* activeText[i] = new ActiveTextArea (null, event.out (), string[i], 5, 40);
* }
*
* Panel panel = new Panel (new GridLayout (string.length/2, 2));
* for (int i = 0; i < string.length; i++) {
* panel.add (activeText[i]);
* }
*
* final Frame realFrame = frame.getActiveFrame ();
* realFrame.setBackground (Color.green);
* realFrame.add (panel);
* realFrame.pack ();
* realFrame.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* frame,
* new Parallel (activeText),
* new CSProcess () {
* public void run () {
* boolean running = true;
* while (running) {
* String s = (String) event.in ().read ();
* System.out.println (s);
* running = (! s.equals (goodbye));
* }
* realFrame.setVisible (false);
* System.exit (0);
* }
* }
* }
* ).run ();
* }
*
* }
*
*
* @see org.jcsp.awt.ActiveTextEnterArea
* @see java.awt.TextArea
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveTextArea extends TextArea implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* Constructs a new ActiveTextArea with scrollbars, but with no configuration
* or event channels or initial text or size.
*/
public ActiveTextArea()
{
this(null, null, "", 0, 0, SCROLLBARS_BOTH);
}
/**
* Constructs a new ActiveTextArea with scrollbars and initial text,
* but with no configuration or event channels or initial size.
*
* @param s the initial text displayed in the area.
*/
public ActiveTextArea(String s)
{
this(null, null, s, 0, 0, SCROLLBARS_BOTH);
}
/**
* Constructs a new ActiveTextArea with scrollbars and initial text and size,
* but with no configuration or event channels.
*
* @param s the initial text displayed in the area.
* @param rows the rows of the area.
* @param columns the columns of the area.
*/
public ActiveTextArea(String s, int rows, int columns)
{
this(null, null, s, rows, columns, SCROLLBARS_BOTH);
}
/**
* Constructs a new ActiveTextArea with user-defined scrollbars and initial text and size,
* but with no configuration or event channels.
*
* @param s the initial text displayed in the area.
* @param rows the rows of the area.
* @param columns the columns of the area.
* @param scrollbars the columns of the area (java.awt.TextArea.SCROLLBARS_BOTH,
* java.awt.TextArea.SCROLLBARS_VERTICAL_ONLY,
* java.awt.TextArea.SCROLLBARS_HORIZONTAL_ONLY
* or java.awt.TextArea.SCROLLBARS_NONE).
*/
public ActiveTextArea(String s, int rows, int columns, int scrollbars)
{
this(null, null, s, rows, columns, scrollbars);
}
/**
* Constructs a new ActiveTextArea with configuration and event channels and scrollbars,
* but with no initial text or size.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the current text will be output when the text area is changed
* -- can be null if no notification is required.
*/
public ActiveTextArea(ChannelInput configure, ChannelOutput event)
{
this(configure, event, "", 0, 0, SCROLLBARS_BOTH);
}
/**
* Constructs a new ActiveTextArea with configuration and event channels
* and scrollbars and initial text, but with no initial size.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the current text will be output when the text area is changed
* -- can be null if no notification is required.
* @param s the initial text displayed in the area.
*/
public ActiveTextArea(ChannelInput configure, ChannelOutput event, String s)
{
this(configure, event, s, 0, 0, SCROLLBARS_BOTH);
}
/**
* Constructs a new ActiveTextArea with configuration and event channels
* and scrollbars and initial text and size.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the current text will be output when the text area is changed
* -- can be null if no notification is required.
* @param s the initial text displayed in the area.
* @param rows the rows of the area.
* @param columns the columns of the area.
*/
public ActiveTextArea(ChannelInput configure, ChannelOutput event,
String s, int rows, int columns)
{
this(configure, event, s, rows, columns, SCROLLBARS_BOTH);
}
/**
* Constructs a new ActiveTextArea with configuration and event channels
* and user-defined scrollbars and initial text and size.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the current text will be output when the text area is changed
* -- can be null if no notification is required.
* @param s the initial text displayed in the area.
* @param rows the rows of the area.
* @param columns the columns of the area.
* @param scrollbars the columns of the area (java.awt.TextArea.SCROLLBARS_BOTH,
* java.awt.TextArea.SCROLLBARS_VERTICAL_ONLY,
* java.awt.TextArea.SCROLLBARS_HORIZONTAL_ONLY
* or java.awt.TextArea.SCROLLBARS_NONE).
*/
public ActiveTextArea(ChannelInput configure, ChannelOutput event,
String s, int rows, int columns, int scrollbars)
{
super(s, rows, columns, scrollbars);
if (event != null)
{
TextEventHandler handler = new TextEventHandler(event);
addTextListener(handler);
vec.addElement(handler);
}
this.configure = configure;
}
/**
* Sets the configuration channel for this ActiveTextArea.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* Add a new channel to this component that will be used to notify that
* a ComponentEvent has occurred. This should be used
* instead of registering a ComponentListener with the component. It is
* possible to add more than one channel by calling this method multiple times
* If the channel passed is null, no action will be taken.
* * NOTE: This method must be called before this process is run. * * @param componentEvent the channel down which to send ComponentEvents. */ public void addComponentEventChannel(ChannelOutput componentEvent) { if (componentEvent != null) { ComponentEventHandler handler = new ComponentEventHandler(componentEvent); addComponentListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a FocusEvent has occurred. This should be used * instead of registering a FocusListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param focusEvent the channel down which to send FocusEvents. */ public void addFocusEventChannel(ChannelOutput focusEvent) { if (focusEvent != null) { FocusEventHandler handler = new FocusEventHandler(focusEvent); addFocusListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a KeyEvent has occurred. This should be used * instead of registering a KeyListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param keyEvent the channel down which to send KeyEvents. */ public void addKeyEventChannel(ChannelOutput keyEvent) { if (keyEvent != null) { KeyEventHandler handler = new KeyEventHandler(keyEvent); addKeyListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseEvent has occurred. This should be used * instead of registering a MouseListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseEvent the channel down which to send MouseEvents. */ public void addMouseEventChannel(ChannelOutput mouseEvent) { if (mouseEvent != null) { MouseEventHandler handler = new MouseEventHandler(mouseEvent); addMouseListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseMotionEvent has occurred. This should be used * instead of registering a MouseMotionListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseMotionEvent the channel down which to send MouseMotionEvents. */ public void addMouseMotionEventChannel(ChannelOutput mouseMotionEvent) { if (mouseMotionEvent != null) { MouseMotionEventHandler handler = new MouseMotionEventHandler(mouseMotionEvent); addMouseMotionListener(handler); vec.addElement(handler); } } /** * This enables general configuration of this component. Any object implementing * this interface and sent down the configure channel to this component will have its * configure method invoked on this component. *
* For an example, see {@link ActiveApplet.Configure}. */ static public interface Configure { /** * @param textArea the TextArea being configured. */ public void configure(final TextArea textArea); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message instanceof String) append((String) message); else if (message instanceof Boolean) { if (message == Boolean.TRUE) setEnabled(true); else if (message == Boolean.FALSE) setEnabled(false); } else if (message instanceof Configure) ((Configure) message).configure(this); else append(message.toString()); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveScrollbar.java 0000644 0000000 0000000 00000046213 11105701167 017664 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.Scrollbar java.awt.Scrollbar} * with a channel interface. *
Process Diagram
*
*
Description
* ActiveScrollbar is a process extension of java.awt.Scrollbar * with channels for run-time configuration and event notification. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure and event channels are * settable from a constructor. * The event channel delivers the adjusted value whenever * the ActiveScrollbar is moved. * Other event channels can be added to notify the occurrence of any other events * the component generates (by calling the appropriate * addXXXEventChannel method before the process is run). * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannelInt myScrollbarEvent = Channel.one2oneInt (new OverWriteOldestBuffer (n)); * * final ActiveScrollbar myScrollbar = * new ActiveScrollbar (null, myScrollbarEvent.out (), Scrollbar.HORIZONTAL, 0, 10, 0, 110); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *Integer | *Sets the value of the scrollbar to the value received | *
| Boolean | *
*
|
* |
| ActiveScrollbar.Configure | *Invoke the user-defined Configure.configure method on the scrollbar. | *|
| Output Channels | *||
| event | *int | ** The new value of the scrollbar * | *
| componentEvent | *ComponentEvent | *See the {@link #addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the {@link #addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the {@link #addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the {@link #addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the {@link #addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import java.awt.*;
* import java.awt.event.*;
* import org.jcsp.lang.*;
* import org.jcsp.util.ints.*;
* import org.jcsp.awt.*;
*
* public class ActiveScrollbarExample {
*
* public static void main (String argv[]) {
*
* final ActiveClosingFrame activeFrame = new ActiveClosingFrame ("ActiveScrollbar Example");
*
* final One2OneChannel configure = Channel.one2one ();
* final One2OneChannelInt scrollEvent = Channel.one2oneInt (new OverWriteOldestBufferInt (10));
*
* final ActiveScrollbar scrollBar =
* new ActiveScrollbar (
* null, scrollEvent.out (), Scrollbar.HORIZONTAL, 0, 10, 0, 110
* );
*
* final Frame realFrame = activeFrame.getActiveFrame ();
* realFrame.setSize (400, 75);
* realFrame.add (scrollBar);
* realFrame.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* activeFrame,
* scrollBar,
* new CSProcess () {
* public void run () {
* final long FREE_TIME = 10000, BUSY_TIME = 250;
* CSTimer tim = new CSTimer ();
* Alternative alt = new Alternative (new Guard[] {tim, scrollEvent.in ()});
* final int TIM = 0, SCROLL = 1;
* long timeout = tim.read ();
* tim.setAlarm (timeout + FREE_TIME);
* boolean running = true;
* while (running) {
* switch (alt.priSelect ()) {
* case TIM: // timeout happened
* configure.out ().write (Boolean.FALSE); // disable scrollbar
* for (int i = 40; i > 0; i--) {
* System.out.println ("*** busy busy busy ... " + i);
* timeout = tim.read ();
* tim.after (timeout + BUSY_TIME);
* }
* System.out.println ("*** free free free ... 0");
* configure.out ().write (Boolean.TRUE); // enable scrollbar
* timeout = tim.read ();
* tim.setAlarm (timeout + FREE_TIME);
* break;
* case SCROLL: // scrollEvent happened
* int position = scrollEvent.in ().read ();
* System.out.println ("ScrollBar ==> " + position);
* running = (position != 100);
* break;
* }
* }
* realFrame.setVisible (false);
* System.exit (0);
* }
* }
* }
* ).run ();
* }
*
* }
*
*
* @see java.awt.Scrollbar
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveScrollbar extends Scrollbar implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* Constructs a vertical ActiveScrollbar with no configuration
* or event channels.
*/
public ActiveScrollbar()
{
this(Scrollbar.VERTICAL);
}
/**
* Constructs a ActiveScrollbar with the specified orientation, but still with no
* configuration or event channels. The minimum and maximum values default to 0 and 100,
* with the initial setting at 0.
*
* @param orientation indicates the orientation of the scroll bar
* (Scrollbar.VERTICAL, Scrollbar.HORIZONTAL).
*/
public ActiveScrollbar(int orientation)
{
this(orientation, 0, 10, 0, 110);
}
/**
* Constructs a ActiveScrollbar with all its options, but still with no
* configuration or event channels.
*
* @param orientation indicates the orientation of the scroll bar
* (Scrollbar.VERTICAL, Scrollbar.HORIZONTAL).
* @param value the initial value of the scroll bar.
* @param visible the size of the scroll bar's bubble, representing the visible portion; the scroll bar uses this value when paging up or down by a page.
* @param minimum the minimum value of the scroll bar.
* @param maximum the maximum value of the scroll bar.
*/
public ActiveScrollbar(int orientation, int value, int visible, int minimum, int maximum)
{
this(null, null, orientation, value, visible, minimum, maximum);
}
/**
* Constructs a vertical ActiveScrollbar with configuration and event channels.
* The minimum and maximum values default to 0 and 100, with the initial setting at 0.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the adjusted value will be output when the scrollbar is moved
* -- can be null if no notification is required.
*/
public ActiveScrollbar(ChannelInput configure, ChannelOutputInt event)
{
this(configure, event, Scrollbar.VERTICAL);
}
/**
* Constructs a ActiveScrollbar with configuration and event channels and
* the specified orientation.
* The minimum and maximum values default to 0 and 100, with the initial setting at 0.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the adjusted value will be output when the scrollbar is moved
* -- can be null if no notification is required.
* @param orientation indicates the orientation of the scroll bar
* (Scrollbar.VERTICAL, Scrollbar.HORIZONTAL).
*/
public ActiveScrollbar(ChannelInput configure, ChannelOutputInt event, int orientation)
{
this(configure, event, orientation, 0, 10, 0, 110);
}
/**
* Constructs a ActiveScrollbar with configuration and event channels and
* all its options.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the adjusted value will be output when the scrollbar is moved
* -- can be null if no notification is required.
* @param orientation indicates the orientation of the scroll bar
* (Scrollbar.VERTICAL, Scrollbar.HORIZONTAL).
* @param value the initial value of the scroll bar.
* @param visible the size of the scroll bar's bubble, representing the visible portion; the scroll bar uses this value when paging up or down by a page.
* @param minimum the minimum value of the scroll bar.
* @param maximum the maximum value of the scroll bar.
*/
public ActiveScrollbar(ChannelInput configure, ChannelOutputInt event,
int orientation, int value, int visible, int minimum, int maximum)
{
super(orientation, value, visible, minimum, maximum);
if (event != null)
{
AdjustmentEventHandler handler = new AdjustmentEventHandler(event);
addAdjustmentListener(handler);
vec.addElement(handler);
}
this.configure = configure;
}
/**
* Sets the configuration channel for this ActiveScrollbar.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* Add a new channel to this component that will be used to notify that
* a ComponentEvent has occurred. This should be used
* instead of registering a ComponentListener with the component. It is
* possible to add more than one channel by calling this method multiple times
* If the channel passed is null, no action will be taken.
* * NOTE: This method must be called before this process is run. * * @param componentEvent the channel down which to send ComponentEvents. */ public void addComponentEventChannel(ChannelOutput componentEvent) { if (componentEvent != null) { ComponentEventHandler handler = new ComponentEventHandler(componentEvent); addComponentListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a FocusEvent has occurred. This should be used * instead of registering a FocusListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param focusEvent the channel down which to send FocusEvents. */ public void addFocusEventChannel(ChannelOutput focusEvent) { if (focusEvent != null) { FocusEventHandler handler = new FocusEventHandler(focusEvent); addFocusListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a KeyEvent has occurred. This should be used * instead of registering a KeyListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param keyEvent the channel down which to send KeyEvents. */ public void addKeyEventChannel(ChannelOutput keyEvent) { if (keyEvent != null) { KeyEventHandler handler = new KeyEventHandler(keyEvent); addKeyListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseEvent has occurred. This should be used * instead of registering a MouseListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseEvent the channel down which to send MouseEvents. */ public void addMouseEventChannel(ChannelOutput mouseEvent) { if (mouseEvent != null) { MouseEventHandler handler = new MouseEventHandler(mouseEvent); addMouseListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseMotionEvent has occurred. This should be used * instead of registering a MouseMotionListener with the component. It is * possible to add more than one channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseMotionEvent the channel down which to send MouseMotionEvents. */ public void addMouseMotionEventChannel(ChannelOutput mouseMotionEvent) { if (mouseMotionEvent != null) { MouseMotionEventHandler handler = new MouseMotionEventHandler(mouseMotionEvent); addMouseMotionListener(handler); vec.addElement(handler); } } /** * This enables general configuration of this component. Any object implementing * this interface and sent down the configure channel to this component will have its * configure method invoked on this component. *
* For an example, see {@link ActiveApplet.Configure}. */ static public interface Configure { /** * @param scrollbar the Scrollbar being configured. */ public void configure(final Scrollbar scrollbar); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message instanceof Integer) setValue(((Integer) message).intValue()); else if (message instanceof Boolean) { if (message == Boolean.TRUE) setEnabled(true); else if (message == Boolean.FALSE) setEnabled(false); } else if (message instanceof Configure) ((Configure) message).configure(this); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/FocusEventHandler.java 0000644 0000000 0000000 00000006577 11105701167 020175 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import org.jcsp.lang.*; import java.awt.event.*; /** * @author P.D. Austin and P.H. Welch */ class FocusEventHandler implements FocusListener { /** * The Channel action event notifications are sent down. */ private ChannelOutput event; /** * constructs a new FocusEventHandler with the specified output Channel. * * @param event The Channel to send the event notification down */ public FocusEventHandler(ChannelOutput event) { this.event = event; } /** * Invoked when the Component the event handler is listening to Gains the * input Focus. Notifies the event process that a FocusEvent has * occurred by sending the FocusEvent Object. Some notifications will be * lost so there are no guarantees that all events generated will be * processed. * * @param e The parameters associated with this event */ public void focusGained(FocusEvent e) { event.write(e); } /** * Invoked when the Component the event handler is listening to Gains the * input Focus. Notifies the event process that a FocusEvent has * occurred by sending the FocusEvent Object. Some notifications will be * lost so there are no guarantees that all events generated will be * processed. * * @param e The parameters associated with this event */ public void focusLost(FocusEvent e) { event.write(e); } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/GraphicsCommand.java 0000644 0000000 0000000 00000061703 11105701167 017645 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import org.jcsp.lang.TaggedProtocol; /** * This is the tagged protocol interpreted by objects * (such as {@link DisplayList}) that implement the {@link Display} interface. *
Description
* GraphicsCommand is the {@link org.jcsp.lang.TaggedProtocol} interpreted by * objects (such as {@link DisplayList}) that implement the {@link Display} interface. * It is a collection of static graphics command classes * and a couple of immutable graphics command objects. * The constructors for each command class set the parameters for the command. * The immutable objects are commands that take no parameters. ** A Display object provides a secure interface between an active user * process and an active graphics component (such as {@link ActiveCanvas}). * It enables all methods of java.awt.graphics * to be executed on the active graphics component. * User processes send an array of GraphicsCommands * by invoking {@link Display#set set}, * {@link Display#extend extend} or {@link Display#change change} * on the Display. *
* The meaning of each command is defined by the corresponding method * in java.awt.graphics. For example, the {@link GraphicsCommand.DrawImage} * constructors correspond to the java.awt.graphics.drawImage methods. * * @see org.jcsp.awt.Display * @see org.jcsp.awt.DisplayList * @see org.jcsp.awt.ActiveCanvas * @see org.jcsp.lang.TaggedProtocol * * @author P.H. Welch */ public abstract class GraphicsCommand extends TaggedProtocol { GraphicsCommand(final int tag) { super(tag); } static final int NULL_TAG = 0; static final int TRANSLATE = 1; static final int SET_COLOR = 2; static final int SET_PAINT_MODE_TAG = 3; static final int SET_XOR_MODE = 4; static final int SET_FONT = 5; static final int CLIP_RECT = 6; static final int SET_CLIP = 7; static final int COPY_AREA = 8; static final int DRAW_LINE = 9; static final int FILL_RECT = 10; static final int DRAW_RECT = 11; static final int CLEAR_RECT = 12; static final int DRAW_ROUND_RECT = 13; static final int FILL_ROUND_RECT = 14; static final int DRAW_3D_RECT = 15; static final int FILL_3D_RECT = 16; static final int DRAW_OVAL = 17; static final int FILL_OVAL = 18; static final int DRAW_ARC = 19; static final int FILL_ARC = 20; static final int DRAW_POLYLINE = 21; static final int DRAW_POLYGON = 22; static final int FILL_POLYGON = 23; static final int DRAW_STRING = 24; static final int DRAW_CHARS = 25; static final int DRAW_BYTES = 26; static final int DRAW_IMAGE = 27; static final int GENERAL = 28; static private final class Null extends GraphicsCommand { public Null() { super(NULL_TAG); } } /** * This is the null command whose interpretation is a no-op. */ static public final GraphicsCommand NULL = new Null(); /** * This is the (immutable) command object for * {@link java.awt.Graphics#translate java.awt.Graphics.translate}. */ static public final class Translate extends GraphicsCommand { final int x; final int y; public Translate(final int x, final int y) { super(TRANSLATE); this.x = x; this.y = y; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#setColor java.awt.Graphics.setColor}. */ static public final class SetColor extends GraphicsCommand { final Color c; public SetColor(final Color c) { super(SET_COLOR); this.c = c; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#setPaintMode java.awt.Graphics.setPaintMode}. */ static private final class SetPaintMode extends GraphicsCommand { public SetPaintMode() { super(SET_PAINT_MODE_TAG); } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#setPaintMode java.awt.Graphics.setPaintMode}. */ static public final GraphicsCommand SET_PAINT_MODE = new SetPaintMode(); /** * This is the (immutable) command object for * {@link java.awt.Graphics#setXORMode java.awt.Graphics.setXORMode}. */ static public final class SetXORMode extends GraphicsCommand { final Color c; public SetXORMode(final Color c) { super(SET_XOR_MODE); this.c = c; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#setFont java.awt.Graphics.setFont}. */ static public final class SetFont extends GraphicsCommand { final Font f; public SetFont(final Font f) { super(SET_FONT); this.f = f; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#clipRect java.awt.Graphics.clipRect}. */ static public final class ClipRect extends GraphicsCommand { final int x; final int y; final int width; final int height; public ClipRect(final int x, final int y, final int width, final int height) { super(CLIP_RECT); this.x = x; this.y = y; this.width = width; this.height = height; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#setClip java.awt.Graphics.setClip}. */ static public final class SetClip extends GraphicsCommand { final int cliptag; final int x; final int y; final int width; final int height; final Shape s; public SetClip(final int x, final int y, final int width, final int height) { super(SET_CLIP); this.cliptag = 0; this.x = x; this.y = y; this.width = width; this.height = height; this.s = null; } public SetClip(final Shape s) { super(SET_CLIP); this.cliptag = 1; this.s = s; this.x = 0; this.y = 0; this.width = 0; this.height = 0; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#copyArea java.awt.Graphics.copyArea}. */ static public final class CopyArea extends GraphicsCommand { final int x; final int y; final int width; final int height; final int dx; final int dy; public CopyArea(final int x, final int y, final int width, final int height, final int dx, final int dy) { super(COPY_AREA); this.x = x; this.y = y; this.width = width; this.height = height; this.dx = dx; this.dy = dy; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#drawLine java.awt.Graphics.drawLine}. */ static public final class DrawLine extends GraphicsCommand { final int x1; final int y1; final int x2; final int y2; public DrawLine(final int x1, final int y1, final int x2, final int y2) { super(DRAW_LINE); this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#fillRect java.awt.Graphics.fillRect}. */ static public final class FillRect extends GraphicsCommand { final int x; final int y; final int width; final int height; public FillRect(final int x, final int y, final int width, final int height) { super(FILL_RECT); this.x = x; this.y = y; this.width = width; this.height = height; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#drawRect java.awt.Graphics.drawRect}. */ static public final class DrawRect extends GraphicsCommand { final int x; final int y; final int width; final int height; public DrawRect(final int x, final int y, final int width, final int height) { super(DRAW_RECT); this.x = x; this.y = y; this.width = width; this.height = height; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#clearRect java.awt.Graphics.clearRect}. */ static public final class ClearRect extends GraphicsCommand { final int x; final int y; final int width; final int height; public ClearRect(final int x, final int y, final int width, final int height) { super(CLEAR_RECT); this.x = x; this.y = y; this.width = width; this.height = height; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#drawRoundRect java.awt.Graphics.drawRoundRect}. */ static public final class DrawRoundRect extends GraphicsCommand { final int x; final int y; final int width; final int height; final int arcWidth; final int arcHeight; public DrawRoundRect(final int x, final int y, final int width, final int height, final int arcWidth, final int arcHeight) { super(DRAW_ROUND_RECT); this.x = x; this.y = y; this.width = width; this.height = height; this.arcWidth = arcWidth; this.arcHeight = arcHeight; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#fillRoundRect java.awt.Graphics.fillRoundRect}. */ static public final class FillRoundRect extends GraphicsCommand { final int x; final int y; final int width; final int height; final int arcWidth; final int arcHeight; public FillRoundRect(final int x, final int y, final int width, final int height, final int arcWidth, final int arcHeight) { super(FILL_ROUND_RECT); this.x = x; this.y = y; this.width = width; this.height = height; this.arcWidth = arcWidth; this.arcHeight = arcHeight; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#draw3DRect java.awt.Graphics.draw3DRect}. */ static public final class Draw3DRect extends GraphicsCommand { final int x; final int y; final int width; final int height; final boolean raised; public Draw3DRect(final int x, final int y, final int width, final int height, final boolean raised) { super(DRAW_3D_RECT); this.x = x; this.y = y; this.width = width; this.height = height; this.raised = raised; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#translate java.awt.Graphics.translate}. */ static public final class Fill3DRect extends GraphicsCommand { final int x; final int y; final int width; final int height; final boolean raised; public Fill3DRect(final int x, final int y, final int width, final int height, final boolean raised) { super(FILL_3D_RECT); this.x = x; this.y = y; this.width = width; this.height = height; this.raised = raised; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#drawOval java.awt.Graphics.drawOval}. */ static public final class DrawOval extends GraphicsCommand { final int x; final int y; final int width; final int height; public DrawOval(final int x, final int y, final int width, final int height) { super(DRAW_OVAL); this.x = x; this.y = y; this.width = width; this.height = height; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#fillOval java.awt.Graphics.fillOval}. */ static public final class FillOval extends GraphicsCommand { final int x; final int y; final int width; final int height; public FillOval(final int x, final int y, final int width, final int height) { super(FILL_OVAL); this.x = x; this.y = y; this.width = width; this.height = height; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#drawArc java.awt.Graphics.drawArc}. */ static public final class DrawArc extends GraphicsCommand { final int x; final int y; final int width; final int height; final int startAngle; final int arcAngle; public DrawArc(final int x, final int y, final int width, final int height, final int startAngle, final int arcAngle) { super(DRAW_ARC); this.x = x; this.y = y; this.width = width; this.height = height; this.startAngle = startAngle; this.arcAngle = arcAngle; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#fillArc java.awt.Graphics.fillArc}. */ static public final class FillArc extends GraphicsCommand { final int x; final int y; final int width; final int height; final int startAngle; final int arcAngle; public FillArc(final int x, final int y, final int width, final int height, final int startAngle, final int arcAngle) { super(FILL_ARC); this.x = x; this.y = y; this.width = width; this.height = height; this.startAngle = startAngle; this.arcAngle = arcAngle; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#drawPolyline java.awt.Graphics.drawPolyline}. */ static public final class DrawPolyline extends GraphicsCommand { final int[] xPoints; final int[] yPoints; final int nPoints; public DrawPolyline(final int[] xPoints, final int[] yPoints, final int nPoints) { super(DRAW_POLYLINE); this.xPoints = xPoints; this.yPoints = yPoints; this.nPoints = nPoints; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#drawPolygon java.awt.Graphics.drawPolygon}. */ static public final class DrawPolygon extends GraphicsCommand { final int polytag; final int[] xPoints; final int[] yPoints; final int nPoints; final Polygon p; public DrawPolygon(final int[] xPoints, final int[] yPoints, final int nPoints) { super(DRAW_POLYGON); this.polytag = 0; this.xPoints = xPoints; this.yPoints = yPoints; this.nPoints = nPoints; this.p = null; } public DrawPolygon(final Polygon p) { super(DRAW_POLYGON); this.polytag = 1; this.p = p; this.xPoints = null; this.yPoints = null; this.nPoints = 0; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#fillPolygon java.awt.Graphics.fillPolygon}. */ static public final class FillPolygon extends GraphicsCommand { final int polytag; final int[] xPoints; final int[] yPoints; final int nPoints; final Polygon p; public FillPolygon(final int[] xPoints, final int[] yPoints, final int nPoints) { super(FILL_POLYGON); this.polytag = 0; this.xPoints = xPoints; this.yPoints = yPoints; this.nPoints = nPoints; this.p = null; } public FillPolygon(final Polygon p) { super(FILL_POLYGON); this.polytag = 1; this.p = p; this.xPoints = null; this.yPoints = null; this.nPoints = 0; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#drawString java.awt.Graphics.drawString}. */ static public final class DrawString extends GraphicsCommand { final String string; final int x; final int y; public DrawString(final String string, final int x, final int y) { super(DRAW_STRING); this.string = string; this.x = x; this.y = y; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#drawChars java.awt.Graphics.drawChars}. */ static public final class DrawChars extends GraphicsCommand { final char[] data; final int offset; final int length; final int x; final int y; public DrawChars(final char[] data, final int offset, final int length, final int x, final int y) { super(DRAW_CHARS); this.data = data; this.offset = offset; this.length = length; this.x = x; this.y = y; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#drawBytes java.awt.Graphics.drawBytes}. */ static public final class DrawBytes extends GraphicsCommand { final byte[] data; final int offset; final int length; final int x; final int y; public DrawBytes(final byte[] data, final int offset, final int length, final int x, final int y) { super(DRAW_BYTES); this.data = data; this.offset = offset; this.length = length; this.x = x; this.y = y; } } /** * This is the (immutable) command object for * {@link java.awt.Graphics#drawImage java.awt.Graphics.drawImage}. */ static public final class DrawImage extends GraphicsCommand { final int drawtag; final Image image; final int x; final int y; final int width; final int height; final Color bgcolor; final int dx1, dy1, dx2, dy2; final int sx1, sy1, sx2, sy2; public DrawImage(final Image image, final int x, final int y) { super(DRAW_IMAGE); this.drawtag = 0; this.image = image; this.x = x; this.y = y; this.width = 0; this.height = 0; this.bgcolor = null; this.dx1 = 0; this.dy1 = 0; this.dx2 = 0; this.dy2 = 0; this.sx1 = 0; this.sy1 = 0; this.sx2 = 0; this.sy2 = 0; } public DrawImage(final Image image, final int x, final int y, final int width, final int height) { super(DRAW_IMAGE); this.drawtag = 1; this.image = image; this.x = x; this.y = y; this.width = width; this.height = height; this.bgcolor = null; this.dx1 = 0; this.dy1 = 0; this.dx2 = 0; this.dy2 = 0; this.sx1 = 0; this.sy1 = 0; this.sx2 = 0; this.sy2 = 0; } public DrawImage(final Image image, final int x, final int y, final Color bgcolor) { super(DRAW_IMAGE); this.drawtag = 2; this.image = image; this.x = x; this.y = y; this.bgcolor = bgcolor; this.width = 0; this.height = 0; this.dx1 = 0; this.dy1 = 0; this.dx2 = 0; this.dy2 = 0; this.sx1 = 0; this.sy1 = 0; this.sx2 = 0; this.sy2 = 0; } public DrawImage(final Image image, final int x, final int y, final int width, final int height, final Color bgcolor) { super(DRAW_IMAGE); this.drawtag = 3; this.image = image; this.x = x; this.y = y; this.width = width; this.height = height; this.bgcolor = bgcolor; this.dx1 = 0; this.dy1 = 0; this.dx2 = 0; this.dy2 = 0; this.sx1 = 0; this.sy1 = 0; this.sx2 = 0; this.sy2 = 0; } public DrawImage(final Image image, final int dx1, final int dy1, final int dx2, final int dy2, final int sx1, final int sy1, final int sx2, final int sy2) { super(DRAW_IMAGE); this.drawtag = 4; this.image = image; this.dx1 = dx1; this.dy1 = dy1; this.dx2 = dx2; this.dy2 = dy2; this.sx1 = sx1; this.sy1 = sy1; this.sx2 = sx2; this.sy2 = sy2; this.x = 0; this.y = 0; this.width = 0; this.height = 0; this.bgcolor = null; } public DrawImage(final Image image, final int dx1, final int dy1, final int dx2, final int dy2, final int sx1, final int sy1, final int sx2, final int sy2, final Color bgcolor) { super(DRAW_IMAGE); this.drawtag = 5; this.image = image; this.dx1 = dx1; this.dy1 = dy1; this.dx2 = dx2; this.dy2 = dy2; this.sx1 = sx1; this.sy1 = sy1; this.sx2 = sx2; this.sy2 = sy2; this.bgcolor = bgcolor; this.x = 0; this.y = 0; this.width = 0; this.height = 0; } } /** * This is the interface allowing any set of {@link java.awt.Graphics} * operations to be wrapped up in an object and sent down a {@link Display} * channel to an Active graphics component. See {@link GraphicsCommand.General} */ static public interface Graphic { public void doGraphic(final Graphics g, final Component c); } /** * This is the command object holding a {@link GraphicsCommand.Graphic} object * implementing an arbitrary set of graphics operations. */ static public final class General extends GraphicsCommand { final Graphic g; public General(final Graphic g) { super(GENERAL); this.g = g; } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveButtonControl.java 0000644 0000000 0000000 00000056345 11105701167 020564 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import org.jcsp.lang.*; /** * This is a user-programmable finite state machine for * controlling an array of {@link ActiveButton}s. *
Process Diagram
*
Description
* ActiveButtonControl is a user-programmable finite state machine for * controlling an array of {@link ActiveButton}s. It is connected to the array * by its event and configure channels, matching pairs of which * must be attached to individual buttons. A button push generates a message down * the attached event channel, which triggers a state transition in the * ActiveButtonControl and a report that is sent down its report * channel. The report consists of the new state just reached (an Integer) * and, optionally, the channel index identifying which button was pushed (also an * Integer) and the message generated by the button (the String * that was labelling it). Also, the labels on all the buttons may be reset on * entry to a new state, together with their enable/disable status (via messages * sent back by ActiveButtonControl on its configure channels). ** All external channels must be supplied as parameters to a constructor. * The constructor must also be passed an array of String arrays * (one String array defining the labels allowed for each attached button), * the state table and a starting state. *
* The state table is an array of {@link ActiveButtonState}s. Each * ActiveButtonState has three arrays, all of size equal to the number * of buttons being controlled. The first array holds the indices defining the * label to be displayed on each button when in that state. The second array * holds the booleans defining the enable/disable status for each button for * that state. The third array holds the states to change into if the corresponding * button is pushed when in that state. *
*Channel Protocols
*| Input Channels | *||
|---|---|---|
| event[i] | *String | *The label on the attached {@link ActiveButton} (when it is pressed and released). | *
| Output Channels | *||
| configure[i] | *String | *Defines the label on the attached {@link ActiveButton}. | *
| Boolean | *Defines the enable/disable status on the attached {@link ActiveButton}. | *|
| report | *Integer | ** The new state (after a state transition). Note: depending on the state * transition table, this may be the same as the previous state.. * | *
| Integer | ** The channel index identifying which button caused the state transition. * Note: this will be output after the above state information only if * requested - see {@link #setReportButtonIndex setReportButtonIndex}. * | *|
| String | ** The label on the button that caused the state transition. * Note: this will be output after the above information only if * requested - see {@link #setReportButtonLabel setReportButtonLabel}. * | *|
Example
*
* import java.awt.*;
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
*
* public class ActiveButtonControlExample {
*
* public static void main (String argv[]) {
*
* final Frame root = new Frame ("ActiveButtonControl Example");
*
* final String[][] labels = {
* new String[] {"Hello World", "JCSP", "Restart"},
* new String[] {"Rocket Science", "JCSP", "occam"},
* new String[] {"Deadlock", "JCSP", "occam"},
* new String[] {"Race Hazard", "JCSP", "occam"},
* new String[] {"Starvation", "JCSP", "Quit", "Back"},
* new String[] {"Threads", "JCSP", "occam"},
* new String[] {"Livelock", "JCSP", "occam"},
* new String[] {"Monitors", "JCSP", "occam"},
* new String[] {"Alchemy", "JCSP", "Smile"}
* };
*
* final int nButtons = labels.length;
*
* final One2OneChannel[] fromButton = Channel.one2oneArray (nButtons, new OverWriteOldestBuffer (1));
* final Any2OneChannel[] toButton = Channel.any2oneArray (nButtons);
*
* final One2OneChannel report = Channel.one2one ();
*
* final ActiveButton[] button = new ActiveButton[nButtons];
* for (int i = 0; i < nButtons; i++) {
* button[i] = new ActiveButton (toButton[i].in (), fromButton[i].out (), "XXXXXXXXX");
* button[i].setBackground (Color.green);
* }
*
* root.setSize (450, 200);
* root.setLayout (new GridLayout (nButtons/3, 3));
* for (int i = 0; i < nButtons; i++) {
* root.add (button[i]);
* }
* root.setVisible (true);
*
* final int initial = 0; // state names
* final int diagonal = 1;
* final int opposite = 2;
* final int centre = 3;
* final int full = 4;
* final int terminal = 5;
*
* final String[] stateName = {
* "initial", "diagonal", "opposite", "centre", "full", "terminal"
* };
*
* final ActiveButtonState[] state = new ActiveButtonState[stateName.length];
*
* try {
*
* state[initial] =
* new ActiveButtonState (
* new int[] {
* 0, 0, 1,
* 0, 1, 1, // label index
* 1, 1, 1
* },
* new boolean[] {
* true, true, false,
* true, false, false, // enable/disable
* false, false, false
* },
* new int[] {
* diagonal, initial, initial,
* initial, initial, initial, // next state
* initial, initial, initial
* }
* );
*
* [In this example, nine buttons are laid out in a 3x3 grid in the root frame.
* The layout of the above state definition reflects this grid. Note that this code
* is enclosed within a try-catch block since the ActiveButtonState
* {@link ActiveButtonState#ActiveButtonState(int[],boolean[],int[]) constructor}
* performs numerous consistency checks on its parameters and may throw an exception.
* * The label index array specifies that, in this initial state, the north-west * button and its east and south neighbours display their 0-index labels (i.e. * "Hello World", "Rocket Science" and "Race Hazard" respectively). All the other * buttons display their 1-index labels (which all happen to be "JCSP"). *
* The enable/disable array specifies that, in this initial state, all those * buttons displaying "JCSP" are disabled and all the others are enabled. *
* The next state array specifies that, in this initial state, if the top-left * button is pushed, then the state should change to diagonal. However, if any * other button is pushed, the state remains as initial. Note that it doesn't * actually matter what is defined for those buttons that are disabled in this * state. *
* The diagonal, opposite, centre and full states are defined similarly. We pick * up the program for the definition of its terminal state (where all the labels * are "JCSP" and all the buttons are disabled).] *
* state[terminal] =
* new ActiveButtonState (
* new int[] {
* 1, 1, 1,
* 1, 1, 1, // label index
* 1, 1, 1
* },
* new boolean[] {
* false, false, false,
* false, false, false, // enable/disable
* false, false, false
* },
* new int[] {
* terminal, terminal, terminal,
* terminal, terminal, terminal, // next state
* terminal, terminal, terminal
* }
* );
*
* } catch (ActiveButtonState.BadArguments e) {
*
* System.out.println (e);
* System.exit (0);
*
* };
*
* new Parallel (
* new CSProcess[] {
* new Parallel (button),
* new CSProcess () {
* public void run () {
* final ActiveButtonControl control;
* try {
* control = new ActiveButtonControl (
* fromButton.in (), toButton.out (), report.out (), labels, state, initial
* );
* control.setReportButtonIndex (true);
* control.setReportButtonLabel (true);
* control.run ();
* } catch (ActiveButtonControl.BadArguments e) {
* System.out.println (e);
* System.exit (0);
* }
* }
* },
* new CSProcess () {
* public void run () {
* boolean running = true;
* while (running) {
* final int newState = ((Integer) report.in ().read ()).intValue ();
* final int buttonIndex = ((Integer) report.in ().read ()).intValue ();
* final String buttonString = (String) report.in ().read ();
* System.out.println (
* "Button " + buttonIndex +
* " (" + buttonString + ") pressed ==> " + stateName[newState]
* );
* running = (newState != terminal);
* }
* final CSTimer tim = new CSTimer (); // countdown to exit
* final long interval = 1000; // one second
* long timeout = tim.read ();
* for (int i = 10; i >= 0; i--) {
* timeout += interval;
* tim.after (timeout);
* final String iString = (new Integer (i)).toString ();
* for (int j = 0; j < nButtons; j++) {
* toButton[j].write (iString);
* }
* }
* root.setVisible (false);
* System.exit (0);
* }
* }
* }
* ).run ();
*
* }
*
* }
*
* The countdown to exit sequence is just for fun. In its terminal state,
* this ActiveButtonControl disables all its buttons and will never
* change state again. This leaves the buttons free to be configured by
* some other process, such as the last one above once it has detected that
* the controller is dead. This is why the toButton configure
* channels were created as Any2OneChannelImpl, rather than the more
* usual One2OneChannelImpl.
* * @see org.jcsp.awt.ActiveButton * @see org.jcsp.awt.ActiveButtonState * * @author P.H. Welch */ public class ActiveButtonControl implements CSProcess { private AltingChannelInput[] event; // from buttons ... private ChannelOutput[] configure; // to buttons ... private ChannelOutput report; // to whoever is out there ... private String[][] label; // button labels (each may have several) private ActiveButtonState[] state; private int startState; private Integer[] stateId; private Integer[] buttonId; private boolean verbose; private boolean reportButtonIndex = false; private boolean reportButtonString = false; /** * Constructs a new ActiveButtonControl, performing consistency * checks on its supplied arguments. * * @param event equal-indexed elements of event and configure * must be connected to the same {@link ActiveButton}. * @param configure equal-indexed elements of event and configure * must be connected to the same {@link ActiveButton}. * @param report the channel on which state transitions are reported. A report has * up to three messages: the new state, the index of the button triggering * the transition ({@link #setReportButtonIndex optional}) and its label * ({@link #setReportButtonLabel optional}). * @param label an array of string arrays (one for each controlled botton). Each * string array defines the label set allowed for each button. * @param state the state transition table. * @param startState the starting state for this finite state machine. * @throws ActiveButtonControl.BadArguments if the consistency check fails. * The exception contains details of the error. */ public ActiveButtonControl(AltingChannelInput[] event, ChannelOutput[] configure, ChannelOutput report, String[][] label, ActiveButtonState[] state, int startState) throws ActiveButtonControl.BadArguments { this(event, configure, report, label, state, startState, false); } /** * Constructs a new ActiveButtonControl, performing consistency * checks on its supplied arguments, with a verbose reporting option. * * @param event equal-indexed elements of event and configure * must be connected to the same {@link ActiveButton}. * @param configure equal-indexed elements of event and configure * must be connected to the same {@link ActiveButton}. * @param report the channel on which state transitions are reported. A report has * up to three messages: the new state, the index of the button triggering * the transition ({@link #setReportButtonIndex optional}) and its label * ({@link #setReportButtonLabel optional}). * @param label an array of string arrays (one for each controlled botton). Each * string array defines the label set allowed for each button. * @param state the state transition table. * @param startState the starting state for this finite state machine. * @param verbose if true, a running commentary is printed on the consistency checks * and state transitions as they occur. * @throws ActiveButtonControl.BadArguments if the consistency check fails. * The exception contains details of the error. */ public ActiveButtonControl(AltingChannelInput[] event, ChannelOutput[] configure, ChannelOutput report, String[][] label, ActiveButtonState[] state, int startState, boolean verbose) throws ActiveButtonControl.BadArguments { if (verbose) System.out.println("ActiveButtonControl creating ..."); // sanity checks if (event == null) throw new ActiveButtonControl.BadArguments("event == null"); if (configure == null) throw new ActiveButtonControl.BadArguments("configure == null"); if (label == null) throw new ActiveButtonControl.BadArguments("label == null"); if (state == null) throw new ActiveButtonControl.BadArguments("state == null"); if (verbose) System.out.println("ActiveButtonControl: arguments not null"); if (event.length != configure.length) throw new ActiveButtonControl.BadArguments("event.length != configure.length"); if (verbose) System.out.println("event.length == configure.length"); if (event.length != label.length) throw new ActiveButtonControl.BadArguments("event.length != label.length"); if (verbose) System.out.println("event.length == label.length"); for (int i = 0; i < label.length; i++) { if (event[i] == null) throw new ActiveButtonControl.BadArguments("event " + i + " channel is null"); if (verbose) System.out.println("event " + i + " channel is not null"); if (configure[i] == null) throw new ActiveButtonControl.BadArguments("configure " + i + " channel is null"); if (verbose) System.out.println("configure " + i + " channel is not null"); if (label[i] == null) throw new ActiveButtonControl.BadArguments("button " + i + " has no labels"); if (verbose) System.out.println("button " + i + " labels are not null"); for (int j = 0; j < label[i].length; j++) { if (label[i][j] == null) throw new ActiveButtonControl.BadArguments("label " + j + ", button " + i + ", is null"); if (verbose) System.out.println("label " + j + ", button " + i + ", is not null"); } } if (report == null) throw new ActiveButtonControl.BadArguments("no report channel"); if (verbose) System.out.println("ActiveButtonControl simple checks completed ..."); for (int i = 0; i < state.length; i++) { if (state[i] == null) throw new ActiveButtonControl.BadArguments("state " + i + " is null"); state[i].check(i, event.length, state.length, label); } if (verbose) System.out.println("ActiveButtonControl all checks completed ..."); // sanity checks complete this.event = event; this.configure = configure; this.report = report; this.label = label; this.state = state; this.startState = startState; this.verbose = verbose; stateId = new Integer[state.length]; for (int i = 0; i < stateId.length; i++) stateId[i] = new Integer(i); buttonId = new Integer[event.length]; for (int i = 0; i < buttonId.length; i++) buttonId[i] = new Integer(i); if (verbose) System.out.println("ActiveButtonControl created OK"); } /** * Defines whether the index of the pushed button causing a state transition should * be included in the report. The default is that it should not be reported. * * @param condition if true, the button index is reported - otherwise it is not reported. */ public void setReportButtonIndex(final boolean condition) { reportButtonIndex = condition; } /** * Defines whether the label on the pushed button causing a state transition should * be included in the report. The default is that it should not be reported. * * @param condition if true, the button label is reported - otherwise it is not reported. */ public void setReportButtonLabel(final boolean condition) { reportButtonString = condition; } private boolean[] setState(int currentState) { ActiveButtonState cState = state[currentState]; for (int i = 0; i < configure.length; i++) { if (cState.enable[i]) configure[i].write(Boolean.TRUE); else configure[i].write(Boolean.FALSE); } for (int i = 0; i < configure.length; i++) configure[i].write(label[i][cState.labelId[i]]); return cState.enable; } private boolean[] setState(int currentState, int lastState) { ActiveButtonState cState = state[currentState]; ActiveButtonState lState = state[lastState]; for (int i = 0; i < configure.length; i++) { if (cState.enable[i] != lState.enable[i]) { if (cState.enable[i]) configure[i].write(Boolean.TRUE); else configure[i].write(Boolean.FALSE); } } for (int i = 0; i < configure.length; i++) if (cState.labelId[i] != lState.labelId[i]) configure[i].write(label[i][cState.labelId[i]]); return cState.enable; } /** * Main body of the process. */ public void run() { if (verbose) System.out.println("ActiveButtonControl starting ..."); Alternative alt = new Alternative(event); int currentState = startState; int lastState; int button; boolean[] enable = setState(currentState); String string; while (true) { button = alt.fairSelect(enable); string = (String)event[button].read(); if (verbose) System.out.println(string + " " + button); lastState = currentState; currentState = state[currentState].next[button]; enable = setState(currentState, lastState); report.write(stateId[currentState]); if (reportButtonIndex) report.write(buttonId[button]); if (reportButtonString) report.write(string); } } /** * This gets thrown if a consistency check fails in the {@link ActiveButtonControl} * constructor. */ public static class BadArguments extends Exception { /** * * @param s details of the consistency failure. */ public BadArguments(String s) { super(s); } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveCheckboxMenuItem.java 0000644 0000000 0000000 00000036423 11105701167 021135 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.CheckboxMenuItem java.awt.CheckboxMenuItem} * with a channel interface. *
Process Diagram
*
Description
* ActiveCheckboxMenuItem is a process extension of java.awt.CheckboxMenuItem * with channels for run-time configuration and event notification. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure and event channels are * settable from a constructor. * The event channel delivers the generated java.awt.ItemEvent whenever * the ActiveCheckboxMenuItem is selected. * Other event channels can be added to notify the occurrence of any other events * the component generates (by calling the appropriate * addXXXEventChannel method before the process is run). * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myCheckboxMenuItemEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveCheckboxMenuItem myCheckboxMenuItem = * new ActiveCheckboxMenuItem (null, myCheckboxMenuItemEvent.out (), "Choose Me"); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *String | *Change the label on the ActiveCheckboxMenuItem to the value of the String | *
| java.awt.MenuShortcut | *Sets the MenuShortcut for the ActiveCheckboxMenuItem * | |
| Boolean | *
*
|
* |
| ActiveCheckboxMenuItem.Configure | *Invoke the user-defined Configure.configure method on the checkboxMenuItem. | *|
| Output Channels | *||
| event | *java.awt.ItemEvent | *The generated java.awt.ItemEvent is written down this channel * (when the checkboxMenuItem is selected or deslected) * | *
| actionEvent | *ActionEvent | *See the {@link #addActionEventChannel * addActionEventChannel} method. | *
Example
*
* import java.awt.*;
* import java.awt.event.*;
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
*
* public class ActiveCheckboxMenuItemExample {
*
* public static void main (String argv[]) {
*
* final ActiveClosingFrame activeClosingFrame =
* new ActiveClosingFrame ("ActiveCheckboxMenuItem Example");
*
* final ActiveFrame frame = activeClosingFrame.getActiveFrame ();
*
* final MenuBar menuBar = new MenuBar ();
* frame.setMenuBar (menuBar);
*
* final Menu fileMenu = new Menu ("File");
* final Menu langMenu = new Menu ("Language");
* menuBar.add (fileMenu);
* menuBar.add (langMenu);
*
* final String[] fileOptions = {"Hello World", "Rocket Science", "CSP",
* "Monitors", "Ignore Me", "Goodbye World"};
* final String[] langOptions = {"occam-pi", "Java", "Smalltalk", "Algol-60",
* "Pascal", "Haskell", "SML", "Lisp"};
*
* final Any2OneChannel event[] = Channel.any2oneArray (2, new OverWriteOldestBuffer (10));
*
* final ActiveMenuItem[] fileMenuItem =
* new ActiveMenuItem[fileOptions.length];
* for (int i = 0; i < fileOptions.length; i++) {
* fileMenuItem[i] = new ActiveMenuItem (null, event[0].out (), fileOptions[i]);
* fileMenu.add (fileMenuItem[i]);
* }
*
* final ActiveCheckboxMenuItem[] langCheckboxMenuItem =
* new ActiveCheckboxMenuItem[langOptions.length];
* for (int i = 0; i < langOptions.length; i++) {
* langCheckboxMenuItem[i] =
* new ActiveCheckboxMenuItem (null, event[1].out (), langOptions[i]);
* langMenu.add (langCheckboxMenuItem[i]);
* }
*
* frame.setSize (300, 200);
* frame.setBackground (Color.green);
* frame.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* activeClosingFrame,
* new Parallel (fileMenuItem),
* new Parallel (langCheckboxMenuItem),
* new CSProcess () {
* public void run () {
* boolean running = true;
* while (running) {
* final String s = (String) event[0].in ().read ();
* System.out.println ("File ==> `" + s + "' selected ...");
* running = (s != fileOptions[fileOptions.length - 1]);
* }
* frame.setVisible (false);
* System.exit (0);
* }
* },
* new CSProcess () {
* public void run () {
* while (true) {
* final ItemEvent e = (ItemEvent) event[1].in ().read ();
* final String item = (String) e.getItem ();
* System.out.print ("Language ==> `" + item);
* if (e.getStateChange () == ItemEvent.SELECTED) {
* System.out.println ("' selected ...");
* } else {
* System.out.println ("' deselected ...");
* }
* }
* }
* }
* }
* ).run ();
*
* }
*
* }
*
*
* @see java.awt.CheckboxMenuItem
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveCheckboxMenuItem extends CheckboxMenuItem implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The Configurer.
*/
// private Configurer configurer = null;
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* Constructs a new unchecked ActiveCheckboxMenuItem with no initial label
* and no configuration or event channels.
*
*/
public ActiveCheckboxMenuItem()
{
this(null, null, "", false);
}
/**
* Constructs a new unchecked ActiveCheckboxMenuItem
* with no configuration or event channels.
*
* @param s the initial label displayed on the checkboxMenuItem.
*/
public ActiveCheckboxMenuItem(String s)
{
this(null, null, s, false);
}
/**
* Constructs a new ActiveCheckboxMenuItem
* with no configuration or event channels.
*
* @param s the initial label displayed on the checkboxMenuItem.
* @param state the initial state of the checkboxMenuItem.
*/
public ActiveCheckboxMenuItem(String s, boolean state)
{
this(null, null, s, state);
}
/**
* Constructs a new unchecked ActiveCheckboxMenuItem with no initial label.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the current label will be output when the checkboxMenuItem is selected
* -- can be null if no notification is required.
*/
public ActiveCheckboxMenuItem(ChannelInput configure, ChannelOutput event)
{
this(configure, event, "", false);
}
/**
* Constructs a new unchecked ActiveCheckboxMenuItem.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the current label will be output when the checkboxMenuItem is selected
* -- can be null if no notification is required.
* @param s the initial label displayed on the checkboxMenuItem.
*/
public ActiveCheckboxMenuItem(ChannelInput configure, ChannelOutput event, String s)
{
this(configure, event, s, false);
}
/**
* Constructs a new ActiveCheckboxMenuItem.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
* @param event the current label will be output when the checkboxMenuItem is selected
* -- can be null if no notification is required.
* @param s the initial label displayed on the checkboxMenuItem.
* @param state the initial state of the checkboxMenuItem.
*/
public ActiveCheckboxMenuItem(ChannelInput configure, ChannelOutput event, String s, boolean state)
{
super(s, state);
if (event != null)
{
ItemEventHandler handler = new ItemEventHandler(event);
addItemListener(handler);
vec.addElement(handler);
}
this.configure = configure;
}
/**
* Sets the configuration channel for this ActiveCheckboxMenuItem.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* Add a new channel to this component that will be used to notify that
* an ActionEvent has occurred. This should be used
* instead of registering a ActionListener with the component. It is
* possible to add more than one channel by calling this method multiple times
* If the channel passed is null, no action will be taken.
* * NOTE: This method must be called before this process is run. * * @param actionEvent the channel down which to send ActionEvents. */ public void addActionEventChannel(ChannelOutput actionEvent) { if (actionEvent != null) { ActionEventHandler handler = new ActionEventHandler(actionEvent); addActionListener(handler); vec.addElement(handler); } } /** * This enables general configuration of this component. Any object implementing * this interface and sent down the configure channel to this component will have its * configure method invoked on this component. *
* For an example, see {@link ActiveApplet.Configure}. */ static public interface Configure { /** * @param checkboxMenuItem the CheckboxMenuItem being configured. */ public void configure(final CheckboxMenuItem checkboxMenuItem); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message instanceof String) setLabel((String) message); else if (message instanceof MenuShortcut) setShortcut((MenuShortcut) message); else if (message instanceof Character) { switch (((Character) message).charValue()) { case 'S': setState(true); break; case 's': setState(false); break; } } else if (message instanceof Boolean) { if (message == Boolean.TRUE) setEnabled(true); else if (message == Boolean.FALSE) setEnabled(false); } else if (message instanceof Configure) ((Configure) message).configure(this); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveContainer.java 0000644 0000000 0000000 00000035710 11105701167 017663 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.Container java.awt.Container} * with a channel interface. *
Process Diagram
*
Description
* ActiveContainer is a process extension of java.awt.Container * with channels for run-time configuration and event notification. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure channel is settable from a constructor. * Event channels can be added to notify the occurrence of any type of Event * the component generates (by calling the appropriate * addXXXEventChannel method before the process is run). * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component -- no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myMouseEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveContainer myContainer = new ActiveContainer (); * myContainer.addMouseEventChannel (myMouseEvent.out ()); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *ActiveContainer.Configure | *Invoke the user-defined Configure.configure method on the container. | *
| Output Channels | *||
| containerEvent | *ContainerEvent | *See the {@link #addContainerEventChannel * addContainerEventChannel} method. | *
| componentEvent | *ComponentEvent | *See the {@link #addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the {@link #addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the {@link #addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the {@link #addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the {@link #addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import java.awt.*;
* import java.awt.event.*;
* import org.jcsp.util.*;
* import org.jcsp.lang.*;
* import org.jcsp.awt.*;
*
* public class ActiveContainerExample {
*
* public static void main (String argv[]) {
*
* final Frame root = new Frame ("ActiveContainer Example");
*
* final One2OneChannel mouseEvent = Channel.one2one (new OverWriteOldestBuffer (10));
*
* final ActiveContainer container = new ActiveContainer ();
* container.addMouseEventChannel (mouseEvent.out ());
*
* root.add (container);
* root.setSize (400, 400);
* root.setVisible (true);
*
* new Parallel (
* new CSProcess[] {
* container,
* new CSProcess () {
* public void run () {
* boolean running = true;
* while (running) {
* final MouseEvent event = (MouseEvent) mouseEvent.in ().read ();
* switch (event.getID ()) {
* case MouseEvent.MOUSE_ENTERED:
* System.out.println ("MOUSE_ENTERED");
* break;
* case MouseEvent.MOUSE_EXITED:
* System.out.println ("MOUSE_EXITED");
* break;
* case MouseEvent.MOUSE_PRESSED:
* System.out.println ("MOUSE_PRESSED");
* break;
* case MouseEvent.MOUSE_RELEASED:
* System.out.println ("MOUSE_RELEASED");
* break;
* case MouseEvent.MOUSE_CLICKED:
* if (event.getClickCount() > 1) {
* System.out.println ("MOUSE_DOUBLE_CLICKED ... goodbye!");
* running = false;
* } else {
* System.out.println ("MOUSE_CLICKED ... *double* click to quit!");
* }
* break;
* }
* }
* root.setVisible (false);
* System.exit (0);
* }
* }
* }
* ).run ();
* }
*
* }
*
*
* @see java.awt.Container
* @see java.awt.event.ContainerEvent
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveContainer extends Container implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* Constructs a new ActiveContainer with no configuration channel.
*/
public ActiveContainer()
{
this(null);
}
/**
* Constructs a new ActiveContainer with a configuration channel.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public ActiveContainer(ChannelInput configure)
{
this.configure = configure;
}
/**
* Sets the configuration channel for this ActiveContainer.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* -- can be null if no configuration is required.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* Add a new channel to this component that will be used to notify that
* a ContainerEvent has occurred. This should be used
* instead of registering a ContainerListener with the component. It is
* possible to add more than one Channel by calling this method multiple times
* If the channel passed is null, no action will be taken.
* * NOTE: This method must be called before this process is run. * * @param containerEvent the channel down which to send ContainerEvents. */ public void addContainerEventChannel(ChannelOutput containerEvent) { if (containerEvent != null) { ContainerEventHandler handler = new ContainerEventHandler(containerEvent); addContainerListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a ComponentEvent has occurred. This should be used * instead of registering a ComponentListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param componentEvent the channel down which to send ComponentEvents. */ public void addComponentEventChannel(ChannelOutput componentEvent) { if (componentEvent != null) { ComponentEventHandler handler = new ComponentEventHandler(componentEvent); addComponentListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a FocusEvent has occurred. This should be used * instead of registering a FocusListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param focusEvent the channel down which to send FocusEvents. */ public void addFocusEventChannel(ChannelOutput focusEvent) { if (focusEvent != null) { FocusEventHandler handler = new FocusEventHandler(focusEvent); addFocusListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a KeyEvent has occurred. This should be used * instead of registering a KeyListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param keyEvent the channel down which to send KeyEvents. */ public void addKeyEventChannel(ChannelOutput keyEvent) { if (keyEvent != null) { KeyEventHandler handler = new KeyEventHandler(keyEvent); addKeyListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseEvent has occurred. This should be used * instead of registering a MouseListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseEvent the channel down which to send MouseEvents. */ public void addMouseEventChannel(ChannelOutput mouseEvent) { if (mouseEvent != null) { MouseEventHandler handler = new MouseEventHandler(mouseEvent); addMouseListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseMotionEvent has occurred. This should be used * instead of registering a MouseMotionListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseMotionEvent the channel down which to send MouseMotionEvents. */ public void addMouseMotionEventChannel(ChannelOutput mouseMotionEvent) { if (mouseMotionEvent != null) { MouseMotionEventHandler handler = new MouseMotionEventHandler(mouseMotionEvent); addMouseMotionListener(handler); vec.addElement(handler); } } /** * This enables general configuration of this component. Any object implementing * this interface and sent down the configure channel to this component will have its * configure method invoked on this component. *
* For an example, see {@link ActiveApplet.Configure}. */ static public interface Configure { /** * @param container the Container being configured. */ public void configure(final Container container); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message instanceof Configure) ((Configure) message).configure(this); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/awt/ActiveFileDialog.java 0000644 0000000 0000000 00000051335 11105701167 017741 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.awt; import java.awt.*; import java.util.Vector; import org.jcsp.lang.*; /** * {@link java.awt.FileDialog java.awt.FileDialog} * with a channel interface. *
Process Diagram
*
Description
* ActiveFileDialog is a process extension of java.awt.FileDialog * with channels for run-time configuration and event notification. The event channels * should be connected to one or more application-specific server processes (instead * of registering a passive object as a Listener to this component). ** All channels are optional. The configure and event channels are * settable from a constructor. * The event channel delivers directory and file names (see next paragraph). * Other event channels can be added to notify the occurrence of any other events * the component generates (by calling the appropriate * addXXXEventChannel method before the process is run). * Messages can be sent down the configure channel at any time to configure * the component. See the table below for details. *
* The ActiveFileDialog is made visible by sending a Boolean.TRUE down * its configure channel. A modal dialogue takes place to select a file * and the selected directory and file names are output down its event channel. *
* All channels are managed by independent internal handler processes. It is, therefore, * safe for a serial application process both to service an event channel and configure * the component – no deadlock can occur. *
* IMPORTANT: it is essential that event channels from this process are * always serviced – otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myFileDialogConfigure = Channel.one2one (); * final One2OneChannel myFileDialogEvent = Channel.one2one (new OverWriteOldestBuffer (n)); * * final ActiveFileDialog myFileDialog = * new ActiveFileDialog (myFileDialogConfigure.in (), myFileDialogEvent.out ()); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| configure | *String | ** The start directory for the fileDialog * | *
| Boolean | *
*
|
* |
| ActiveFileDialog.Configure | *Invoke the user-defined Configure.configure method on the activeFileDialog. | *|
| Output Channels | *||
| event | *String, String | *The directory and file names generated by the fileDialog – these may be null | *
| windowEvent | *WindowEvent | *See the {@link #addWindowEventChannel * addWindowEventChannel} method. | *
| containerEvent | *ContainerEvent | *See the {@link #addContainerEventChannel * addContainerEventChannel} method. | *
| componentEvent | *ComponentEvent | *See the {@link #addComponentEventChannel * addComponentEventChannel} method. | *
| focusEvent | *FocusEvent | *See the {@link #addFocusEventChannel * addFocusEventChannel} method. | *
| keyEvent | *KeyEvent | *See the {@link #addKeyEventChannel * addKeyEventChannel} method. | *
| mouseEvent | *MouseEvent | *See the {@link #addMouseEventChannel * addMouseEventChannel} method. | *
| mouseMotionEvent | *MouseEvent | *See the {@link #addMouseMotionEventChannel * addMouseMotionEventChannel} method. | *
Example
*
* import java.awt.*;
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.awt.*;
*
* public class ActiveFileDialogExample {
*
* public static void main (String argv[]) {
*
* final Frame root = new Frame ();
*
* final One2OneChannel configure = Channel.one2one ();
*
* final One2OneChannel event = Channel.one2one (new OverWriteOldestBuffer (10));
*
* final ActiveFileDialog fileDialog =
* new ActiveFileDialog (configure.in (), event.out (), root, "ActiveFileDialog Example");
*
* new Parallel (
* new CSProcess[] {
* fileDialog,
* new CSProcess () {
* public void run () {
* String dir = "."; // start directory for the file dialogue
* String file = "";
* while (file != null) {
* configure.out ().write (dir);
* configure.out ().write (Boolean.TRUE);
* dir = (String) event.in ().read ();
* file = (String) event.in ().read ();
* if (file != null)
* System.out.println ("Chosen file = `" + dir + file + "'");
* }
* System.exit (0);
* }
* }
* }
* ).run ();
* }
*
* }
*
*
* @see java.awt.FileDialog
* @see java.awt.event.WindowEvent
* @see java.awt.event.ContainerEvent
* @see java.awt.event.ComponentEvent
* @see java.awt.event.FocusEvent
* @see java.awt.event.KeyEvent
* @see java.awt.event.MouseEvent
* @see org.jcsp.util.OverWriteOldestBuffer
*
* @author P.D. Austin and P.H. Welch
*/
public class ActiveFileDialog extends FileDialog implements CSProcess
{
/**
* The Vector construct containing the handlers.
*/
private Vector vec = new Vector();
/**
* The channel from which configuration messages arrive.
*/
private ChannelInput configure;
/**
* The channel to which the selected directory and file names are sent.
*/
private ChannelOutput event;
/**
* Constructs a new ActiveDialog with a blank title for loading a file
* and with no configuration or event channels.
* Constructs a new ActiveFileDialog.
*
* @param parent the parent frame for the fileDialog.
*/
public ActiveFileDialog(Frame parent)
{
this(null, null, parent, "", LOAD);
}
/**
* Constructs a new ActiveFileDialog with a blank title
* and no configuration or event channels.
*
* @param parent the parent frame for the fileDialog.
* @param mode java.awt.FileDialog.LOAD or java.awt.FileDialog.SAVE.
*/
public ActiveFileDialog(Frame parent, int mode)
{
this(null, null, parent, "", mode);
}
/**
* Constructs a new ActiveFileDialog for loading a file
* and no configuration or event channels.
*
* @param parent the parent frame for the fileDialog.
* @param title the title of the fileDialog.
*/
public ActiveFileDialog(Frame parent, String title)
{
this(null, null, parent, title, LOAD);
}
/**
* Constructs a new ActiveFileDialog
* with no configuration or event channels.
*
* @param parent the parent frame for the fileDialog.
* @param title the title of the fileDialog.
* @param mode java.awt.FileDialog.LOAD or java.awt.FileDialog.SAVE.
*/
public ActiveFileDialog(Frame parent, String title, int mode)
{
this(null, null, parent, title, mode);
}
/**
* Constructs a new ActiveFileDialog with a blank title for loading a file.
*
* @param configure the channel for configuration events
* – can be null if no configuration is required.
* @param event the directory and file names will be output whenever selected
* – can be null if no notification is required.
* @param parent the parent frame for the fileDialog.
*/
public ActiveFileDialog(ChannelInput configure, ChannelOutput event, Frame parent)
{
this(configure, event, parent, "", LOAD);
}
/**
* Constructs a new ActiveFileDialog with a blank title.
*
* @param configure the channel for configuration events
* – can be null if no configuration is required.
* @param event the directory and file names will be output whenever selected
* – can be null if no notification is required.
* @param parent the parent frame for the fileDialog.
* @param mode java.awt.FileDialog.LOAD or java.awt.FileDialog.SAVE.
*/
public ActiveFileDialog(ChannelInput configure, ChannelOutput event, Frame parent, int mode)
{
this(configure, event, parent, "", mode);
}
/**
* Constructs a new ActiveFileDialog for loading a file.
*
* @param configure the channel for configuration events
* – can be null if no configuration is required.
* @param event the directory and file names will be output whenever selected
* – can be null if no notification is required.
* @param parent the parent frame for the fileDialog.
* @param title the title of the fileDialog.
*/
public ActiveFileDialog(ChannelInput configure, ChannelOutput event, Frame parent, String title)
{
this(configure, event, parent, title, LOAD);
}
/**
* Constructs a new ActiveFileDialog.
*
* @param configure the channel for configuration events
* – can be null if no configuration is required.
* @param event the directory and file names will be output whenever selected
* – can be null if no notification is required.
* @param parent the parent frame for the fileDialog.
* @param title the title of the fileDialog.
* @param mode java.awt.FileDialog.LOAD or java.awt.FileDialog.SAVE.
*
*/
public ActiveFileDialog(ChannelInput configure, ChannelOutput event, Frame parent, String title, int mode)
{
super(parent, title, mode);
this.configure = configure;
this.event = event;
}
/**
* Sets the configuration channel for this ActiveFileDialog.
* This method overwrites any configuration channel set in the constructor.
*
* @param configure the channel for configuration events
* – can be null if no configuration is required.
*/
public void setConfigureChannel(ChannelInput configure)
{
this.configure = configure;
}
/**
* Add a new channel to this component that will be used to notify that
* a WindowEvent has occurred. This should be used
* instead of registering a WindowListener with the component. It is
* possible to add more than one channel by calling this method multiple times
* If the channel passed is null, no action will be taken.
* * NOTE: This method must be called before this process is run. * * @param windowEvent the channel down which to send ContainerEvents. */ public void addWindowEventChannel(ChannelOutput windowEvent) { if (windowEvent != null) { WindowEventHandler handler = new WindowEventHandler(windowEvent); addWindowListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a ContainerEvent has occurred. This should be used * instead of registering a ContainerListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param containerEvent the channel down which to send ContainerEvents. */ public void addContainerEventChannel(ChannelOutput containerEvent) { if (containerEvent != null) { ContainerEventHandler handler = new ContainerEventHandler(containerEvent); addContainerListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a ComponentEvent has occurred. This should be used * instead of registering a ComponentListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param componentEvent the channel down which to send ComponentEvents. */ public void addComponentEventChannel(ChannelOutput componentEvent) { if (componentEvent != null) { ComponentEventHandler handler = new ComponentEventHandler(componentEvent); addComponentListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a FocusEvent has occurred. This should be used * instead of registering a FocusListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param focusEvent the channel down which to send FocusEvents. */ public void addFocusEventChannel(ChannelOutput focusEvent) { if (focusEvent != null) { FocusEventHandler handler = new FocusEventHandler(focusEvent); addFocusListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a KeyEvent has occurred. This should be used * instead of registering a KeyListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param keyEvent the channel down which to send KeyEvents. */ public void addKeyEventChannel(ChannelOutput keyEvent) { if (keyEvent != null) { KeyEventHandler handler = new KeyEventHandler(keyEvent); addKeyListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseEvent has occurred. This should be used * instead of registering a MouseListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseEvent the channel down which to send MouseEvents. */ public void addMouseEventChannel(ChannelOutput mouseEvent) { if (mouseEvent != null) { MouseEventHandler handler = new MouseEventHandler(mouseEvent); addMouseListener(handler); vec.addElement(handler); } } /** * Add a new channel to this component that will be used to notify that * a MouseMotionEvent has occurred. This should be used * instead of registering a MouseMotionListener with the component. It is * possible to add more than one Channel by calling this method multiple times * If the channel passed is null, no action will be taken. *
* NOTE: This method must be called before this process is run. * * @param mouseMotionEvent the channel down which to send MouseMotionEvents. */ public void addMouseMotionEventChannel(ChannelOutput mouseMotionEvent) { if (mouseMotionEvent != null) { MouseMotionEventHandler handler = new MouseMotionEventHandler(mouseMotionEvent); addMouseMotionListener(handler); vec.addElement(handler); } } /** * This enables general configuration of this component. Any object implementing * this interface and sent down the configure channel to this component will have its * configure method invoked on this component. *
* For an example, see {@link ActiveApplet.Configure}. */ static public interface Configure { /** * @param fileDialog the FileDialog being configured. */ public void configure(final FileDialog fileDialog); } /** * The main body of this process. */ public void run() { if (configure != null) { while (true) { Object message = configure.read(); if (message instanceof Boolean) { if (message == Boolean.TRUE) { setVisible(true); if (event != null) { event.write(getDirectory()); event.write(getFile()); } } else if (message == Boolean.FALSE) setVisible(false); } else if (message instanceof String) setDirectory((String) message); else if (message instanceof Configure) ((Configure) message).configure(this); } } } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/ 0000755 0000000 0000000 00000000000 11410045052 014002 5 ustar jcsp-1.1-rc4.orig/src/org/jcsp/net2/NetChannelEndFactory.java 0000644 0000000 0000000 00000060247 11072626250 020665 0 ustar package org.jcsp.net2; /** * This interface defines the methods that any networked channel factory must implement. For a concrete implementation, * see StandardNetChannelEndFactory * * @see StandardNetChannelEndFactory * @author Kevin Chalmers (updated from Quickstone Technologies) */ public interface NetChannelEndFactory { /** * Creates a new NetAltingChannelInput * * @return A new NetAltingChannelInput */ public NetAltingChannelInput net2one(); /** * Creates a new NetAltingChannelInput with the given immunity level for poison * * @param immunityLevel * The immunity level for poison * @return A new NetAltingChannelInput */ public NetAltingChannelInput net2one(int immunityLevel); /** * Creates a new NetAltingChannelInput which uses the given filter to decode incoming messages * * @param filter * The filter used to decode incoming messages * @return A new NetAltingChannelInput */ public NetAltingChannelInput net2one(NetworkMessageFilter.FilterRx filter); /** * Creates a new NetAltingChannelInput with the given poison immunity level which uses the given filter to decode * incoming messages * * @param immunityLevel * The immunity level to poison for the created channel * @param filter * The filter used to decode incoming messages * @return A new NetAltingChannelInput */ public NetAltingChannelInput net2one(int immunityLevel, NetworkMessageFilter.FilterRx filter); /** * Creates a new NetSharedChannelInput * * @return A new NetSharedChannelInput */ public NetSharedChannelInput net2any(); /** * Creates a new NetSharedChannelInput with the given poison immunity level * * @param immunityLevel * The immunity level to poison for this channel * @return A new NetSharedChannelInput */ public NetSharedChannelInput net2any(int immunityLevel); /** * Creates a new NetSharedChannelInput which uses the given filter to decode incoming messages * * @param filter * The filter used to decode incoming messages * @return A new NetSharedChannelInput */ public NetSharedChannelInput net2any(NetworkMessageFilter.FilterRx filter); /** * Creates a new NetSharedChannelInput with the given poison immunity level, which uses the given filter to decode * messages * * @param immunityLevel * The immunity level to poison for this channel * @param filter * The filter used to decode incoming messages * @return A new NetSharedChannelInput */ public NetSharedChannelInput net2any(int immunityLevel, NetworkMessageFilter.FilterRx filter); /** * Creates a new NetAltingChannelInput with the given index * * @param index * The index to create the channel with * @return A new NetAltingChannelInput * @throws IllegalArgumentException * Thrown if a channel with the given index already exists */ public NetAltingChannelInput numberedNet2One(int index) throws IllegalArgumentException; /** * Creates a new NetAltingChannelInput with the given index and the given poison immunity level * * @param index * The index to create the channel with * @param immunityLevel * The immunity to poison that the channel has * @return A new NetAltingChannelInput * @throws IllegalArgumentException * Thrown if a channel with the given index already exists */ public NetAltingChannelInput numberedNet2One(int index, int immunityLevel) throws IllegalArgumentException; /** * Creates a new NetAltingChannelInput with the given index that uses the given filter to decode incoming messages * * @param index * The index to create the channel with * @param filter * The filter used to decode incoming messages * @return A new NetAltingChannelInput * @throws IllegalArgumentException * Thrown if a channel with the given index already exists */ public NetAltingChannelInput numberedNet2One(int index, NetworkMessageFilter.FilterRx filter) throws IllegalArgumentException; /** * Creates a new NetAltingChannelInput with the given index and given poison immunity, which uses the given filter * to decode incoming messages * * @param index * The index to create the channel with * @param immunityLevel * The immunity to poison that the channel has * @param filter * The filter used to decode incoming messages * @return A new NetAltingChannelInput * @throws IllegalArgumentException * Thrown if a channel with the given index already exists */ public NetAltingChannelInput numberedNet2One(int index, int immunityLevel, NetworkMessageFilter.FilterRx filter) throws IllegalArgumentException; /** * Creates a new NetSharedChannelInput with the given index * * @param index * The index to create the channel with * @return A new NetSharedChannelInput * @throws IllegalArgumentException * Thrown if a channel with the given index already exists */ public NetSharedChannelInput numberedNet2Any(int index) throws IllegalArgumentException; /** * Creates a new NetSharedChannelInput with the given index and poison immunity level * * @param index * The index to create the channel with * @param immunityLevel * The immunity to poison the channel has * @return A new NetSharedChannelInput * @throws IllegalArgumentException * Thrown if a channel with the given index already exists */ public NetSharedChannelInput numberedNet2Any(int index, int immunityLevel) throws IllegalArgumentException; /** * Creates a new NetSharedChannelInput with the given index that uses the given filter to decode incoming messages * * @param index * The index to create the channel with * @param filter * The filter used to decode incoming messages * @return A new NetSharedChannelInput * @throws IllegalArgumentException * Thrown if a channel with the given index already exists */ public NetSharedChannelInput numberedNet2Any(int index, NetworkMessageFilter.FilterRx filter) throws IllegalArgumentException; /** * Creates a new NetSharedChannelInput with the given index and poison immunity level, which uses the given filter * to decode incoming messages. * * @param index * The index to create the channel with * @param immunityLevel * The immunity level to poison that the channel has * @param filter * The filter used to decode incoming messages * @return A new NetSharedChannelInput * @throws IllegalArgumentException * Thrown if a channel with the given index already exists. */ public NetSharedChannelInput numberedNet2Any(int index, int immunityLevel, NetworkMessageFilter.FilterRx filter) throws IllegalArgumentException; /** * Creates a new NetChannelOutput connected to the input end with the given NetChannelLocation * * @param loc * The location of the input end of the channel * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NetChannelLocation loc) throws JCSPNetworkException; /** * Creates a new NetChannelOutput connected to the input end with the given NetChannelLocation, and having the given * poison immunity level * * @param loc * The location of the input end of the channel * @param immunityLevel * The immunity to poison that this channel has * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NetChannelLocation loc, int immunityLevel) throws JCSPNetworkException; /** * Creates a new NetChannelOutput connected to the input end with the given NetChannelLocation, and uses the given * filter to encode outgoing messages * * @param loc * The location of the input end of the channel * @param filter * The filter used to encode outgoing messages * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NetChannelLocation loc, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException; /** * Creates a new NetChannelOutput connected to the given location with the given poison immunity level, and uses the * given filter to encode outgoing messages. * * @param loc * The location of the input end of the channel * @param immunityLevel * The immunity to poison that this channel has * @param filter * The filter used to encode outgoing messages * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NetChannelLocation loc, int immunityLevel, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException; /** * Creates a new NetSharedChannelOutput connected to the input end at the given location * * @param loc * The location of the input end of the channel * @return A new NetSharedChannelInput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NetChannelLocation loc) throws JCSPNetworkException; /** * Creates a new NetSharedChannelOutput connected to the input end at the given location and with the given poison * immunity level * * @param loc * The location of the input end of the channel * @param immunityLevel * The immunity to poison that the channel has * @return A new NetSharedChannelInput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NetChannelLocation loc, int immunityLevel) throws JCSPNetworkException; /** * Creates a new NetSharedChannelOutput connected to the input end with the given location, and uses the given * filter to encode outgoing messages * * @param loc * The location of the input end of the channel * @param filter * The filter used to encode outgoing messages * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NetChannelLocation loc, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException; /** * Creates a new NetSharedChannelOutput connected to the input end with the given location and with the given * immunity level, which uses the given filter to encode outgoing messages. * * @param loc * The location of the input end of the channel * @param immunityLevel * The immunity to poison that this channel has * @param filter * The filter used to encode outgoing messages * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NetChannelLocation loc, int immunityLevel, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException; /** * Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node * * @param nodeID * The NodeID of the node that the input channel resides on * @param vcn * The Virtual Channel Number of the input channel * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NodeID nodeID, int vcn) throws JCSPNetworkException; /** * Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node, and with the given * poison immunity level * * @param nodeID * The NodeID of the Node that the input channel resides on * @param vcn * The Virtual Channel Number of the input channel * @param immunityLevel * The immunity to poison of the channel * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NodeID nodeID, int vcn, int immunityLevel) throws JCSPNetworkException; /** * Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node, which uses the * given filter to encode outgoing messages * * @param nodeID * The NodeID of the Node that the input channel resides on * @param vcn * The Virtual Channel Number of the input channel * @param filter * The filter to encode outgoing messages * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong with the underlying architecture */ public NetChannelOutput one2net(NodeID nodeID, int vcn, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException; /** * Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node, with the given * poison immunity level and uses the given filter to encode outgoing messages * * @param nodeID * The NodeID of the Node that the input channel resides on * @param vcn * The Virtual Channel Number of the input channel * @param immunityLevel * The immunity to poison that the channel has * @param filter * The filter that encodes the outgoing messages * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong with the underlying architecture */ public NetChannelOutput one2net(NodeID nodeID, int vcn, int immunityLevel, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException; /** * Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node * * @param nodeID * The NodeID of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NodeID nodeID, int vcn) throws JCSPNetworkException; /** * Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node and the given * poison immunity * * @param nodeID * The NodeID of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @param immunityLevel * The immunity to poison that the channel has * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NodeID nodeID, int vcn, int immunityLevel) throws JCSPNetworkException; /** * Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node, which uses * the given filter to encode outgoing messages * * @param nodeID * The NodeID of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @param filter * The filter used to encode the outgoing messages * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NodeID nodeID, int vcn, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException; /** * Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node, with the * given poison immunity level, which uses the given filter to encode outgoing messages * * @param nodeID * The NodeID of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @param immunityLevel * The immunity to poison that the channel has * @param filter * The filter used to encode outgoing messages * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NodeID nodeID, int vcn, int immunityLevel, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException; /** * Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node * * @param nodeAddr * The NodeAddress of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NodeAddress nodeAddr, int vcn) throws JCSPNetworkException; /** * Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node with the given * poison immunity * * @param nodeAddr * The NodeAddress of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @param immunityLevel * The immunity to poison the channel has * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NodeAddress nodeAddr, int vcn, int immunityLevel) throws JCSPNetworkException; /** * Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node which uses the given * filter to encode outgoing messages * * @param nodeAddr * The NodeAddress of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @param filter * The filter used to encode outgoing messages * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NodeAddress nodeAddr, int vcn, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException; /** * Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node which has the given * poison immunity and uses the given filter to encode outgoing messages * * @param nodeAddr * The NodeAddress of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @param immunityLevel * The immunity to poison that the channel has * @param filter * The filter used to encode outgoing messages * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NodeAddress nodeAddr, int vcn, int immunityLevel, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException; /** * Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node * * @param nodeAddr * The NodeAddress of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn) throws JCSPNetworkException; /** * Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node which has the * given poison immunity * * @param nodeAddr * The NodeAddress of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @param immunityLevel * The immunity to poison that the channel has * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn, int immunityLevel) throws JCSPNetworkException; /** * Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node which uses the * given filter to encode outgoing messages * * @param nodeAddr * The NodeAddress of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @param filter * The immunity to poison that the channel has * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException; /** * Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node that has the * given poison immunity level and uses the given filter to encode outgoing messages * * @param nodeAddr * The NodeAddress of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @param immunityLevel * The immunity to poison that the channel has * @param filter * The filter used to encode outgoing messages * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn, int immunityLevel, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException; } jcsp-1.1-rc4.orig/src/org/jcsp/net2/ChannelDataState.java 0000644 0000000 0000000 00000003042 11072626250 020020 0 ustar package org.jcsp.net2; /** * Represents the state of the networked channel. For information on networked channels, see the relevant documentation. * * @see org.jcsp.net2.NetChannelInput * @see org.jcsp.net2.NetChannelOutput * @author Kevin Chalmers */ final class ChannelDataState { /** * Private default constructor. */ private ChannelDataState() { // Empty constructor } /** * Signifies that the channel has not been activated yet. */ static final byte INACTIVE = 0; /** * Signifies that the channel has been started and is a input end. */ static final byte OK_INPUT = 1; /** * Signified that the channel has been started and is a output end. */ static final byte OK_OUTPUT = 2; /** * Signifies that the channel has been destroyed. */ static final byte DESTROYED = 3; /** * Signifies that the channel is broken. This is from the original JCSP model, and may be unnecessary as Destroyed * and Poisoned may cover this. */ static final byte BROKEN = 4; /** * Signifies that the channel has recently moved and has yet to be reestablished at a new location. */ static final byte MOVING = 5; /** * Signifies that the channel has moved to a new location and that this new location is available. */ static final byte MOVED = 6; /** * Signifies that the channel has been poisoned. */ static final byte POISONED = 7; } jcsp-1.1-rc4.orig/src/org/jcsp/net2/ObjectNetworkMessageFilter.java 0000644 0000000 0000000 00000011754 11072626250 022121 0 ustar package org.jcsp.net2; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; /** * This class is the standard encoding and decoding filter for networked JCSP channels. It uses standard Java * serialization to operate. * * @author Kevin Chalmers */ public final class ObjectNetworkMessageFilter { /* * Size of the internal buffer of the memory stream */ public static int BUFFER_SIZE = 8192; /** * The receiving (decoding) filter for Objects * * @author Kevin Chalmers */ public static final class FilterRX implements NetworkMessageFilter.FilterRx { /** * These four bytes represent the normal header expected in Java for object streams */ static final byte[] objectStreamHeader = { -84, -19, 0, 5 }; /** * The byte array stream used to connect to the ObjectInputStream */ private final ResettableByteArrayInputStream bais; /** * The ObjectInputStream used to read the objects from. */ private final ObjectInputStream ois; /** * Creates a new incoming object filter */ public FilterRX() { try { // We need to put the header down the stream first to create the ObjectInputStream this.bais = new ResettableByteArrayInputStream(ObjectNetworkMessageFilter.FilterRX.objectStreamHeader); // Now hook the ObjectInputStream to the byte array stream. Should work fine. this.ois = new ObjectInputStream(this.bais); } catch (IOException ioe) { // Should never really happen, however... throw new RuntimeException( "Failed to create the required streams for ObjectNetwrokMessageFilter.FilterRX"); } } /** * Decodes an incoming byte array, converting it back into an Object * * @param bytes * The byte representation of the object * @return The recreated Object * @throws IOException * Thrown of something goes wrong during the decoding */ public Object filterRX(byte[] bytes) throws IOException { try { // Reset the byte array stream with the incoming bytes this.bais.reset(bytes); // Return the object read from the input stream return this.ois.readObject(); } catch (ClassNotFoundException cnfe) { // Not an exception thrown by other filters, so we convert into an IOException throw new IOException("Class not found"); } } } /** * The sending (encoding) filter for Object channels * * @author Kevin Chalmers */ public static final class FilterTX implements NetworkMessageFilter.FilterTx { /** * The output stream to get the bytes from */ private final ResettableByteArrayOutputStream baos; /** * The ObjectOutputStream connected to the byte stream to allow the serialization of objects */ private final ObjectOutputStream oos; /** * Creates a new encoding object filter */ public FilterTX() { try { // We use an 8Kb buffer to serialize into as default, although this could can adjusted this.baos = new ResettableByteArrayOutputStream(ObjectNetworkMessageFilter.BUFFER_SIZE); this.oos = new ObjectOutputStream(this.baos); } catch (IOException ioe) { throw new RuntimeException( "Failed to create the required streams for ObjectNetworkMessageFilter.FilterTX"); } } /** * Encodes an object into bytes by using Object serialization * * @param obj * The Object to serialize * @return The byte array equivalent of the object * @throws IOException * Thrown if something goes wrong during the serialization */ public byte[] filterTX(Object obj) throws IOException { // First we reset the byte buffer to the buffer size, just in case a previous message caused it to grow this.baos.reset(ObjectNetworkMessageFilter.BUFFER_SIZE); // Now reset the object stream. This clears any remembered messages this.oos.reset(); // Write the object to the stream this.oos.writeObject(obj); // Get the bytes return this.baos.toByteArray(); } } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/BarrierData.java 0000644 0000000 0000000 00000001467 11072626250 017046 0 ustar package org.jcsp.net2; import org.jcsp.lang.ChannelOutput; /** * Contains the data that relates to a networked Barrier. This is an external data structure within JCSP networking, and * is held by both the NetBarrier and the BarrierManager. For information on the operation of the NetBarrier, see the * relevant documentation. * * @see org.jcsp.net2.NetBarrier * @author Kevin Chalmers */ final class BarrierData { /** * The virtual Barrier number that uniquely identifies the Barrier within the Node */ int vbn = -1; /** * The current state of the Barrier */ byte state = BarrierDataState.INACTIVE; /** * The connection to the Barrier for connecting to the NetBarrier object from the Link */ ChannelOutput toBarrier = null; } jcsp-1.1-rc4.orig/src/org/jcsp/net2/tcpip/ 0000755 0000000 0000000 00000000000 11410045052 015121 5 ustar jcsp-1.1-rc4.orig/src/org/jcsp/net2/tcpip/TCPIPLink.java 0000644 0000000 0000000 00000031345 11072626250 017500 0 ustar package org.jcsp.net2.tcpip; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.net.Inet4Address; import java.net.InetAddress; import java.net.Socket; import org.jcsp.net2.JCSPNetworkException; import org.jcsp.net2.Link; import org.jcsp.net2.Node; import org.jcsp.net2.NodeAddress; import org.jcsp.net2.NodeID; /** * A concrete implementation of a Link that operates over a TCP/IP based socket connection. For information on Link, see * the relative documentation. *
* It is perfectly possible for a user to create a TCPIPLink without going through the standard LinkFactory approach, * although this is not recommended. For example: *
*
*
* TCPIPLink link = new TCPIPLink(address);
*
* link.connect();
* link.registerLink();
* new ProcessManager(link).start();
*
* Can be achieved using the LinkFactory: *
*
*
* link = LinkFactory.getLink(address);
*
*
* The LinkFactory will create and start the Link automatically if required. *
* * @see Link * @see TCPIPNodeAddress * @author Kevin Chalmers */ public final class TCPIPLink extends Link { /** * Defines the size of the buffer to place on the incoming and outgoing streams. This is a rather large size, and * for certain implementations, this may be reduced. It is unlikely that any sent object will be this large. */ public static int BUFFER_SIZE = 8192; /** * Flag to determine whether the Nagle algorithm should be activated. Default is false (off). */ public static boolean NAGLE = false; /** * The socket connected to the remote Node. */ private Socket sock; /** * The address of the remote Node. */ private TCPIPNodeAddress remoteAddress; /** * Creates a new TCPIPLink * * @param address * The address of the remote Node to connect to * @throws JCSPNetworkException * Thrown if something goes wrong during the creation process */ public TCPIPLink(TCPIPNodeAddress address) throws JCSPNetworkException { try { // First check if we have an ip address in the string. If not, we assume that this is to be connected // to the local machine but to a different JVM if (address.getIpAddress().equals("")) { // Get the local IP addresses InetAddress[] local = InetAddress.getAllByName(InetAddress.getLocalHost().getHostName()); InetAddress toUse = InetAddress.getLocalHost(); // We basically have four types of addresses to worry about. Loopback (127), link local (169), // local (192) and (possibly) global. Grade each 1, 2, 3, 4 and use highest scoring address. In all // cases use first address of that score. int current = 0; // Loop until we have checked all the addresses for (int i = 0; i < local.length; i++) { // Ensure we have an IPv4 address if (local[i] instanceof Inet4Address) { // Get the first byte of the address byte first = local[i].getAddress()[0]; // Now check the value if (first == (byte)127 && current < 1) { // We have a Loopback address current = 1; // Set the address to use toUse = local[i]; } else if (first == (byte)169 && current < 2) { // We have a link local address current = 2; // Set the address to use toUse = local[i]; } else if (first == (byte)192 && current < 3) { // We have a local address current = 3; // Set the address to use toUse = local[i]; } else { // Assume the address is globally accessible and use by default. toUse = local[i]; // Break from the loop break; } } } // Now set the IP address of the address address.setIpAddress(toUse.getHostAddress()); // Set the address part. address.setAddress(address.getIpAddress() + ":" + address.getPort()); } // Connect the socket to the server socket on the remote Node this.sock = new Socket(address.getIpAddress(), address.getPort()); // Set TcpNoDelay. Off should improve performance for smaller packet sizes, which JCSP should have in // general this.sock.setTcpNoDelay(!TCPIPLink.NAGLE); // Create the input and output streams for the Link this.rxStream = new DataInputStream(new BufferedInputStream(this.sock.getInputStream(), TCPIPLink.BUFFER_SIZE)); this.txStream = new DataOutputStream(new BufferedOutputStream(this.sock.getOutputStream(), TCPIPLink.BUFFER_SIZE)); // Set the remote address this.remoteAddress = address; // We are not connected, so set connected to false. this.connected = false; // Log Node connection Node.log.log(this.getClass(), "Link created to " + address.toString()); } catch (IOException ioe) { // Something went wrong during connection. Log and throw exception Node.err.log(this.getClass(), "Failed to create Link to " + address.toString()); throw new JCSPNetworkException("Failed to create TCPIPLink to: " + address.getAddress()); } } /** * Creates new TCPIPLink from a Socket. This is used internally by JCSP * * @param socket * The socket to create the TCPIPLink with * @param nodeID * The NodeID of the remote Node * @throws JCSPNetworkException * Thrown if there is a problem during the connection */ TCPIPLink(Socket socket, NodeID nodeID) throws JCSPNetworkException { try { // Set the sock property this.sock = socket; // Set TcpNoDelay socket.setTcpNoDelay(!TCPIPLink.NAGLE); // Set the input and output streams for the Link this.rxStream = new DataInputStream(new BufferedInputStream(socket.getInputStream(), TCPIPLink.BUFFER_SIZE)); this.txStream = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream(), TCPIPLink.BUFFER_SIZE)); // Set the NodeID this.remoteID = nodeID; // Set the remote address this.remoteAddress = (TCPIPNodeAddress)this.remoteID.getNodeAddress(); // Set connected to true this.connected = true; // Log Link creation and Link connection Node.log.log(this.getClass(), "Link created to " + nodeID.toString()); Node.log.log(this.getClass(), "Link to " + nodeID.toString() + " connected"); } catch (IOException ioe) { // Something went wrong during the creation. Log and throw exception Node.err.log(this.getClass(), "Failed to create Link to " + nodeID.toString()); throw new JCSPNetworkException("Failed to create TCPIPLink to: " + nodeID.getNodeAddress().getAddress()); } } /** * Connects the Link to the remote Node. Exchanges the NodeIDs * * @return True if the Link successfully connected to the remote Link * @throws JCSPNetworkException * Thrown if something goes wrong during the connection */ public boolean connect() throws JCSPNetworkException { // First check if we are connected. if (this.connected) return true; // Flag to determine if we are connected at the end of the process. boolean toReturn = false; try { // Write the string representation of our NodeID to the remote Node this.txStream.writeUTF(Node.getInstance().getNodeID().toString()); this.txStream.flush(); // Read in the response from the opposite Node String response = this.rxStream.readUTF(); // Either the connection has been accepted (no connection to this Node exists on the opposite Node) or // it has not. The opposite Node sends OK in the first instance. if (response.equalsIgnoreCase("OK")) { // The connection is to be kept. Log, and set toReturn to true Node.log.log(this.getClass(), "Link to " + this.remoteAddress.toString() + " connected"); toReturn = true; } // Read in Remote NodeID as string String nodeIDString = this.rxStream.readUTF(); NodeID otherID = NodeID.parse(nodeIDString); // First check we have a tcpip Node connection. This should always be the case if (otherID.getNodeAddress() instanceof TCPIPNodeAddress) { // Set address and NodeID. If we are not connected then this NodeID can be used to // get the actual Link from the LinkManager this.remoteAddress = (TCPIPNodeAddress)otherID.getNodeAddress(); this.remoteID = otherID; // Set connected to toReturn this.connected = toReturn; return toReturn; } // We do not have a tcpip? Should never really happen however. Log and throw Exception Node.err.log(this.getClass(), "Tried to connect a TCPIPLink to a non TCPIP connection"); throw new JCSPNetworkException("Tried to connect a TCPIPLink to a non TCPIP connection"); } catch (IOException ioe) { // Something went wrong during the connection process. Log and throw exception. Node.err.log(this.getClass(), "Failed to connect TCPIPLink to: " + this.remoteAddress.getAddress()); throw new JCSPNetworkException("Failed to connect TCPIPLink to: " + this.remoteAddress.getAddress()); } } /** * Creates any required resources. For TCP/IP there is none. * * @return True if all resources were created OK. Always the case in TCP/IP * @throws JCSPNetworkException * Thrown if anything goes wrong during the creation process. */ protected boolean createResources() throws JCSPNetworkException { // Just return true return true; } /** * Destroys any resources used by the Link */ protected void destroyResources() { try { // We must ensure only one process can call destroy at any time synchronized (this) { // Check that the socket is still in existence if (this.sock != null) { // Close the streams this.txStream.close(); this.rxStream.close(); // Close the socket this.sock.close(); // Set the socket to null this.sock = null; // Remove the Link from the LinkManager this.lostLink(); } } } catch (Exception e) { // Hopefully nothing bad has happened. If it has, we still need to // register the Link as lost this.lostLink(); } } /** * Gets the NodeAddress of the Node that this Link is connected to * * @return The NodeAddress of the remotely connected Node */ public NodeAddress getRemoteAddress() { return this.remoteAddress; } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/tcpip/TCPIPNodeServer.java 0000644 0000000 0000000 00000005616 11072626250 020661 0 ustar package org.jcsp.net2.tcpip; import java.net.Inet4Address; import java.net.InetAddress; import org.jcsp.lang.CSProcess; import org.jcsp.lang.Parallel; import org.jcsp.net2.Node; import org.jcsp.net2.bns.BNS; import org.jcsp.net2.cns.CNS; /** * The new name for the TCPIPCNSServer. Use this class instead. * * @author Kevin Chalmers */ public final class TCPIPNodeServer { /** * @param args * @throws Exception */ public static void main(String[] args) throws Exception { Node.getInstance().setLog(System.out); Node.getInstance().setErr(System.err); // Get the local IP addresses InetAddress[] local = InetAddress.getAllByName(InetAddress.getLocalHost().getHostName()); InetAddress toUse = InetAddress.getLocalHost(); // We basically have four types of addresses to worry about. Loopback (127), link local (169), // local (192) and (possibly) global. Grade each 1, 2, 3, 4 and use highest scoring address. In all // cases use first address of that score. int current = 0; // Loop until we have checked all the addresses for (int i = 0; i < local.length; i++) { // Ensure we have an IPv4 address if (local[i] instanceof Inet4Address) { // Get the first byte of the address byte first = local[i].getAddress()[0]; // Now check the value if (first == (byte)127 && current < 1) { // We have a Loopback address current = 1; // Set the address to use toUse = local[i]; } else if (first == (byte)169 && current < 2) { // We have a link local address current = 2; // Set the address to use toUse = local[i]; } else if (first == (byte)192 && current < 3) { // We have a local address current = 3; // Set the address to use toUse = local[i]; } else { // Assume the address is globally accessible and use by default. toUse = local[i]; // Break from the loop break; } } } // Create a local address object TCPIPNodeAddress localAddr = new TCPIPNodeAddress(toUse.getHostAddress(), 7890); // Initialise the Node Node.getInstance().init(localAddr); // Start CNS and BNS CSProcess[] processes = { CNS.getInstance(), BNS.getInstance() }; new Parallel(processes).run(); } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/tcpip/TCPIPNodeAddress.java 0000644 0000000 0000000 00000007455 11072626250 021003 0 ustar package org.jcsp.net2.tcpip; import org.jcsp.net2.JCSPNetworkException; import org.jcsp.net2.Link; import org.jcsp.net2.LinkServer; import org.jcsp.net2.NodeAddress; import org.jcsp.net2.ProtocolID; /** * A concrete implementation of a NodeAddress that is designed for TCP/IP connections. * * @see NodeAddress * @author Kevin Chalmers */ public final class TCPIPNodeAddress extends NodeAddress { /** * The SUID for this class */ private static final long serialVersionUID = 1L; /** * The IP address part of the address */ private String ip; /** * The port part of the address */ private int port; /** * Creates a new TCPIPNodeAddress from an IP address and port * * @param ipAddress * The IP address part of the NodeAddress * @param portNumber * The port number part of the NodeAddress */ public TCPIPNodeAddress(String ipAddress, int portNumber) { this.ip = ipAddress; this.port = portNumber; this.protocol = "tcpip"; this.address = ipAddress + ":" + portNumber; } /** * Creates a new TCPIPNodeAddress using the local IP address and a given port number. Allows a * * @param portNumber * The port number to use */ public TCPIPNodeAddress(int portNumber) { this.port = portNumber; this.ip = ""; this.protocol = "tcpip"; } /** * Creates a new TCPIPNodeAddress */ public TCPIPNodeAddress() { this.port = 0; this.ip = ""; this.protocol = "tcpip"; } /** * Gets the port number part of this address * * @return The port number part of the address */ public final int getPort() { return this.port; } /** * Sets the port part of the address. Used internally in JCSP * * @param portNumber * The port number to use */ void setPort(int portNumber) { this.port = portNumber; } /** * Gets the IP address part of the address * * @return The IP Address part of the address */ public final String getIpAddress() { return this.ip; } /** * Sets the IP address part of the NodeAddress. Used internally in JCSP * * @param ipAddr * The IP address to use */ void setIpAddress(String ipAddr) { this.ip = ipAddr; } /** * Sets the address String. Used internally within JCSP * * @param str * The String to set as the address */ void setAddress(String str) { this.address = str; } /** * Creates a new TCPIPLink connected to a Node with this address * * @return A new TCPIPLink connected to this address * @throws JCSPNetworkException * Thrown if something goes wrong during the creation of the Link */ protected Link createLink() throws JCSPNetworkException { return new TCPIPLink(this); } /** * Creates a new TCPIPLinkServer listening on this address * * @return A new TCPIPLinkServer listening on this address * @throws JCSPNetworkException * Thrown if something goes wrong during the creation of the LinkServer */ protected LinkServer createLinkServer() throws JCSPNetworkException { return new TCPIPLinkServer(this); } /** * Returns the TCPIPProtocolID * * @return TCPIPProtocolID */ protected ProtocolID getProtocolID() { return TCPIPProtocolID.getInstance(); } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/tcpip/TCPIPProtocolID.java 0000644 0000000 0000000 00000003156 11072626250 020620 0 ustar package org.jcsp.net2.tcpip; import org.jcsp.net2.NodeAddress; import org.jcsp.net2.ProtocolID; /** * Concrete implementation of a ProtocolID used to parse a string representation of a TCPIPNodeAddress into a * TCPIPNodeAddress object. * * @author Kevin Chalmers */ public final class TCPIPProtocolID extends ProtocolID { /** * Singleton instance of this class */ private static TCPIPProtocolID instance = new TCPIPProtocolID(); /** * Gets the singleton instance of this class * * @return A new singleton instance of this class */ public static TCPIPProtocolID getInstance() { return instance; } /** * Default private constructor */ private TCPIPProtocolID() { // Empty constructor } /** * Parses a string to recreate a TCPIPNodeAddress object * * @param addressString * String representing the address * @return A new TCPIPNodeAddress object * @throws IllegalArgumentException * Thrown if the address is not in a correct form */ protected NodeAddress parse(String addressString) throws IllegalArgumentException { // Split address into IP and port int index = addressString.indexOf("\\\\"); String temp = addressString.substring(index + 2); index = temp.indexOf(":"); String address = temp.substring(0, index); int port = Integer.parseInt(temp.substring(index + 1, temp.length())); return new TCPIPNodeAddress(address, port); } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/tcpip/TCPIPNodeFactory.java 0000644 0000000 0000000 00000011436 11072626250 021017 0 ustar package org.jcsp.net2.tcpip; import java.io.IOException; import java.net.Inet4Address; import java.net.InetAddress; import java.net.ServerSocket; import java.net.UnknownHostException; import org.jcsp.lang.ProcessManager; import org.jcsp.net2.JCSPNetworkException; import org.jcsp.net2.Node; import org.jcsp.net2.NodeAddress; import org.jcsp.net2.NodeFactory; /** * Used to initialise a Node. This is kept for backward compatibility. See Node for more information. * * @see Node * @see NodeFactory * @deprecated This method of Node initialisation should no longer be used. See Node for more information * @author Kevin Chalmers */ public final class TCPIPNodeFactory extends NodeFactory { /** * Creates a new TCPIPNodeFactory * * @param addr * The address of the CNS / BNS */ public TCPIPNodeFactory(TCPIPNodeAddress addr) { this.cnsAddress = addr; } /** * Creates a new TCPIPNodeFactory * * @param serverIP * The IP address of the CNS / BNS */ public TCPIPNodeFactory(String serverIP) { this.cnsAddress = new TCPIPNodeAddress(serverIP, 7890); } /** * Initialises the Node, connecting to the CNS / BNS * * @param node * The Node to initialise * @return A new NodeAddress which the Node is registered at * @throws JCSPNetworkException * Thrown if something goes wrong during the Node initialisation process */ protected NodeAddress initNode(Node node) throws JCSPNetworkException { // First install TCPIPProtocolID NodeAddress.installProtocol("tcpip", TCPIPProtocolID.getInstance()); try { // Get the local IP addresses InetAddress[] local = InetAddress.getAllByName(InetAddress.getLocalHost().getHostName()); InetAddress toUse = InetAddress.getLocalHost(); // We basically have four types of addresses to worry about. Loopback (127), link local (169), // local (192) and (possibly) global. Grade each 1, 2, 3, 4 and use highest scoring address. In all // cases use first address of that score. int current = 0; // Loop until we have checked all the addresses for (int i = 0; i < local.length; i++) { // Ensure we have an IPv4 address if (local[i] instanceof Inet4Address) { // Get the first byte of the address byte first = local[i].getAddress()[0]; // Now check the value if (first == (byte)127 && current < 1) { // We have a Loopback address current = 1; // Set the address to use toUse = local[i]; } else if (first == (byte)169 && current < 2) { // We have a link local address current = 2; // Set the address to use toUse = local[i]; } else if (first == (byte)192 && current < 3) { // We have a local address current = 3; // Set the address to use toUse = local[i]; } else { // Assume the address is globally accessible and use by default. toUse = local[i]; // Break from the loop break; } } } // Create a new ServerSocket listening on this address ServerSocket serv = new ServerSocket(0, 10, toUse); // Create the local address TCPIPNodeAddress localAddr = new TCPIPNodeAddress(toUse.getHostAddress(), serv.getLocalPort()); // Create and start the LinkServer TCPIPLinkServer server = new TCPIPLinkServer(serv); new ProcessManager(server).start(); // Return the NodeAddress return localAddr; } catch (UnknownHostException uhe) { throw new JCSPNetworkException("Failed to start TCPIPLinkServer. Could not get local IP address.\n" + uhe.getMessage()); } catch (IOException ioe) { throw new JCSPNetworkException("Failed to open new Server Socket.\n" + ioe.getMessage()); } } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/tcpip/TCPIPCNSServer.java 0000644 0000000 0000000 00000005604 11072626250 020414 0 ustar package org.jcsp.net2.tcpip; import java.net.Inet4Address; import java.net.InetAddress; import org.jcsp.lang.CSProcess; import org.jcsp.lang.Parallel; import org.jcsp.net2.Node; import org.jcsp.net2.bns.BNS; import org.jcsp.net2.cns.CNS; /** * This is the original (now deprecated) server program for use by * * @author Kevin Chalmers (updated from Quickstone Technologies) * @deprecated Use TCPIPNodeFactory instead */ public final class TCPIPCNSServer { /** * @param args * @throws Exception */ public static void main(String[] args) throws Exception { // Get the local IP addresses InetAddress[] local = InetAddress.getAllByName(InetAddress.getLocalHost().getHostName()); InetAddress toUse = InetAddress.getLocalHost(); // We basically have four types of addresses to worry about. Loopback (127), link local (169), // local (192) and (possibly) global. Grade each 1, 2, 3, 4 and use highest scoring address. In all // cases use first address of that score. int current = 0; // Loop until we have checked all the addresses for (int i = 0; i < local.length; i++) { // Ensure we have an IPv4 address if (local[i] instanceof Inet4Address) { // Get the first byte of the address byte first = local[i].getAddress()[0]; // Now check the value if (first == (byte)127 && current < 1) { // We have a Loopback address current = 1; // Set the address to use toUse = local[i]; } else if (first == (byte)169 && current < 2) { // We have a link local address current = 2; // Set the address to use toUse = local[i]; } else if (first == (byte)192 && current < 3) { // We have a local address current = 3; // Set the address to use toUse = local[i]; } else { // Assume the address is globally accessible and use by default. toUse = local[i]; // Break from the loop break; } } } // Create a local address object TCPIPNodeAddress localAddr = new TCPIPNodeAddress(toUse.getHostAddress(), 7890); // Initialise the Node Node.getInstance().init(localAddr); // Start CNS and BNS CSProcess[] processes = { CNS.getInstance(), BNS.getInstance() }; new Parallel(processes).run(); } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/tcpip/TCPIPLinkServer.java 0000644 0000000 0000000 00000024167 11072626250 020673 0 ustar package org.jcsp.net2.tcpip; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.net.Inet4Address; import java.net.InetAddress; import java.net.ServerSocket; import java.net.Socket; import org.jcsp.lang.ProcessManager; import org.jcsp.net2.JCSPNetworkException; import org.jcsp.net2.LinkServer; import org.jcsp.net2.Node; import org.jcsp.net2.NodeID; /** * Concrete implementation of a LinkServer that listens on a TCP/IP based ServerSocket. For information on LinkServer, * see the relevant documentation. ** It is possible for an advanced user to create this object themselves, although it is not recommended. For example: *
*
*
* TCPIPLinkServer serv = new TCPIPLinkServer(address);
*
* new ProcessManager(serv).start();
*
* This is done automatically during Node initialisation. However, if the machine used has multiple interfaces, this can * be used to listen on another interface also. *
* * @see LinkServer * @author Kevin Chalmers */ public final class TCPIPLinkServer extends LinkServer { /** * The ServerSocket that this class wraps around. The process listens on this connection */ private final ServerSocket serv; /** * The NodeAddress that this LinkServer is listening on. This should be the same as the Node's address. */ final TCPIPNodeAddress listeningAddress; /** * Creates LinkServer by wrapping round an existing ServerSocket. Used internally by JCSP * * @param serverSocket * The ServerSocket to create the LinkServer with */ TCPIPLinkServer(ServerSocket serverSocket) { // We need to set the NodeAddress. Create from ServerSocket address and port this.listeningAddress = new TCPIPNodeAddress(serverSocket.getInetAddress().getHostAddress(), serverSocket .getLocalPort()); this.serv = serverSocket; } /** * Creates a new TCPIPLinkServer listening on the given address * * @param address * The address to listen on for new connections * @throws JCSPNetworkException * Thrown if something goes wrong during the creation of the ServerSocket */ public TCPIPLinkServer(TCPIPNodeAddress address) throws JCSPNetworkException { try { // First check if we have an ip address in the string if (address.getIpAddress().equals("")) { // Get the local IP addresses InetAddress[] local = InetAddress.getAllByName(InetAddress.getLocalHost().getHostName()); InetAddress toUse = InetAddress.getLocalHost(); // We basically have four types of addresses to worry about. Loopback (127), link local (169), // local (192) and (possibly) global. Grade each 1, 2, 3, 4 and use highest scoring address. In all // cases use first address of that score. int current = 0; // Loop until we have checked all the addresses for (int i = 0; i < local.length; i++) { // Ensure we have an IPv4 address if (local[i] instanceof Inet4Address) { // Get the first byte of the address byte first = local[i].getAddress()[0]; // Now check the value if (first == (byte)127 && current < 1) { // We have a Loopback address current = 1; // Set the address to use toUse = local[i]; } else if (first == (byte)169 && current < 2) { // We have a link local address current = 2; // Set the address to use toUse = local[i]; } else if (first == (byte)192 && current < 3) { // We have a local address current = 3; // Set the address to use toUse = local[i]; } else { // Assume the address is globally accessible and use by default. toUse = local[i]; // Break from the loop break; } } } // Now set the IP address of the address address.setIpAddress(toUse.getHostAddress()); // Set the address part now, but it may change if we have to get a port number address.setAddress(address.getIpAddress() + ":" + address.getPort()); } // Now check if the address has a port number if (address.getPort() == 0) { // No port number supplied. Get one as we create the ServerSocket InetAddress socketAddress = InetAddress.getByName(address.getIpAddress()); // Create the server socket with a random port this.serv = new ServerSocket(0, 0, socketAddress); // Assign the port to the address address.setPort(this.serv.getLocalPort()); // And set the address address.setAddress(address.getIpAddress() + ":" + address.getPort()); // Set the listening address this.listeningAddress = address; } else { // Create an IP address from the NodeAddress InetAddress inetAddress = InetAddress.getByName(address.getIpAddress()); // Now create the ServerSocket this.serv = new ServerSocket(address.getPort(), 10, inetAddress); // Set listeningAddress this.listeningAddress = address; } } catch (IOException ioe) { throw new JCSPNetworkException("Failed to create TCPIPLinkServer on: " + address.getAddress()); } } /** * The run method for the TCPIPLinkServer process */ public void run() { // Log start of Link Server Node.log.log(this.getClass(), "TCPIP Link Server started on " + this.listeningAddress.getAddress()); try { // Now we loop until something goes wrong while (true) { // Receive incoming connection Socket incoming = this.serv.accept(); // Log Node.log.log(this.getClass(), "Received new incoming connection"); // Set TcpNoDelay incoming.setTcpNoDelay(true); // Now we want to receive the connecting Node's NodeID DataInputStream inStream = new DataInputStream(incoming.getInputStream()); // Receive remote NodeID and parse String otherID = inStream.readUTF(); NodeID remoteID = NodeID.parse(otherID); // First check we have a tcpip Node connection if (remoteID.getNodeAddress() instanceof TCPIPNodeAddress) { // Create an output stream from the Socket DataOutputStream outStream = new DataOutputStream(incoming.getOutputStream()); // Now Log that we have received a connection Node.log.log(this.getClass(), "Received connection from: " + remoteID.toString()); // Check if already connected if (requestLink(remoteID) == null) { // No existing connection to incoming Node exists. Keep connection // Write OK to the connecting Node outStream.writeUTF("OK"); outStream.flush(); // Send out our NodeID outStream.writeUTF(Node.getInstance().getNodeID().toString()); outStream.flush(); // Create Link, register, and start. TCPIPLink link = new TCPIPLink(incoming, remoteID); registerLink(link); new ProcessManager(link).start(); } else { // We already have a connection to the incoming Node // Log failed connection Node.log.log(this.getClass(), "Connection to " + remoteID + " already exists. Informing remote Node."); // Write EXISTS to the remote Node outStream.writeUTF("EXISTS"); outStream.flush(); // Send out NodeID. We do this so the opposite Node can find its own connection outStream.writeUTF(Node.getInstance().getNodeID().toString()); outStream.flush(); // Close socket incoming.close(); } } // Address is not a TCPIP address. Close socket. This will cause an exception on the opposite Node else incoming.close(); } } catch (IOException ioe) { // We can't really recover from this. This may happen if the network connection was lost. // Log and fail Node.err.log(this.getClass(), "TCPIPLinkServer failed. " + ioe.getMessage()); } } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/ProtocolID.java 0000644 0000000 0000000 00000001503 11072626250 016673 0 ustar package org.jcsp.net2; import org.jcsp.net.tcpip.TCPIPProtocolID; /** * This abstract class must be defined in concrete protocol implementations. Its main usage is to allow installation and * correct parsing of relevant address strings into correct address objects. See TCPIPProtocolID for an example. * * @see TCPIPProtocolID * @author Kevin Chalmers */ public abstract class ProtocolID { /** * Parses an address string into an address object * * @param addressString * String representation of an address * @return A new NodeAddress object * @throws IllegalArgumentException * Thrown if the string is in an incorrect form */ protected abstract NodeAddress parse(String addressString) throws IllegalArgumentException; } jcsp-1.1-rc4.orig/src/org/jcsp/net2/LinkManager.java 0000644 0000000 0000000 00000011306 11072626250 017047 0 ustar package org.jcsp.net2; import java.util.ArrayList; import java.util.Hashtable; import java.util.Iterator; import org.jcsp.lang.AltingChannelInput; import org.jcsp.lang.Channel; import org.jcsp.lang.ChannelOutput; import org.jcsp.lang.One2OneChannel; import org.jcsp.util.InfiniteBuffer; /** * Class for managing Links. Ensures that only one Link is only ever created for each individual Node that the hosting * Node may be connected to. This is an internal management class of JCSP. For information on how to create Links, see * LinkFactory. * * @see Link * @see LinkFactory * @author Kevin Chalmers (updated from Quickstone Technologies) */ final class LinkManager { /** * A table containing the links currently in operation within the Node. The key is a NodeID and the value is the * Link itself for that specific NodeID. */ private static final Hashtable links = new Hashtable(); /** * These event channels are used by the LinkManager to inform any process that may be interested in Link Lost * events. */ private static ArrayList eventChans = new ArrayList(); /** * Singleton instance of the LinkManager. */ private static LinkManager instance = new LinkManager(); /** * Private default constructor for singleton instance. */ private LinkManager() { // Empty constructor } /** * Gets the singleton instance of the LinkManager * * @return The singleton instance of the LinkManager */ static LinkManager getInstance() { return instance; } /** * Handles a Link Lost event. This is done by sending messages over the event channels registered in the eventChans * ArrayList. This is possible in the current thread as each event channel is infinitely buffered, so no blocking * can occur. * * @param link * The Link that has been lost. */ synchronized void lostLink(Link link) { // First remove the Link from the links table, using the Link's NodeID Link removed = (Link)links.remove(link.remoteID); // Now check if the Link was indeed removed. Unlikely to happened, but the Link may have been previously removed // meaning we have achieved nothing if (removed != null) { // Log the Link Lost Node.log.log(this.getClass(), "Link lost to: " + removed.remoteID); // Now inform any process listening on a Link Lost channel for (Iterator iter = eventChans.iterator(); iter.hasNext();) ((ChannelOutput)iter.next()).write(removed.remoteID); } } /** * Registers a new Link with the LinkManager. * * @param link * The Link to register. * @return True if a Link to the Node does not yet exist, false otherwise. */ synchronized boolean registerLink(Link link) { // Log the registration attempt Node.log.log(this.getClass(), "Trying to register Link to: " + link.remoteID); // Retrieve the NodeID for the Link NodeID remoteID = link.remoteID; // Now check whether the key has been registered in the Links table if (links.containsKey(remoteID)) { // Connection to the Node already exists. Log. Node.err.log(this.getClass(), "Failed to register Link to " + link.remoteID + ". Connection to Node already exists"); // Return false. return false; } // Link registration successful. Log. Node.log.log(this.getClass(), "Link established to: " + link.remoteID); // Add the Link to the links table links.put(link.remoteID, link); // Return true return true; } /** * Returns the Link for the given NodeID * * @param id * The NodeID of the remote node * @return The Link for the given NodeID */ synchronized Link requestLink(NodeID id) { return (Link)links.get(id); } /** * Gets a channel input end for receiving Link Lost events. * * @return A input end for receiving Link Lost Events. */ synchronized AltingChannelInput getLinkLostEventChannel() { // Create a new infinitely buffered one to one channel final One2OneChannel eventChan = Channel.one2one(new InfiniteBuffer()); // Add the output end to the list of event channels eventChans.add(eventChan.out()); // Return the input end return eventChan.in(); } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/ResettableByteArrayInputStream.java 0000644 0000000 0000000 00000001632 11072626250 022771 0 ustar package org.jcsp.net2; import java.io.ByteArrayInputStream; /** * This class is used by the ObjectNetworkMessageFilter. It acts as a ByteArrayInputStream, but allows the internal byte * array to be replaced by another. This stops unnecessary object creation * * @author Kevin Chalmers */ final class ResettableByteArrayInputStream extends ByteArrayInputStream { /** * Creates a new ResettableByteArrayInputStream * * @param bytes * The byte array to read data from */ ResettableByteArrayInputStream(byte[] bytes) { super(bytes); } /** * Replaces the internal byte array * * @param bytes * The byte array to replace the existing internal one */ void reset(byte[] bytes) { this.buf = bytes; this.count = bytes.length; this.pos = 0; } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/Net2AnyChannel.java 0000644 0000000 0000000 00000021032 11072626250 017425 0 ustar package org.jcsp.net2; import org.jcsp.net2.NetworkMessageFilter.FilterRx; /** * This class is a concrete implementation of a NetSharedChannelInput, and acts as a wrapper to a Net2OneChannel, * allowing safe shared access. This class is internal to the JCSP architecture. To create an instance of this class, * use the NetChannel factory, or the CNS. * * @see NetChannelInput * @see NetSharedChannelInput * @see NetChannel * @author Kevin Chalmers (updated from Quickstone Technologies) * @author Neil Brown (for the extended read operations) */ final class Net2AnyChannel implements NetSharedChannelInput { /** * The underlying Net2OneChannel that this object wraps around */ private final Net2OneChannel actualChannel; /** * A mutual exclusion lock, allowing only one process access to perform a read operation at a time */ private final Mutex mutex = new Mutex(); /** * A static factory method to create a new Net2AnyChannel object * * @param poisonImmunity * The immunity level of the channel * @param filter * The filter used to convert an incoming byte array into an object * @return A new Net2AnyChannel * @throws JCSPNetworkException * Thrown if there is a problem creating the underlying channel */ static Net2AnyChannel create(int poisonImmunity, NetworkMessageFilter.FilterRx filter) throws JCSPNetworkException { // Create the underlying channel Net2OneChannel chan = Net2OneChannel.create(poisonImmunity, filter); // Return a new instance of this object return new Net2AnyChannel(chan); } /** * Static factory method for creating a new instance of Net2AnyChannel, given a particular index * * @param index * The index to create the channel with * @param poisonImmunity * the immunity level of the channels * @param filter * The filter used to convert the byte array back into an object * @return A new Net2AnyChannel * @throws IllegalArgumentException * Thrown if a channel with the given index already exists * @throws JCSPNetworkException * Thrown if something goes wrong during the creation of the underlying channel */ static Net2AnyChannel create(int index, int poisonImmunity, NetworkMessageFilter.FilterRx filter) throws IllegalArgumentException, JCSPNetworkException { // Create the underlying channel Net2OneChannel chan = Net2OneChannel.create(index, poisonImmunity, filter); // Return a new instance of Net2AnyChannel return new Net2AnyChannel(chan); } /** * Constructor for Net2AnyChannel * * @param chan * The underlying channel that this object will wrap around */ private Net2AnyChannel(Net2OneChannel chan) { this.actualChannel = chan; } /** * Ends an extended read operation * * @throws IllegalStateException * Thrown if the channel is not in an extended read state * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying network architecture * @throws NetworkPoisonException * Thrown if the underlying channel has been poisoned */ public void endRead() throws IllegalStateException, JCSPNetworkException, NetworkPoisonException { // Acquire lock on the channel to ensure exclusive access synchronized (this) { // We now try and end the read operation. There are a number of possible exceptions // that can be thrown, so we must catch them and re-throw them. What we must ensure is // done is that the mutex is released. try { this.actualChannel.endRead(); } catch (IllegalStateException ise) { throw ise; } catch (JCSPNetworkException jne) { throw jne; } catch (NetworkPoisonException npe) { throw npe; } finally { this.mutex.release(); } } } /** * Reads the next message from the channel * * @return Message read from the channel * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture * @throws IllegalStateException * Thrown if the channel is in an extended read state * @throws NetworkPoisonException * Thrown if the channel has been poisoned */ public Object read() throws JCSPNetworkException, IllegalStateException, NetworkPoisonException { // First, we must endure that only one process is trying to perform a read operations this.mutex.claim(); // Now ensure that we are the only process operating on the underlying channel synchronized (this) { // We now try and perform the read operation. There are a number of possible exceptions, which we must // catch and then re-throw again. Finally, we must ensure that the read operation is finished by // releasing the mutex. try { Object toReturn = this.actualChannel.read(); return toReturn; } catch (JCSPNetworkException jne) { throw jne; } catch (IllegalStateException ise) { throw ise; } catch (NetworkPoisonException npe) { throw npe; } finally { this.mutex.release(); } } } /** * Begins an extended read operation on the channel * * @return The message read from the channel * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture * @throws NetworkPoisonException * Thrown if the channel has been poisoned * @throws IllegalStateException * Thrown if the channel is in an extended read state */ public Object startRead() throws JCSPNetworkException, NetworkPoisonException, IllegalStateException { // First ensure we have exclusive read access this.mutex.claim(); // Now ensure we have exclusive access to the channel synchronized (this) { // Now return the message read from the channel. We could encounter a number of exceptions here, in which // case we must re-throw the exception, remembering to release to release the read lock prior to doing so. try { return this.actualChannel.startRead(); } catch (JCSPNetworkException jne) { this.mutex.release(); throw jne; } catch (NetworkPoisonException npe) { this.mutex.release(); throw npe; } catch (IllegalStateException ise) { this.mutex.release(); throw ise; } } } /** * Poisons the underlying channel * * @param strength * The strength of the poison */ public void poison(int strength) { synchronized (this) { this.actualChannel.poison(strength); } } /** * Gets the channel location of this channel * * @return Location of this channel */ public NetLocation getLocation() { return this.actualChannel.getLocation(); } /** * Destroys the channel */ public void destroy() { synchronized (this) { this.actualChannel.destroy(); } } /** * Sets the underlying message filter * * @param decoder * The new message filter to use */ public void setDecoder(FilterRx decoder) { synchronized (this) { this.actualChannel.setDecoder(decoder); } } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/mobile/ 0000755 0000000 0000000 00000000000 11410045051 015250 5 ustar jcsp-1.1-rc4.orig/src/org/jcsp/net2/mobile/CodeLoadingChannelFilter.java 0000644 0000000 0000000 00000006746 11072626250 022751 0 ustar package org.jcsp.net2.mobile; import java.io.ByteArrayInputStream; import java.io.IOException; import org.jcsp.net2.NetChannelLocation; import org.jcsp.net2.NetworkMessageFilter; import org.jcsp.net2.Node; import org.jcsp.net2.ObjectNetworkMessageFilter; /** * @author Kevin */ public final class CodeLoadingChannelFilter { public static final class FilterRX implements NetworkMessageFilter.FilterRx { private final ObjectNetworkMessageFilter.FilterRX objectFilter = new ObjectNetworkMessageFilter.FilterRX(); public FilterRX() { // Do nothing } public Object filterRX(byte[] bytes) throws IOException { try { Object message = this.objectFilter.filterRX(bytes); if (!(message instanceof DynamicClassLoaderMessage)) { return message; } DynamicClassLoaderMessage loaderMessage = (DynamicClassLoaderMessage)message; byte[] bytesWithHeader = new byte[4 + loaderMessage.bytes.length]; byte[] header = { -84, -19, 0, 5 }; System.arraycopy(header, 0, bytesWithHeader, 0, 4); System.arraycopy(loaderMessage.bytes, 0, bytesWithHeader, 4, loaderMessage.bytes.length); ByteArrayInputStream bais = new ByteArrayInputStream(bytesWithHeader); DynamicClassLoader loader = (DynamicClassLoader)ClassManager.classLoaders .get(loaderMessage.originatingNode); if (loader == null) { loader = new DynamicClassLoader(loaderMessage.originatingNode, loaderMessage.requestLocation); ClassManager.classLoaders.put(loaderMessage.originatingNode, loader); } DynamicObjectInputStream dois = new DynamicObjectInputStream(bais, loader); Object toReturn = dois.readObject(); return toReturn; } catch (ClassNotFoundException cnfe) { throw new IOException("Failed to load class"); } } } public static final class FilterTX implements NetworkMessageFilter.FilterTx { private final ObjectNetworkMessageFilter.FilterTX internalFilter = new ObjectNetworkMessageFilter.FilterTX(); public FilterTX() { } public byte[] filterTX(Object obj) throws IOException { ClassLoader loader = obj.getClass().getClassLoader(); byte[] bytes = this.internalFilter.filterTX(obj); if (loader == ClassLoader.getSystemClassLoader() || loader == null) { DynamicClassLoaderMessage message = new DynamicClassLoaderMessage(Node.getInstance().getNodeID(), (NetChannelLocation)ClassManager.in.getLocation(), bytes); byte[] wrappedData = this.internalFilter.filterTX(message); return wrappedData; } DynamicClassLoader dcl = (DynamicClassLoader)loader; DynamicClassLoaderMessage message = new DynamicClassLoaderMessage(dcl.originatingNode, (NetChannelLocation)ClassManager.in.getLocation(), bytes); byte[] wrappedData = this.internalFilter.filterTX(message); return wrappedData; } } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/mobile/MessageBox.java 0000644 0000000 0000000 00000010462 11072626250 020165 0 ustar package org.jcsp.net2.mobile; import org.jcsp.lang.Alternative; import org.jcsp.lang.CSProcess; import org.jcsp.lang.Guard; import org.jcsp.net2.JCSPNetworkException; import org.jcsp.net2.NetAltingChannelInput; import org.jcsp.net2.NetChannel; import org.jcsp.net2.NetChannelLocation; import org.jcsp.net2.NetChannelOutput; import org.jcsp.net2.NetworkMessageFilter; import org.jcsp.net2.Node; final class MessageBox implements CSProcess { private final NetAltingChannelInput in; private final NetAltingChannelInput fromInputEnd; private NetChannelOutput toInputEnd = null; private final NetworkMessageFilter.FilterTx encoder; private final NetChannelLocation inputEndLoc = null; MessageBox(NetAltingChannelInput intoBox, NetAltingChannelInput requestChannel, NetworkMessageFilter.FilterTx encodingFilter) { this.in = intoBox; this.fromInputEnd = requestChannel; this.encoder = encodingFilter; } public void run() { try { while (true) { MobileChannelMessage msg = (MobileChannelMessage)fromInputEnd.read(); if (msg.type == MobileChannelMessage.REQUEST) { if (!msg.inputLocation.equals(this.inputEndLoc)) { if (this.toInputEnd != null) { this.toInputEnd.destroy(); } this.toInputEnd = NetChannel.one2net(msg.inputLocation, this.encoder); } Object obj = this.in.read(); this.toInputEnd.write(obj); } else if (msg.type == MobileChannelMessage.CHECK) { if (!msg.inputLocation.equals(this.inputEndLoc)) { if (this.toInputEnd != null) { this.toInputEnd.destroy(); } this.toInputEnd = NetChannel.one2net(msg.inputLocation, this.encoder); } MobileChannelMessage response = new MobileChannelMessage(); response.type = MobileChannelMessage.CHECK_RESPONSE; if (this.in.pending()) { response.ready = true; this.toInputEnd.write(response); } else { this.toInputEnd.write(response); Guard[] guards = { this.fromInputEnd, this.in }; Alternative alt = new Alternative(guards); int selected = alt.priSelect(); if (selected == 1) { MobileChannelMessage resp = new MobileChannelMessage(); resp.type = MobileChannelMessage.CHECK_RESPONSE; resp.ready = true; try { // Try and write to the input end this.toInputEnd.write(response); } catch (JCSPNetworkException ex) { // The channel input end is no longer there. // Quietly ignore and wait for request. } } // If a new message from the input end has been received, then deal with // that message separately. Go into the main loop again. } } } } catch (JCSPNetworkException jne) { // Something went wrong during comms. Kill the message box and all channels. this.in.destroy(); this.fromInputEnd.destroy(); if (this.toInputEnd != null) { this.toInputEnd.destroy(); } Node.err.log(this.getClass(), "Message box threw exception during comms. Destroying"); } } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/mobile/MobileChannelInput.java 0000644 0000000 0000000 00000007574 11072626250 021662 0 ustar package org.jcsp.net2.mobile; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; import org.jcsp.lang.ProcessManager; import org.jcsp.net2.NetAltingChannelInput; import org.jcsp.net2.NetChannel; import org.jcsp.net2.NetChannelInput; import org.jcsp.net2.NetChannelLocation; import org.jcsp.net2.NetChannelOutput; import org.jcsp.net2.NetLocation; import org.jcsp.net2.NetworkMessageFilter; import org.jcsp.net2.ObjectNetworkMessageFilter; import org.jcsp.net2.NetworkMessageFilter.FilterRx; public final class MobileChannelInput implements NetChannelInput, Serializable { private NetChannelLocation messageBoxLoc; private NetChannelLocation msgBoxReqLoc; private transient NetChannelInput actualIn; private transient NetChannelOutput toMessageBox; public MobileChannelInput() { NetAltingChannelInput toMsgBox = NetChannel.net2one(); NetAltingChannelInput msgBoxReq = NetChannel.net2one(); MessageBox msgBox = new MessageBox(toMsgBox, msgBoxReq, new ObjectNetworkMessageFilter.FilterTX()); new ProcessManager(msgBox).start(); this.messageBoxLoc = (NetChannelLocation)toMsgBox.getLocation(); this.msgBoxReqLoc = (NetChannelLocation)msgBoxReq.getLocation(); this.actualIn = NetChannel.net2one(); this.toMessageBox = NetChannel.one2net(this.msgBoxReqLoc); } public MobileChannelInput(NetworkMessageFilter.FilterTx encoder, NetworkMessageFilter.FilterRx decoder) { NetAltingChannelInput toMsgBox = NetChannel.net2one(decoder); NetAltingChannelInput msgBoxReq = NetChannel.net2one(); MessageBox msgBox = new MessageBox(toMsgBox, msgBoxReq, encoder); new ProcessManager(msgBox).start(); this.messageBoxLoc = (NetChannelLocation)toMsgBox.getLocation(); this.msgBoxReqLoc = (NetChannelLocation)msgBoxReq.getLocation(); this.actualIn = NetChannel.net2one(decoder); this.toMessageBox = NetChannel.one2net(this.msgBoxReqLoc); } public void endRead() { this.actualIn.endRead(); } public Object read() { MobileChannelMessage msg = new MobileChannelMessage(); msg.type = MobileChannelMessage.REQUEST; msg.inputLocation = (NetChannelLocation)this.actualIn.getLocation(); this.toMessageBox.write(msg); Object toReturn = this.actualIn.read(); return toReturn; } public Object startRead() { MobileChannelMessage msg = new MobileChannelMessage(); msg.type = MobileChannelMessage.REQUEST; msg.inputLocation = (NetChannelLocation)this.actualIn.getLocation(); this.toMessageBox.write(msg); Object toReturn = this.actualIn.startRead(); return toReturn; } public void poison(int strength) { this.actualIn.poison(strength); } public void destroy() { this.actualIn.destroy(); this.toMessageBox.destroy(); } public NetLocation getLocation() { return this.messageBoxLoc; } public void setDecoder(FilterRx decoder) { this.actualIn.setDecoder(decoder); } private void writeObject(ObjectOutputStream output) throws IOException { output.writeObject(this.messageBoxLoc); output.writeObject(this.msgBoxReqLoc); this.actualIn.destroy(); this.toMessageBox.destroy(); } private void readObject(ObjectInputStream input) throws IOException, ClassNotFoundException { this.messageBoxLoc = (NetChannelLocation)input.readObject(); this.msgBoxReqLoc = (NetChannelLocation)input.readObject(); this.actualIn = NetChannel.net2one(); this.toMessageBox = NetChannel.one2net(this.messageBoxLoc); } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/mobile/DynamicObjectInputStream.java 0000644 0000000 0000000 00000001177 11072626250 023042 0 ustar package org.jcsp.net2.mobile; import java.io.IOException; import java.io.InputStream; import java.io.ObjectInputStream; import java.io.ObjectStreamClass; /** * @author Kevin */ final class DynamicObjectInputStream extends ObjectInputStream { final DynamicClassLoader dcl; DynamicObjectInputStream(InputStream is, DynamicClassLoader loader) throws IOException { super(is); this.dcl = loader; } protected Class resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException { return dcl.loadClass(desc.getName()); } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/mobile/ClassData.java 0000644 0000000 0000000 00000000516 11072626250 017766 0 ustar package org.jcsp.net2.mobile; import java.io.Serializable; /** * @author Kevin */ final class ClassData implements Serializable { final String className; final byte[] bytes; ClassData(String name, byte[] classBytes) { this.className = name; this.bytes = classBytes; } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/mobile/DynamicClassLoader.java 0000644 0000000 0000000 00000005366 11072626250 021640 0 ustar package org.jcsp.net2.mobile; import java.util.Hashtable; import org.jcsp.net2.JCSPNetworkException; import org.jcsp.net2.NetChannel; import org.jcsp.net2.NetChannelInput; import org.jcsp.net2.NetChannelLocation; import org.jcsp.net2.NetChannelOutput; import org.jcsp.net2.NodeID; /** * @author Kevin */ final class DynamicClassLoader extends ClassLoader { final NodeID originatingNode; NetChannelOutput requestClassData; NetChannelInput classDataResponse = NetChannel.net2one(); final Hashtable classes = new Hashtable(); DynamicClassLoader(NodeID originator, NetChannelLocation requestLocation) { super(ClassLoader.getSystemClassLoader()); this.originatingNode = originator; this.requestClassData = NetChannel.one2net(requestLocation); } protected Class findClass(String className) throws ClassNotFoundException, JCSPNetworkException { try { Class clazz = Class.forName(className, false, ClassLoader.getSystemClassLoader()); return clazz; } catch (ClassNotFoundException cnfe) { try { byte[] bytes = this.requestClass(className); Class toReturn = this.defineClass(className, bytes, 0, bytes.length); this.resolveClass(toReturn); return toReturn; } catch (ClassNotFoundException cnf) { throw cnf; } } } synchronized byte[] requestClass(String className) throws ClassNotFoundException { try { byte[] bytes = (byte[])classes.get(className); if (bytes != null) { return bytes; } if (this.requestClassData == null) { throw new ClassNotFoundException(className); } ClassRequest req = new ClassRequest(this.originatingNode, className, (NetChannelLocation)this.classDataResponse.getLocation()); this.requestClassData.write(req); ClassData data = (ClassData)classDataResponse.read(); if (data.bytes == null) { throw new ClassNotFoundException(className); } this.classes.put(className, data.bytes); return data.bytes; } catch (JCSPNetworkException jne) { this.classDataResponse.destroy(); this.classDataResponse = null; this.requestClassData.destroy(); this.requestClassData = null; throw new ClassNotFoundException(className); } } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/mobile/ClassRequest.java 0000644 0000000 0000000 00000001046 11072626250 020544 0 ustar package org.jcsp.net2.mobile; import java.io.Serializable; import org.jcsp.net2.NetChannelLocation; import org.jcsp.net2.NodeID; /** * @author Kevin */ final class ClassRequest implements Serializable { final NodeID originatingNode; final String className; final NetChannelLocation returnLocation; ClassRequest(NodeID originator, String name, NetChannelLocation response) { this.originatingNode = originator; this.className = name; this.returnLocation = response; } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/mobile/MobileChannelMessage.java 0000644 0000000 0000000 00000000644 11072626250 022136 0 ustar package org.jcsp.net2.mobile; import java.io.Serializable; import org.jcsp.net2.NetChannelLocation; /** * @author Kevin */ final class MobileChannelMessage implements Serializable { static final int REQUEST = 1; static final int CHECK = 2; static final int CHECK_RESPONSE = 3; int type = -1; boolean ready = false; NetChannelLocation inputLocation = null; } jcsp-1.1-rc4.orig/src/org/jcsp/net2/mobile/ClassManager.java 0000644 0000000 0000000 00000007660 11072626250 020476 0 ustar package org.jcsp.net2.mobile; import java.io.IOException; import java.io.InputStream; import java.util.Hashtable; import org.jcsp.lang.CSProcess; import org.jcsp.net2.JCSPNetworkException; import org.jcsp.net2.NetChannel; import org.jcsp.net2.NetChannelInput; import org.jcsp.net2.NetChannelOutput; import org.jcsp.net2.Node; /** * @author Kevin */ final class ClassManager implements CSProcess { static Hashtable classLoaders = new Hashtable(); static NetChannelInput in = NetChannel.numberedNet2One(10); public void run() { while (true) { try { ClassRequest req = (ClassRequest)in.read(); if (req.originatingNode.equals(Node.getInstance().getNodeID())) { String className = req.className.replace('.', '/') + ".class"; InputStream is = ClassLoader.getSystemResourceAsStream(className); try { if (is != null) { int read = 0; byte[] bytes = new byte[is.available()]; while (read < bytes.length) read += is.read(bytes, read, bytes.length - read); ClassData resp = new ClassData(req.className, bytes); NetChannelOutput out = NetChannel.one2net(req.returnLocation); out.asyncWrite(resp); out.destroy(); out = null; } else { ClassData resp = new ClassData(req.className, null); NetChannelOutput out = NetChannel.one2net(req.returnLocation); out.asyncWrite(resp); out.destroy(); out = null; } } catch (IOException ioe) { ClassData resp = new ClassData(req.className, null); NetChannelOutput out = NetChannel.one2net(req.returnLocation); out.asyncWrite(resp); out.destroy(); } } else { DynamicClassLoader loader = (DynamicClassLoader)ClassManager.classLoaders.get(req.originatingNode); if (loader == null) { ClassData resp = new ClassData(req.className, null); NetChannelOutput out = NetChannel.one2net(req.returnLocation); out.asyncWrite(resp); out.destroy(); } else { try { byte[] bytes = loader.requestClass(req.className); ClassData resp = new ClassData(req.className, bytes); NetChannelOutput out = NetChannel.one2net(req.returnLocation); out.asyncWrite(resp); out.destroy(); } catch (ClassNotFoundException cnf) { ClassData resp = new ClassData(req.className, null); NetChannelOutput out = NetChannel.one2net(req.returnLocation); out.asyncWrite(resp); out.destroy(); } } } } catch (JCSPNetworkException jne) { // Do nothing } } } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/mobile/MobileChannelOutput.java 0000644 0000000 0000000 00000004074 11072626250 022053 0 ustar package org.jcsp.net2.mobile; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; import org.jcsp.net2.JCSPNetworkException; import org.jcsp.net2.NetChannel; import org.jcsp.net2.NetChannelLocation; import org.jcsp.net2.NetChannelOutput; import org.jcsp.net2.NetLocation; import org.jcsp.net2.NetworkPoisonException; import org.jcsp.net2.NetworkMessageFilter.FilterTx; /** * @author Kevin */ public final class MobileChannelOutput implements NetChannelOutput, Serializable { private NetChannelLocation msgBoxLocation; private transient NetChannelOutput actualOut; public MobileChannelOutput(NetChannelLocation loc) { this.msgBoxLocation = loc; this.actualOut = NetChannel.one2net(loc); } public MobileChannelOutput(NetChannelLocation loc, FilterTx encoder) { this.msgBoxLocation = loc; this.actualOut = NetChannel.one2net(loc, encoder); } public void write(Object object) { this.actualOut.write(object); } public void destroy() { this.actualOut.destroy(); } public NetLocation getLocation() { return this.actualOut.getLocation(); } public void poison(int strength) { this.actualOut.poison(strength); } public void asyncWrite(Object obj) throws JCSPNetworkException, NetworkPoisonException { this.actualOut.asyncWrite(obj); } public void setEncoder(FilterTx encoder) { this.actualOut.setEncoder(encoder); } private void writeObject(ObjectOutputStream output) throws IOException { output.writeObject(this.msgBoxLocation); this.actualOut.destroy(); } private void readObject(ObjectInputStream input) throws IOException, ClassNotFoundException { this.msgBoxLocation = (NetChannelLocation)input.readObject(); this.actualOut = NetChannel.one2net(this.msgBoxLocation); } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/mobile/DynamicClassLoaderMessage.java 0000644 0000000 0000000 00000001360 11072626250 023133 0 ustar package org.jcsp.net2.mobile; import java.io.Serializable; import org.jcsp.lang.ProcessManager; import org.jcsp.net2.NetChannelLocation; import org.jcsp.net2.NodeID; /** * @author Kevin */ final class DynamicClassLoaderMessage implements Serializable { static { ClassManager classManager = new ClassManager(); new ProcessManager(classManager).start(); } final NodeID originatingNode; final NetChannelLocation requestLocation; final byte[] bytes; DynamicClassLoaderMessage(NodeID originator, NetChannelLocation request, byte[] classData) { this.originatingNode = originator; this.requestLocation = request; this.bytes = classData; } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/ResettableByteArrayOutputStream.java 0000644 0000000 0000000 00000001612 11072626250 023170 0 ustar package org.jcsp.net2; import java.io.ByteArrayOutputStream; /** * This class is used by the ObjectNetworkMessageFilter. It acts as a normal ByteArrayOutputStream, but allows the * internal buffer to be reset in size, thereby regaining some resources. * * @author Kevin Chalmers */ final class ResettableByteArrayOutputStream extends ByteArrayOutputStream { /** * Creates a new ResettableByteArrayOutputStream * * @param size * The size of the internal buffer */ ResettableByteArrayOutputStream(int size) { super(size); } /** * Resets the internal buffer * * @param size * The size to reset the internal buffer to */ void reset(int size) { this.reset(); if (this.buf.length != size) this.buf = new byte[size]; } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/StandardNetChannelEndFactory.java 0000644 0000000 0000000 00000077251 11072626250 022351 0 ustar package org.jcsp.net2; /** * A concrete implementation of a NetChannelEndFactory, used to create networked channel ends * * @see NetChannelEndFactory * @see NetChannel * @author Kevin Chalmers (updated from Quickstone Technologies) */ public final class StandardNetChannelEndFactory implements NetChannelEndFactory { /** * Creates a new NetAltingChannelInput * * @deprecated Use net2one instead * @return A new NetAltingChannelInput */ public NetAltingChannelInput createNet2One() { return Net2OneChannel.create(Integer.MAX_VALUE, new ObjectNetworkMessageFilter.FilterRX()); } /** * Creates a new NetSharedChannelInput * * @deprecated Use net2any instead * @return A new NetSharedChannelInput */ public NetSharedChannelInput createNet2Any() { return Net2AnyChannel.create(Integer.MAX_VALUE, new ObjectNetworkMessageFilter.FilterRX()); } /** * Creates a new NetChannelOutput connected to the input channel end with the given location * * @deprecated Use one2net instead * @param loc * The location to connect the output end to * @return A new NetChannelOutput connected to the input end at the given location * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput createOne2Net(NetChannelLocation loc) throws JCSPNetworkException { return One2NetChannel.create(loc, Integer.MAX_VALUE, new ObjectNetworkMessageFilter.FilterTX()); } /** * Creates a new NetSharedChannelOutput connected to the input end at the given location * * @deprecated Use any2net instead * @param loc * The location to connect the output end to * @return A new NetSharedChannelOutput connected to the input end at the given location * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput createAny2Net(NetChannelLocation loc) throws JCSPNetworkException { return Any2NetChannel.create(loc, Integer.MAX_VALUE, new ObjectNetworkMessageFilter.FilterTX()); } /** * Creates a new NetAltingChannelInput * * @return A new NetAltingChannelInput */ public NetAltingChannelInput net2one() { return Net2OneChannel.create(Integer.MAX_VALUE, new ObjectNetworkMessageFilter.FilterRX()); } /** * Creates a new NetAltingChannelInput with the given immunity level for poison * * @param immunityLevel * The immunity level for poison * @return A new NetAltingChannelInput */ public NetAltingChannelInput net2one(int immunityLevel) { return Net2OneChannel.create(immunityLevel, new ObjectNetworkMessageFilter.FilterRX()); } /** * Creates a new NetAltingChannelInput which uses the given filter to decode incoming messages * * @param filter * The filter used to decode incoming messages * @return A new NetAltingChannelInput */ public NetAltingChannelInput net2one(NetworkMessageFilter.FilterRx filter) { return Net2OneChannel.create(Integer.MAX_VALUE, filter); } /** * Creates a new NetAltingChannelInput with the given poison immunity level which uses the given filter to decode * incoming messages * * @param immunityLevel * The immunity level to poison for the created channel * @param filter * The filter used to decode incoming messages * @return A new NetAltingChannelInput */ public NetAltingChannelInput net2one(int immunityLevel, NetworkMessageFilter.FilterRx filter) { return Net2OneChannel.create(immunityLevel, filter); } /** * Creates a new NetSharedChannelInput * * @return A new NetSharedChannelInput */ public NetSharedChannelInput net2any() { return Net2AnyChannel.create(Integer.MAX_VALUE, new ObjectNetworkMessageFilter.FilterRX()); } /** * Creates a new NetSharedChannelInput with the given poison immunity level * * @param immunityLevel * The immunity level to poison for this channel * @return A new NetSharedChannelInput */ public NetSharedChannelInput net2any(int immunityLevel) { return Net2AnyChannel.create(immunityLevel, new ObjectNetworkMessageFilter.FilterRX()); } /** * Creates a new NetSharedChannelInput which uses the given filter to decode incoming messages * * @param filter * The filter used to decode incoming messages * @return A new NetSharedChannelInput */ public NetSharedChannelInput net2any(NetworkMessageFilter.FilterRx filter) { return Net2AnyChannel.create(Integer.MAX_VALUE, filter); } /** * Creates a new NetSharedChannelInput with the given poison immunity level, which uses the given filter to decode * messages * * @param immunityLevel * The immunity level to poison for this channel * @param filter * The filter used to decode incoming messages * @return A new NetSharedChannelInput */ public NetSharedChannelInput net2any(int immunityLevel, NetworkMessageFilter.FilterRx filter) { return Net2AnyChannel.create(immunityLevel, filter); } /** * Creates a new NetAltingChannelInput with the given index * * @param index * The index to create the channel with * @return A new NetAltingChannelInput * @throws IllegalArgumentException * Thrown if a channel with the given index already exists */ public NetAltingChannelInput numberedNet2One(int index) throws IllegalArgumentException { return Net2OneChannel.create(index, Integer.MAX_VALUE, new ObjectNetworkMessageFilter.FilterRX()); } /** * Creates a new NetAltingChannelInput with the given index and the given poison immunity level * * @param index * The index to create the channel with * @param immunityLevel * The immunity to poison that the channel has * @return A new NetAltingChannelInput * @throws IllegalArgumentException * Thrown if a channel with the given index already exists */ public NetAltingChannelInput numberedNet2One(int index, int immunityLevel) throws IllegalArgumentException { return Net2OneChannel.create(index, immunityLevel, new ObjectNetworkMessageFilter.FilterRX()); } /** * Creates a new NetAltingChannelInput with the given index that uses the given filter to decode incoming messages * * @param index * The index to create the channel with * @param filter * The filter used to decode incoming messages * @return A new NetAltingChannelInput * @throws IllegalArgumentException * Thrown if a channel with the given index already exists */ public NetAltingChannelInput numberedNet2One(int index, NetworkMessageFilter.FilterRx filter) throws IllegalArgumentException { return Net2OneChannel.create(index, Integer.MAX_VALUE, filter); } /** * Creates a new NetAltingChannelInput with the given index and given poison immunity, which uses the given filter * to decode incoming messages * * @param index * The index to create the channel with * @param immunityLevel * The immunity to poison that the channel has * @param filter * The filter used to decode incoming messages * @return A new NetAltingChannelInput * @throws IllegalArgumentException * Thrown if a channel with the given index already exists */ public NetAltingChannelInput numberedNet2One(int index, int immunityLevel, NetworkMessageFilter.FilterRx filter) throws IllegalArgumentException { return Net2OneChannel.create(index, immunityLevel, filter); } /** * Creates a new NetSharedChannelInput with the given index * * @param index * The index to create the channel with * @return A new NetSharedChannelInput * @throws IllegalArgumentException * Thrown if a channel with the given index already exists */ public NetSharedChannelInput numberedNet2Any(int index) throws IllegalArgumentException { return Net2AnyChannel.create(index, Integer.MAX_VALUE, new ObjectNetworkMessageFilter.FilterRX()); } /** * Creates a new NetSharedChannelInput with the given index and poison immunity level * * @param index * The index to create the channel with * @param immunityLevel * The immunity to poison the channel has * @return A new NetSharedChannelInput * @throws IllegalArgumentException * Thrown if a channel with the given index already exists */ public NetSharedChannelInput numberedNet2Any(int index, int immunityLevel) throws IllegalArgumentException { return Net2AnyChannel.create(index, immunityLevel, new ObjectNetworkMessageFilter.FilterRX()); } /** * Creates a new NetSharedChannelInput with the given index that uses the given filter to decode incoming messages * * @param index * The index to create the channel with * @param filter * The filter used to decode incoming messages * @return A new NetSharedChannelInput * @throws IllegalArgumentException * Thrown if a channel with the given index already exists */ public NetSharedChannelInput numberedNet2Any(int index, NetworkMessageFilter.FilterRx filter) throws IllegalArgumentException { return Net2AnyChannel.create(index, Integer.MAX_VALUE, filter); } /** * Creates a new NetSharedChannelInput with the given index and poison immunity level, which uses the given filter * to decode incoming messages. * * @param index * The index to create the channel with * @param immunityLevel * The immunity level to poison that the channel has * @param filter * The filter used to decode incoming messages * @return A new NetSharedChannelInput * @throws IllegalArgumentException * Thrown if a channel with the given index already exists. */ public NetSharedChannelInput numberedNet2Any(int index, int immunityLevel, NetworkMessageFilter.FilterRx filter) throws IllegalArgumentException { return Net2AnyChannel.create(index, immunityLevel, filter); } /** * Creates a new NetChannelOutput connected to the input end with the given NetChannelLocation * * @param loc * The location of the input end of the channel * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NetChannelLocation loc) throws JCSPNetworkException { return One2NetChannel.create(loc, Integer.MAX_VALUE, new ObjectNetworkMessageFilter.FilterTX()); } /** * Creates a new NetChannelOutput connected to the input end with the given NetChannelLocation, and having the given * poison immunity level * * @param loc * The location of the input end of the channel * @param immunityLevel * The immunity to poison that this channel has * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NetChannelLocation loc, int immunityLevel) throws JCSPNetworkException { return One2NetChannel.create(loc, immunityLevel, new ObjectNetworkMessageFilter.FilterTX()); } /** * Creates a new NetChannelOutput connected to the input end with the given NetChannelLocation, and uses the given * filter to encode outgoing messages * * @param loc * The location of the input end of the channel * @param filter * The filter used to encode outgoing messages * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NetChannelLocation loc, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException { return One2NetChannel.create(loc, Integer.MAX_VALUE, filter); } /** * Creates a new NetChannelOutput connected to the given location with the given poison immunity level, and uses the * given filter to encode outgoing messages. * * @param loc * The location of the input end of the channel * @param immunityLevel * The immunity to poison that this channel has * @param filter * The filter used to encode outgoing messages * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NetChannelLocation loc, int immunityLevel, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException { return One2NetChannel.create(loc, immunityLevel, filter); } /** * Creates a new NetSharedChannelOutput connected to the input end at the given location * * @param loc * The location of the input end of the channel * @return A new NetSharedChannelInput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NetChannelLocation loc) throws JCSPNetworkException { return Any2NetChannel.create(loc, Integer.MAX_VALUE, new ObjectNetworkMessageFilter.FilterTX()); } /** * Creates a new NetSharedChannelOutput connected to the input end at the given location and with the given poison * immunity level * * @param loc * The location of the input end of the channel * @param immunityLevel * The immunity to poison that the channel has * @return A new NetSharedChannelInput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NetChannelLocation loc, int immunityLevel) throws JCSPNetworkException { return Any2NetChannel.create(loc, immunityLevel, new ObjectNetworkMessageFilter.FilterTX()); } /** * Creates a new NetSharedChannelOutput connected to the input end with the given location, and uses the given * filter to encode outgoing messages * * @param loc * The location of the input end of the channel * @param filter * The filter used to encode outgoing messages * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NetChannelLocation loc, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException { return Any2NetChannel.create(loc, Integer.MAX_VALUE, filter); } /** * Creates a new NetSharedChannelOutput connected to the input end with the given location and with the given * immunity level, which uses the given filter to encode outgoing messages. * * @param loc * The location of the input end of the channel * @param immunityLevel * The immunity to poison that this channel has * @param filter * The filter used to encode outgoing messages * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NetChannelLocation loc, int immunityLevel, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException { return Any2NetChannel.create(loc, immunityLevel, filter); } /** * Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node * * @param nodeID * The NodeID of the node that the input channel resides on * @param vcn * The Virtual Channel Number of the input channel * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NodeID nodeID, int vcn) throws JCSPNetworkException { NetChannelLocation loc = new NetChannelLocation(nodeID, vcn); return One2NetChannel.create(loc, Integer.MAX_VALUE, new ObjectNetworkMessageFilter.FilterTX()); } /** * Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node, and with the given * poison immunity level * * @param nodeID * The NodeID of the Node that the input channel resides on * @param vcn * The Virtual Channel Number of the input channel * @param immunityLevel * The immunity to poison of the channel * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NodeID nodeID, int vcn, int immunityLevel) throws JCSPNetworkException { NetChannelLocation loc = new NetChannelLocation(nodeID, vcn); return One2NetChannel.create(loc, immunityLevel, new ObjectNetworkMessageFilter.FilterTX()); } /** * Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node, which uses the * given filter to encode outgoing messages * * @param nodeID * The NodeID of the Node that the input channel resides on * @param vcn * The Virtual Channel Number of the input channel * @param filter * The filter to encode outgoing messages * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong with the underlying architecture */ public NetChannelOutput one2net(NodeID nodeID, int vcn, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException { NetChannelLocation loc = new NetChannelLocation(nodeID, vcn); return One2NetChannel.create(loc, Integer.MAX_VALUE, filter); } /** * Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node, with the given * poison immunity level and uses the given filter to encode outgoing messages * * @param nodeID * The NodeID of the Node that the input channel resides on * @param vcn * The Virtual Channel Number of the input channel * @param immunityLevel * The immunity to poison that the channel has * @param filter * The filter that encodes the outgoing messages * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong with the underlying architecture */ public NetChannelOutput one2net(NodeID nodeID, int vcn, int immunityLevel, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException { NetChannelLocation loc = new NetChannelLocation(nodeID, vcn); return One2NetChannel.create(loc, immunityLevel, filter); } /** * Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node * * @param nodeID * The NodeID of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NodeID nodeID, int vcn) throws JCSPNetworkException { NetChannelLocation loc = new NetChannelLocation(nodeID, vcn); return Any2NetChannel.create(loc, Integer.MAX_VALUE, new ObjectNetworkMessageFilter.FilterTX()); } /** * Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node and the given * poison immunity * * @param nodeID * The NodeID of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @param immunityLevel * The immunity to poison that the channel has * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NodeID nodeID, int vcn, int immunityLevel) throws JCSPNetworkException { NetChannelLocation loc = new NetChannelLocation(nodeID, vcn); return Any2NetChannel.create(loc, immunityLevel, new ObjectNetworkMessageFilter.FilterTX()); } /** * Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node, which uses * the given filter to encode outgoing messages * * @param nodeID * The NodeID of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @param filter * The filter used to encode the outgoing messages * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NodeID nodeID, int vcn, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException { NetChannelLocation loc = new NetChannelLocation(nodeID, vcn); return Any2NetChannel.create(loc, Integer.MAX_VALUE, filter); } /** * Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node, with the * given poison immunity level, which uses the given filter to encode outgoing messages * * @param nodeID * The NodeID of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @param immunityLevel * The immunity to poison that the channel has * @param filter * The filter used to encode outgoing messages * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NodeID nodeID, int vcn, int immunityLevel, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException { NetChannelLocation loc = new NetChannelLocation(nodeID, vcn); return Any2NetChannel.create(loc, immunityLevel, filter); } /** * Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node * * @param nodeAddr * The NodeAddress of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NodeAddress nodeAddr, int vcn) throws JCSPNetworkException { NodeID remoteNode = LinkFactory.getLink(nodeAddr).remoteID; NetChannelLocation loc = new NetChannelLocation(remoteNode, vcn); return One2NetChannel.create(loc, Integer.MAX_VALUE, new ObjectNetworkMessageFilter.FilterTX()); } /** * Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node with the given * poison immunity * * @param nodeAddr * The NodeAddress of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @param immunityLevel * The immunity to poison the channel has * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NodeAddress nodeAddr, int vcn, int immunityLevel) throws JCSPNetworkException { NodeID remoteNode = LinkFactory.getLink(nodeAddr).remoteID; NetChannelLocation loc = new NetChannelLocation(remoteNode, vcn); return One2NetChannel.create(loc, immunityLevel, new ObjectNetworkMessageFilter.FilterTX()); } /** * Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node which uses the given * filter to encode outgoing messages * * @param nodeAddr * The NodeAddress of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @param filter * The filter used to encode outgoing messages * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NodeAddress nodeAddr, int vcn, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException { NodeID remoteNode = LinkFactory.getLink(nodeAddr).remoteID; NetChannelLocation loc = new NetChannelLocation(remoteNode, vcn); return One2NetChannel.create(loc, Integer.MAX_VALUE, filter); } /** * Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node which has the given * poison immunity and uses the given filter to encode outgoing messages * * @param nodeAddr * The NodeAddress of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @param immunityLevel * The immunity to poison that the channel has * @param filter * The filter used to encode outgoing messages * @return A new NetChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelOutput one2net(NodeAddress nodeAddr, int vcn, int immunityLevel, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException { NodeID remoteNode = LinkFactory.getLink(nodeAddr).remoteID; NetChannelLocation loc = new NetChannelLocation(remoteNode, vcn); return One2NetChannel.create(loc, immunityLevel, filter); } /** * Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node * * @param nodeAddr * The NodeAddress of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn) throws JCSPNetworkException { NodeID remoteNode = LinkFactory.getLink(nodeAddr).remoteID; NetChannelLocation loc = new NetChannelLocation(remoteNode, vcn); return Any2NetChannel.create(loc, Integer.MAX_VALUE, new ObjectNetworkMessageFilter.FilterTX()); } /** * Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node which has the * given poison immunity * * @param nodeAddr * The NodeAddress of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @param immunityLevel * The immunity to poison that the channel has * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn, int immunityLevel) throws JCSPNetworkException { NodeID remoteNode = LinkFactory.getLink(nodeAddr).remoteID; NetChannelLocation loc = new NetChannelLocation(remoteNode, vcn); return Any2NetChannel.create(loc, immunityLevel, new ObjectNetworkMessageFilter.FilterTX()); } /** * Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node which uses the * given filter to encode outgoing messages * * @param nodeAddr * The NodeAddress of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @param filter * The immunity to poison that the channel has * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException { NodeID remoteNode = LinkFactory.getLink(nodeAddr).remoteID; NetChannelLocation loc = new NetChannelLocation(remoteNode, vcn); return Any2NetChannel.create(loc, Integer.MAX_VALUE, filter); } /** * Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node that has the * given poison immunity level and uses the given filter to encode outgoing messages * * @param nodeAddr * The NodeAddress of the Node to connect to * @param vcn * The Virtual Channel Number of the input channel * @param immunityLevel * The immunity to poison that the channel has * @param filter * The filter used to encode outgoing messages * @return A new NetSharedChannelOutput * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn, int immunityLevel, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException { NodeID remoteNode = LinkFactory.getLink(nodeAddr).remoteID; NetChannelLocation loc = new NetChannelLocation(remoteNode, vcn); return Any2NetChannel.create(loc, immunityLevel, filter); } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/NetChannelLocation.java 0000644 0000000 0000000 00000007117 11072626250 020374 0 ustar package org.jcsp.net2; import java.io.Serializable; /** * This class is a data structure representing the location of a NetChannelInput in a network. The NetChannelLocation * consists of the NodeID of the Node on which the NetChannelInput resides, and its Virtual Channel Number, which is the * number uniquely identifying the NetChannelInput on said Node. ** To acquire the NetChannelLocation of a NetBarrier, use the getLocation method: *
*
*
* NetChannelLocation location = (NetChannelLocation)chan.getLocation();
*
*
* The location returned depends on whether the channel is a NetChannelInput or a NetChannelOutput end. An input end * will return its own location. An output end will return the location of the input end it is connected to. This is * because we consider a networked channel to be a single, virtual construct, with only one location. That location is * where the input end is located. *
* * @see NetChannelInput * @see NetChannelOutput * @see NetLocation * @author Kevin Chalmers */ public final class NetChannelLocation extends NetLocation implements Serializable { /** * The SUID representing this class */ private static final long serialVersionUID = 1L; /** * The NodeID portion of the location */ private final NodeID nodeID; /** * The vcn portion of the location */ private final int vcn; /** * Creates a new NetChannelLocation * * @param aNodeID * The NodeID part of the location * @param aVCN * The vcn part of the location */ public NetChannelLocation(NodeID aNodeID, int aVCN) { this.nodeID = aNodeID; this.vcn = aVCN; } /** * Gets the NodeID part of the location * * @return The NodeID part of the NetChannelLocation */ public NodeID getNodeID() { return this.nodeID; } /** * Gets the NodeAddress part of the location * * @return The NodeAddress part of the NetChannelLocation */ public NodeAddress getNodeAddress() { return this.nodeID.getNodeAddress(); } /** * Gets the vcn part of the location * * @return The VCN part of the NetChannelLocation */ public int getVCN() { return this.vcn; } /** * Converts the NetChannelLocation object into a string representation of the form ncl://[NodeID]/[VCN] * * @return The String form of the NetChannelLocation */ public String toString() { return "ncl://" + this.nodeID.toString() + "/" + this.vcn; } /** * Converts the string form of a NetChannelLocation back into its object form * * @param str * The string representation of a NetChannelLocation * @return A new NetChannelLocation created from the String representation */ public static NetChannelLocation parse(String str) { if (str.equalsIgnoreCase("null")) return null; if (str.startsWith("ncl://")) { String toParse = str.substring(6); int index = toParse.indexOf("/"); NodeID nodeID = NodeID.parse(toParse.substring(0, index)); int vcn = Integer.parseInt(toParse.substring(index + 1)); return new NetChannelLocation(nodeID, vcn); } throw new IllegalArgumentException("String is not a string form of a NetChannelLocation"); } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/Any2NetChannel.java 0000644 0000000 0000000 00000010206 11072626250 017426 0 ustar package org.jcsp.net2; import org.jcsp.lang.PoisonException; import org.jcsp.net2.NetworkMessageFilter.FilterTx; /*********************************************************************************************************************** * An outputting network channel (TX) that can be safely shared amongst multiple writers (Any2Net). This is the concrete * implementation of the construct. For information on the user level interface, see NetSharedChannelOutput * * @see org.jcsp.net2.NetSharedChannelOutput * @author Kevin Chalmers (updated from Quickstone Technologies Limited) */ final class Any2NetChannel implements NetSharedChannelOutput { /** * The underlying One2NetChannel used by this channel. This class acts like a wrapper, protecting the underlying * unshared connection. */ private final One2NetChannel chan; /** * Static factory method used to create an Any2NetChannel * * @param loc * The location of the input channel end * @param immunity * The immunity level of the channel * @param filter * The filter used to convert the object being sent into bytes * @return A new Any2NetChannel connected to the input end. * @throws JCSPNetworkException * Thrown if a connection to the Node cannot be made. */ static Any2NetChannel create(NetChannelLocation loc, int immunity, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException { One2NetChannel channel = One2NetChannel.create(loc, immunity, filter); return new Any2NetChannel(channel); } /** * Constructor wrapping an existing One2NetChannel in an Any2NetChannel * * @param channel * The One2NetChannel to be wrapped. */ private Any2NetChannel(One2NetChannel channel) { this.chan = channel; } /** * Poisons the underlying channel * * @param strength * The strength of the poison being put on the channel */ public void poison(int strength) { synchronized (this) { this.chan.poison(strength); } } /** * Gets the NetChannelLocation of the input end this channel is connected to. * * @return The location of the input end that this output end is connected to. */ public NetLocation getLocation() { return this.chan.getLocation(); } /** * Writes an object to the underlying channel. * * @param object * The Object to write to the channel * @throws JCSPNetworkException * Thrown if something happens in the underlying architecture * @throws PoisonException * Thrown if the channel has been poisoned. */ public void write(Object object) throws JCSPNetworkException, PoisonException { synchronized (this) { this.chan.write(object); } } /** * Writes asynchronously to the underlying channel. * * @param object * The object to write to the channel * @throws JCSPNetworkException * Thrown if something happens in the underlying architecture * @throws PoisonException * Thrown is the channel has been poisoned */ public void asyncWrite(Object object) throws JCSPNetworkException, PoisonException { synchronized (this) { this.chan.asyncWrite(object); } } /** * Removes the channel from the ChannelManager, and sets the state to DESTROYED */ public void destroy() { synchronized (this) { this.chan.destroy(); } } /** * Sets the underlying message filter * * @param encoder * The new message filter to use */ public void setEncoder(FilterTx encoder) { synchronized (this) { this.chan.setEncoder(encoder); } } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/BarrierManager.java 0000644 0000000 0000000 00000007526 11072626250 017551 0 ustar package org.jcsp.net2; import java.util.Hashtable; /** * Manages the networked Barriers in the system. This object wraps a Hashtable containing the NetBarrier data objects, * and manages the allocation and removal of NetBarrier front ends within the JCSP networking architecture. For * information on the NetBarrier, see the appropriate documentation. * * @see org.jcsp.net2.NetBarrier * @author Kevin Chalmers */ final class BarrierManager { /** * The index for the next Barrier to be created. We start at 50 as it allows us to have up to 50 default Barriers * with set numbers. */ private static int index = 50; /** * The table containing the Barriers. An Integer (object wrapped int) is used as the key, and the BarrierData as the * value. */ private final Hashtable barriers = new Hashtable(); /** * Singleton instance of the BarrierManager */ private static BarrierManager instance = new BarrierManager(); /** * Private default constructor. Used for the singleton instance. */ private BarrierManager() { // Empty constructor } /** * Allows getting of the singleton instance. * * @return The singleton instance of the BarrierManager */ static BarrierManager getInstance() { return instance; } /** * Allocates a new number to the Barrier, and stores it in the table. * * @param bd * The BarrierData for the Barrier */ synchronized void create(BarrierData bd) { // First allocate the next available number for the Barrier index (VBN). Integer objIndex = new Integer(index); while (this.barriers.get(objIndex) != null) objIndex = new Integer(++index); // Now set the index of the BarrierData to the required index bd.vbn = index; // And add the BarrierData at the given index in the Hashtable this.barriers.put(objIndex, bd); // Increment the index for the next allocation index++; } /** * Stores a barrier with the given index in the table. * * @param idx * The index to use for the barrier * @param bd * The BarrierData representing the barrier * @throws IllegalArgumentException * If a barrier of the given index already exists. */ synchronized void create(int idx, BarrierData bd) throws IllegalArgumentException { Integer objIndex = new Integer(idx); // First, ensure that no barrier of the given index already exists. If it does, throw an exception if (this.barriers.get(objIndex) != null) throw new IllegalArgumentException("Barrier of given number already exists."); // Now allocate the index to the BarrierData object bd.vbn = idx; // And put the new barrier into the list of barriers, and increment the next index if necessary this.barriers.put(objIndex, bd); if (idx == BarrierManager.index) BarrierManager.index++; } /** * Retrieves a barrier from the table * * @param idx * Index in the table to retrieve the barrier from. * @return The BarrierData object for the barrier. */ BarrierData getBarrier(int idx) { Integer objIndex = new Integer(idx); return (BarrierData)this.barriers.get(objIndex); } /** * Removes the given barrier from the table of barriers. * * @param data * The BarrierData object of the barrier to be removed */ void removeBarrier(BarrierData data) { Integer objIndex = new Integer(data.vbn); this.barriers.remove(objIndex); } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/NodeFactory.java 0000644 0000000 0000000 00000001700 11072626250 017071 0 ustar package org.jcsp.net2; /** * Used to initialise a Node by connecting to the CNS. This approach is now deprecated. To initialise a Node now: *
*
* NodeAddress localAddress = ...;
*
* NodeAddress nodeServerAddr = ...;
* Node.getInstance().init(localAddress);
* CNS.init(nodeServerAddr);
* BNS.init(nodeServerAddr);
*
-
*/
private final HashMap barrierRegister = new HashMap();
/**
* Map of currently waiting resolves; name->reply-location
*/
private final HashMap waitingResolves = new HashMap();
/**
* Map of currently logged clients; NodeID->reply-channel
*/
private final HashMap loggedClients = new HashMap();
/**
* A channel used to receive incoming link lost notifications
*/
private final AltingChannelInput lostLink = Node.getInstance().getLinkLostEventChannel();
/**
* Private empty constructor
*/
private BNS()
{
// Empty constructor
}
/**
* Gets the singleton instance of the BNS
*
* @return The singleton instance of the BNS
*/
public static BNS getInstance()
{
return instance;
}
/**
* Initialises the connection to the BNS
*
* @param bnsNode
* The NodeID of the BNS Node
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static void initialise(NodeID bnsNode)
throws JCSPNetworkException
{
// First check that we are not already initialised
if (BNS.initialised)
throw new JCSPNetworkException("The BNS is already initialised");
// We are initialised. Attempt to do so.
// First, we need to create the BNSService
BNS.service = new BNSService(bnsNode);
// Now set initialised to true
BNS.initialised = true;
// We are now connected
}
/**
* Initialises the connection to the BNS
*
* @param bnsNode
* The NodeAddress of the BNS Node
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static void initialise(NodeAddress bnsNode)
throws JCSPNetworkException
{
// First check that we are not already initialised
if (BNS.initialised)
throw new JCSPNetworkException("The BNS is already initialised");
// We are initialised. Attempt to do so.
// First, we need to connect to the BNS Node
Link link = LinkFactory.getLink(bnsNode);
// Now create the BNSService
BNS.service = new BNSService(link.getRemoteNodeID());
// Now set initialised to true
BNS.initialised = true;
// We are now connected
}
/**
* The run method for the BNS process
*/
public void run()
{
// Create the channel to receive incoming messages on. The index is 2.
NetAltingChannelInput in = NetChannel.numberedNet2One(2, new BNSNetworkMessageFilter.FilterRX());
// We now wish to alternate upon this channel and the link lost channel
Alternative alt = new Alternative(new Guard[] { this.lostLink, in });
// Loop forever
while (true)
{
// Select next available Guard. Give priority to link failure
switch (alt.priSelect())
{
// We have lost the connection to a Node
case 0:
// Read in the NodeID of the lost Node
NodeID lostNode = (NodeID)this.lostLink.read();
// Log loss of connection
Node.log.log(this.getClass(), "Lost Link to: " + lostNode.toString());
// Remove the logged client
this.loggedClients.remove(lostNode);
// Next get the ArrayList of any barriers registered by that Node
ArrayList registeredBars = (ArrayList)this.barrierRegister.get(lostNode);
// If this ArrayList is null, we have no registrations
if (registeredBars != null)
{
// There are registered barriers
// Remove the list from the Hashmap
this.barrierRegister.remove(lostNode);
// Now remove all the barriers registered by the Node
for (Iterator iter = registeredBars.iterator(); iter.hasNext();)
{
String toRemove = (String)iter.next();
this.registeredBarriers.remove(toRemove);
Node.log.log(this.getClass(), toRemove + " deregistered");
}
}
break;
// We have received a new incoming message
case 1:
{
// Read in the message
BNSMessage message = (BNSMessage)in.read();
// Now behave based on the type of the message
switch (message.type)
{
// We have received a logon message
case BNSMessageProtocol.LOGON_MESSAGE:
{
// Log the logon attempt
Node.log.log(this.getClass(), "Logon received from: "
+ message.serviceLocation.getNodeID().toString());
// try-catch loop. We don't want the BNS to fail
try
{
// Check if the node is already logged on
NetChannelOutput out = (NetChannelOutput)this.loggedClients.get(message.serviceLocation
.getNodeID());
// If out is null, no previous logon received
if (out != null)
{
// This Node is already logged on. Send fail message
// Log failed attempt
Node.err.log(this.getClass(), message.serviceLocation.getNodeID().toString()
+ " already logged on. Rejecting");
// Create reply channel to the Node
NetChannelOutput toNewRegister = NetChannel.one2net(message.serviceLocation,
new BNSNetworkMessageFilter.FilterTX());
// Create the reply message
BNSMessage reply = new BNSMessage();
reply.type = BNSMessageProtocol.LOGON_REPLY_MESSAGE;
reply.success = false;
// Asynchronously write to Node. We don't want the BNS to block
toNewRegister.asyncWrite(reply);
// Destroy the temporary channel
toNewRegister.destroy();
}
else
{
// Node hasn't previously registered
// Log registration
Node.log.log(this.getClass(), message.serviceLocation.getNodeID().toString()
+ " successfully logged on");
// Create the reply channel
NetChannelOutput toNewRegister = NetChannel.one2net(message.serviceLocation,
new BNSNetworkMessageFilter.FilterTX());
// Add the Node and reply channel to the logged clients map
this.loggedClients.put(message.serviceLocation.getNodeID(), toNewRegister);
// Create a reply message
BNSMessage reply = new BNSMessage();
reply.type = BNSMessageProtocol.LOGON_REPLY_MESSAGE;
reply.success = true;
// Write reply asynchronously to the logging on Node
toNewRegister.asyncWrite(reply);
}
}
catch (JCSPNetworkException jne)
{
// Catch any JCSPNetworkException. We don't let the BNS go down
}
break;
}
// A Node is attempting to register a Barrier
case BNSMessageProtocol.REGISTER_REQUEST:
{
// Log registration attempt
Node.log.log(this.getClass(), "Registeration for " + message.name + " received");
// Catch any JCSPNetworkException
try
{
// Get the reply channel from our logged clients map
NetChannelOutput out = (NetChannelOutput)this.loggedClients.get(message.serviceLocation
.getNodeID());
// Check if the Node has logged on with us
if (out == null)
{
// The Node is not logged on. Send failure message
Node.err.log(this.getClass(), "Registration failed. "
+ message.serviceLocation.getNodeID()
+ " not logged on");
// Create the channel to reply to
out = NetChannel.one2net(message.serviceLocation,
new BNSNetworkMessageFilter.FilterTX());
// Create the reply message
BNSMessage reply = new BNSMessage();
reply.type = BNSMessageProtocol.REGISTER_REPLY;
reply.success = false;
// Write message asynchronously to the Node
out.asyncWrite(reply);
// Destroy the temporary channel
out.destroy();
}
// The Node is registered. Now check if the name is
else if (this.registeredBarriers.containsKey(message.name))
{
// The name is already registered. Inform the register
// Log the failed registration
Node.err.log(this.getClass(), "Registration failed. " + message.name
+ " already registered");
// Create reply message
BNSMessage reply = new BNSMessage();
reply.type = BNSMessageProtocol.RESOLVE_REPLY;
reply.success = false;
// Write the reply asynchronously. Do not block the BNS
out.asyncWrite(reply);
}
else
{
// The name is not registered
// Log successful registration
Node.log.log(this.getClass(), "Registration of " + message.name + " succeeded.");
// First check if any client end is waiting for this name
ArrayList pending = (ArrayList)this.waitingResolves.get(message.name);
if (pending != null)
{
// We have waiting resolves. Complete
for (Iterator iter = pending.iterator(); iter.hasNext();)
{
NetChannelOutput toPending = null;
// We now catch internally any JCSPNetworkException
try
{
// Get the next waiting message
BNSMessage msg = (BNSMessage)iter.next();
// Log resolve completion
Node.log.log(this.getClass(), "Queued resolve of " + message.name
+ " by "
+ msg.serviceLocation.getNodeID()
+ " completed");
// Create channel to the resolver
toPending = NetChannel.one2net(msg.serviceLocation,
new BNSNetworkMessageFilter.FilterTX());
// Create the reply message
BNSMessage reply = new BNSMessage();
reply.type = BNSMessageProtocol.RESOLVE_REPLY;
reply.location = message.location;
reply.success = true;
// Write the reply asynchronously to the waiting resolver
toPending.asyncWrite(reply);
}
catch (JCSPNetworkException jne)
{
// Something went wrong as we tried to send the resolution complete
// message
// Do nothing
}
finally
{
// Check if we need to destroy the temporary channel
if (toPending != null)
toPending.destroy();
}
}
// Remove the name from the pending resolves
this.waitingResolves.remove(message.name);
}
// We have completed any pending resolves. Now register the barrier
this.registeredBarriers.put(message.name, message.location);
// Now add the registered barrier to the barriers registered by this Node
ArrayList registered = (ArrayList)this.barrierRegister.get(message.serviceLocation
.getNodeID());
// If the ArrayList is null, we have no previous registrations
if (registered == null)
{
// Create a new ArrayList to store the registered names
registered = new ArrayList();
// Add it to the barrier register
this.barrierRegister.put(message.location.getNodeID(), registered);
}
// Add the name to the ArrayList
registered.add(message.name);
// Log the successful registration
Node.log.log(this.getClass(), message.name + " registered to " + message.location);
// Create the reply message
BNSMessage reply = new BNSMessage();
reply.type = BNSMessageProtocol.REGISTER_REPLY;
reply.success = true;
// Write the reply asynchronously to the Node
out.asyncWrite(reply);
}
}
catch (JCSPNetworkException jne)
{
// Do nothing. Do not let the BNS break
}
break;
}
// We have received a resolve request
case BNSMessageProtocol.RESOLVE_REQUEST:
{
// Log resolve request
Node.log.log(this.getClass(), "Resolve request for " + message.name + " received");
// Catch any JCSPNetworkException
try
{
// Check if the resolving Node is logged on
NetChannelOutput out = (NetChannelOutput)this.loggedClients.get(message.serviceLocation
.getNodeID());
// If the channel is null, then the Node has yet to log on with us
if (out == null)
{
// Node is not logged on
// Log failed resolution
Node.err.log(this.getClass(), "Resolve failed. "
+ message.serviceLocation.getNodeID()
+ " not logged on");
// Create connection to the receiver
out = NetChannel.one2net(message.serviceLocation,
new BNSNetworkMessageFilter.FilterTX());
// Create the reply message
BNSMessage reply = new BNSMessage();
reply.type = BNSMessageProtocol.RESOLVE_REPLY;
reply.success = false;
// Write message asynchronously to the Node
out.asyncWrite(reply);
// Destroy the temporary channel
out.destroy();
}
else
{
// Node is logged on. Now check if the name is already registered
NetBarrierLocation loc = (NetBarrierLocation)this.registeredBarriers
.get(message.name);
// If the location is null, then the name has not yet been registered
if (loc == null)
{
// The name is not registered. We need to queue the resolve until it is
// Log the queueing of the resolve
Node.log.log(this.getClass(), message.name
+ " not registered. Queueing resolve by "
+ message.serviceLocation.getNodeID().toString());
// Check if any other resolvers are waiting for the channel
ArrayList pending = (ArrayList)this.waitingResolves.get(message.name);
// If the ArrayList is null, no one else is waiting
if (pending == null)
{
// No one else is waiting. Create a new list and add it to the waiting
// resolves
pending = new ArrayList();
this.waitingResolves.put(message.name, pending);
}
// Add this resolve message to the list of waiting resolvers
pending.add(message);
}
else
{
// The location is not null. Send it to the resolver
Node.log.log(this.getClass(), "Resolve request completed. " + message.name
+ " location being sent to "
+ message.serviceLocation.getNodeID());
// Create channel to the resolver
NetChannelOutput toPending = NetChannel.one2net(message.serviceLocation,
new BNSNetworkMessageFilter.FilterTX());
// Create the reply message
BNSMessage reply = new BNSMessage();
reply.type = BNSMessageProtocol.RESOLVE_REPLY;
reply.location = loc;
reply.success = true;
// Write the reply to the resolver asynchronously
toPending.asyncWrite(reply);
// Destroy the temporary channel
toPending.destroy();
}
}
}
catch (JCSPNetworkException jne)
{
// Something went wrong during the resolution. Ignore
}
break;
}
}
break;
}
}
}
}
/**
* Creates a new server end of a NetBarrier with the given name
*
* @param name
* The name to register with the BNS
* @param localEnrolled
* The number of locally enrolled processes
* @param netEnrolled
* The number of net enrolled processes to expect
* @return A new NetBarrier server end with the number of enrolled processes
* @throws IllegalArgumentException
* Thrown if the parameters are outside the defined ranges
* @throws IllegalStateException
* Thrown if the BNS connection has not been initialised
*/
public static NetBarrier netBarrier(String name, int localEnrolled, int netEnrolled)
throws IllegalArgumentException, IllegalStateException
{
// Check if the BNS connection is initialised
if (!BNS.initialised)
throw new IllegalStateException("The connection to the BNS has not been initialised");
// Create a new NetBarrier
NetBarrier toReturn = NetBarrierEnd.netBarrier(localEnrolled, netEnrolled);
// Attempt to register
if (BNS.service.register(name, toReturn))
{
return toReturn;
}
// Registration failed. Destroy and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the BNS");
}
/**
* Creates a new server end of a NetBarrier with a given index and name
*
* @param name
* Name to register with the BNS
* @param index
* The index to create the NetBarrier with
* @param localEnrolled
* The number of locally enrolled processes
* @param netEnrolled
* The number of remote enrollments to wait for
* @return A new NetBarrier
* @throws IllegalArgumentException
* Thrown if the parameters are outside the defined ranges
* @throws IllegalStateException
* Thrown if the connection to the BNS has not been initialised
*/
public static NetBarrier numberedNetBarrier(String name, int index, int localEnrolled, int netEnrolled)
throws IllegalArgumentException, IllegalStateException
{
// Check if the BNS connection is initialised
if (!BNS.initialised)
throw new IllegalStateException("The connection to the BNS has not been initialised");
// Create a new NetBarrier
NetBarrier toReturn = NetBarrierEnd.numberedNetBarrier(index, localEnrolled, netEnrolled);
// Attempt to register
if (BNS.service.register(name, toReturn))
{
return toReturn;
}
// Registration failed. Destroy and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the BNS");
}
/**
* Creates a new client end of a NetBarrier
*
* @param name
* The name to resolve with the BNS
* @param enrolled
* The number of locally enrolled processes
* @return A new NetBarrier client end with the number of enrolled processes
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
* @throws IllegalArgumentException
* Thrown if the number of of local enrolled is outside the defined range
* @throws IllegalStateException
* Thrown if the connection to the BNS has not been initialised
*/
public static NetBarrier netBarrier(String name, int enrolled)
throws IllegalArgumentException, IllegalStateException, JCSPNetworkException
{
// Check if the BNS connection is initialised
if (!BNS.initialised)
throw new IllegalStateException("The connection to the BNS has not been initialised");
// Resolve the location of the barrier
NetBarrierLocation loc = BNS.service.resolve(name);
// Return a new NetBarrier
return NetBarrierEnd.netBarrier(loc, enrolled);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/net2/bns/BNSService.java 0000644 0000000 0000000 00000010634 11072626250 017407 0 ustar package org.jcsp.net2.bns;
import org.jcsp.net2.JCSPNetworkException;
import org.jcsp.net2.NetBarrier;
import org.jcsp.net2.NetBarrierLocation;
import org.jcsp.net2.NetChannel;
import org.jcsp.net2.NetChannelInput;
import org.jcsp.net2.NetChannelLocation;
import org.jcsp.net2.NetChannelOutput;
import org.jcsp.net2.Node;
import org.jcsp.net2.NodeID;
/**
* This is the service object used to register and resolve barrier names with a Barrier Name Server. This provides a
* client front end.
*
* @author Kevin Chalmers (updated from Quickstone Technologies)
*/
public final class BNSService
{
/**
* The channel to send messages to the BNS upon
*/
private final NetChannelOutput toBNS;
/**
* The incoming channel to receive messages from the BNS
*/
private final NetChannelInput fromBNS;
/**
* Creates a new BNSService
*
* @param bnsNode
* The Node that the BNS is on
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public BNSService(NodeID bnsNode)
throws JCSPNetworkException
{
// Create input and output end
this.toBNS = NetChannel.one2net(bnsNode, 2, new BNSNetworkMessageFilter.FilterTX());
this.fromBNS = NetChannel.net2one(new BNSNetworkMessageFilter.FilterRX());
// Logon to the BNS
BNSMessage message = new BNSMessage();
message.type = BNSMessageProtocol.LOGON_MESSAGE;
message.serviceLocation = (NetChannelLocation)this.fromBNS.getLocation();
this.toBNS.write(message);
// Wait for logon reply message
BNSMessage logonReply = (BNSMessage)this.fromBNS.read();
// Check if we logged on OK
if (logonReply.success == false)
{
Node.err.log(this.getClass(), "Failed to logon to BNS");
throw new JCSPNetworkException("Failed to logon to BNS");
}
Node.log.log(this.getClass(), "Logged into BNS");
}
/**
* Registers a Server end of a NetBarrier with the BNS
*
* @param name
* Name to register with BNS
* @param bar
* Barrier to register
* @return True if the name was registered successfully, false otherwise
*/
public boolean register(String name, NetBarrier bar)
{
// Ensure only one registration can happen at a time
synchronized (this)
{
// Create a new registration message
BNSMessage message = new BNSMessage();
message.type = BNSMessageProtocol.REGISTER_REQUEST;
message.name = name;
message.serviceLocation = (NetChannelLocation)this.fromBNS.getLocation();
message.location = (NetBarrierLocation)bar.getLocation();
// Write registration message to the BNS
this.toBNS.write(message);
// Read in reply
BNSMessage reply = (BNSMessage)this.fromBNS.read();
return reply.success;
}
}
/**
* Resolves a name on the BNS, retrieving the NetBarrierLocation for the NetBarrier
*
* @param name
* The name to resolve from the BNS
* @return The NetBarrierLocation of the NetBarrier declared with name
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public NetBarrierLocation resolve(String name)
throws JCSPNetworkException
{
// Create a temporary channel to receive the incoming NetBarrierLocation
NetChannelInput responseChan = NetChannel.net2one(new BNSNetworkMessageFilter.FilterRX());
// Create the resolution message
BNSMessage message = new BNSMessage();
message.type = BNSMessageProtocol.RESOLVE_REQUEST;
message.serviceLocation = (NetChannelLocation)responseChan.getLocation();
message.name = name;
// Write resolution message to the BNS
this.toBNS.write(message);
// Read in reply
BNSMessage reply = (BNSMessage)responseChan.read();
// Destroy temporary channel
responseChan.destroy();
// Return result
if (reply.success)
return reply.location;
throw new JCSPNetworkException("Failed to resolve barrier named: " + name);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/net2/bns/BNSMessageProtocol.java 0000644 0000000 0000000 00000002614 11072626250 021114 0 ustar package org.jcsp.net2.bns;
/**
* This class defines the message types that can be sent to and from the CNS. This is internal to JCSP
*
* @author Kevin Chalmers
*/
final class BNSMessageProtocol
{
/**
* Empty, private constructor. We do not create instances of this class
*/
private BNSMessageProtocol()
{
// Empty constructor
}
/**
* A message sent from a BNSService to a BNS to log on
*/
static final byte LOGON_MESSAGE = 1;
/**
* Reply from server after a log on
*/
static final byte LOGON_REPLY_MESSAGE = 2;
/**
* Register a name with the BNS
*/
static final byte REGISTER_REQUEST = 3;
/**
* Resolve a name from the NS
*/
static final byte RESOLVE_REQUEST = 4;
/**
* *** Not currently used ***
*/
static final byte LEASE_REQUEST = 5;
/**
* *** Not currently used ***
*/
static final byte DEREGISTER_REQUEST = 6;
/**
* Reply from a registration request
*/
static final byte REGISTER_REPLY = 7;
/**
* Reply from a resolve request
*/
static final byte RESOLVE_REPLY = 8;
/**
* *** Not currently used ***
*/
static final byte LEASE_REPLY = 9;
/**
* *** Not currently used ***
*/
static final byte DEREGISTER_REPLY = 10;
}
jcsp-1.1-rc4.orig/src/org/jcsp/net2/NetSharedChannelOutput.java 0000644 0000000 0000000 00000001073 11072626250 021246 0 ustar package org.jcsp.net2;
import org.jcsp.lang.SharedChannelOutput;
/**
* Defines a networked ChannelOutput that is safe to be used by multiple concurrent processes. For more information see
* NetChannelOutput and SharedChannelOutput. To create an instance, see the relevant factory method.
*
* @see NetChannelOutput
* @see SharedChannelOutput
* @see NetChannel
* @author Kevin Chalmers (updated from Quickstone Technologies)
*/
public interface NetSharedChannelOutput
extends NetChannelOutput, SharedChannelOutput
{
// Nothing to add
}
jcsp-1.1-rc4.orig/src/org/jcsp/net2/NetBarrierLocation.java 0000644 0000000 0000000 00000010504 11072626250 020404 0 ustar package org.jcsp.net2;
import java.io.Serializable;
/**
* This class is a data structure representing the location of a NetBarrier in a network. The NetBarrierLocation
* consists of the NodeID of the Node on which the NetBarrier resides, and its Virtual Barrier Number, which is the
* number uniquely identifying the NetBarrier on said node.
*
* To acquire the NetBarrierLocation of a NetBarrier, use the getLocation method: *
*
*
* NetBarrierLocation location = (NetBarrierLocation)bar.getLocation();
*
*
* The location returned depends on whether the NetBarrier is a client or a server end. A server end of a NetBarrier * will return its own location. A client end of a NetBarrier will return the location of the server end it is connected * to. This is because we consider the NetBarrier to be a single, virtual construct, with only one location. That * location is where the server end of the NetBarrier is located. *
* * @see NetBarrier * @see NetLocation * @author Kevin Chalmers */ public final class NetBarrierLocation extends NetLocation implements Serializable { /** * The SUID of this object. Required for Serialization. */ private static final long serialVersionUID = 1L; /** * The NodeID portion of the location structure */ private final NodeID nodeID; /** * The index portion of the location structure */ private final int vbn; /** * Constructor to create a new NetBarrierLocation * * @param aNodeID * The NodeID portion of the NetBarrierLocation * @param aVBN * The index part of the NetBarrierLocation */ public NetBarrierLocation(NodeID aNodeID, int aVBN) { this.nodeID = aNodeID; this.vbn = aVBN; } /** * Gets the NodeID part of the location * * @return The NodeID part of the NetBarrierLocation */ public NodeID getNodeID() { return this.nodeID; } /** * Gets the NodeAddress part of the location * * @return The NodeAddress part of the NetBarrierLocation */ public NodeAddress getNodeAddress() { return this.nodeID.getNodeAddress(); } /** * Gets the index part of the location * * @return The VBN part of the NetBarrierLocation */ public int getVBN() { return this.vbn; } /** * Returns the string representation of the NetBarrierLocation. This takes the form of nbl://[NodeID]/[VBN]. * This string representation has been created to allow other frameworks to interpret the NetBarrierLocation. * * @return String representation of the NetBarrierLocation */ public String toString() { return "nbl://" + this.nodeID.toString() + "/" + this.vbn; } /** * Takes the string representation of a NetBarrierLocation and converts it back into an object for usage by JCSP. * * @param str * The string representation of the NetBarrierLocation * @return A NetBarrierLocation produced from a String representation * @throws IllegalArgumentException * Thrown if a non NetBarrierLocation is attempted to be parsed */ public static NetBarrierLocation parse(String str) throws IllegalArgumentException { if (str.equalsIgnoreCase("null")) return null; // Check that the string starts with nbl:// if (str.startsWith("nbl://")) { // Take the off the starting part of the string String toParse = str.substring(6); // Split the string in two int index = toParse.indexOf("/"); // Parse the NodeID portion NodeID nodeID = NodeID.parse(toParse.substring(0, index)); // Parse the VBN portion int vcn = Integer.parseInt(toParse.substring(index + 1)); // Return a new NetBarrierLocation created from the two parts return new NetBarrierLocation(nodeID, vcn); } // We don't have a NetBarrierLocation throw new IllegalArgumentException("String is not a string form of a NetBarrierLocation"); } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/NetConnectionClient.java 0000644 0000000 0000000 00000000233 11072626250 020561 0 ustar package org.jcsp.net2; import org.jcsp.lang.ConnectionClient; public interface NetConnectionClient extends Networked, ConnectionClient { } jcsp-1.1-rc4.orig/src/org/jcsp/net2/One2NetChannel.java 0000644 0000000 0000000 00000062253 11072626250 017431 0 ustar package org.jcsp.net2; import java.io.IOException; import org.jcsp.lang.AltingChannelInput; import org.jcsp.lang.Channel; import org.jcsp.lang.ChannelOutput; import org.jcsp.lang.One2OneChannel; import org.jcsp.lang.PoisonException; import org.jcsp.net2.NetworkMessageFilter.FilterTx; import org.jcsp.util.InfiniteBuffer; /** * An outputting end of a networked channel (TX). This is a concrete implementation created internally by JCSP. For * information on how to use networked channels, and how to create them, see the relevant documentation. * * @see NetChannelOutput * @see NetChannel * @author Kevin Chalmers (Updated from Quickstone Technologies) */ final class One2NetChannel implements NetChannelOutput { /** * The channel connecting to the Link that connects to the networked input end of this channel. */ private final ChannelOutput toLinkTx; /** * The actual Link this output channel sends on. We keep this as it allows us to register and unregister with the * Link as we are created and destroyed, allowing the Link to inform the channel when a Link goes down. */ private final Link linkConnectedTo; /** * This is used if we are ever connected locally. We use this to check the state of a locally connected channel * prior to sending a message. */ private final ChannelData localChannel; /** * The channel used to receive acknowledgements from the input end via the Link. */ private final AltingChannelInput theAckChannel; /** * A structure containing the information on the state of the channel. */ private final ChannelData data; /** * The location that this channel is connected to (the input channel ends location) */ private final NetChannelLocation remoteLocation; /** * The local channel end location */ private final NetChannelLocation localLocation; /** * Flag to determine if this is a locally connected channel or not */ private final boolean isLocal; /** * The filter used to encode outgoing messages */ private NetworkMessageFilter.FilterTx messageFilter; /** * Creates a new One2NetChannel by connecting to an already created NetChannelInput * * @param loc * The location of the NetChannelInput * @param immunity * The immunity level of the channel * @param filter * The filter used to encode outgoing messages * @return A new One2NetChannel * @throws JCSPNetworkException * Thrown if the connection to the remote Node fails */ static One2NetChannel create(NetChannelLocation loc, int immunity, NetworkMessageFilter.FilterTx filter) throws JCSPNetworkException { // Create the channel data structure ChannelData data = new ChannelData(); // Create the channel linking this to the Link level. This channel is the one used to receive acknowledgement // messages One2OneChannel chan = Channel.one2one(new InfiniteBuffer()); data.toChannel = chan.out(); // Set state of channel data.state = ChannelDataState.OK_OUTPUT; // Register channel ChannelManager.getInstance().create(data); // We now need to create the connection to the input end of the channel ChannelOutput toLink; // Check if this is a local link, and if so connect directly to the input channel if (loc.getNodeID().equals(Node.getInstance().getNodeID())) { toLink = ChannelManager.getInstance().getChannel(loc.getVCN()).toChannel; return new One2NetChannel(chan.in(), toLink, null, data, loc, immunity, filter); } // Connect to remote node if necessary Link link = LinkManager.getInstance().requestLink(loc.getNodeID()); // Check if an existing connection exists if (link == null) { // We are not connected. Connect to remote Node. link = LinkFactory.getLink(loc.getNodeID()); } // Get the connection to the Link. toLink = link.getTxChannel(); // Return new channel return new One2NetChannel(chan.in(), toLink, link, data, loc, immunity, filter); } /** * Private constructor for creating a One2NetChannel. This is called by the create method. * * @param ackChannel * The channel used to receive acknowledgements from Links * @param toLink * The channel used to send messages to the input end * @param link * The Link that this channel is connected to * @param chanData * The structure used to store the state of the channel * @param loc * The location of the input end that this channel is connected to * @param immunity * The poison immunity level of the channel * @param filter * Filter used to encode outgoing messages */ private One2NetChannel(AltingChannelInput ackChannel, ChannelOutput toLink, Link link, ChannelData chanData, NetChannelLocation loc, int immunity, NetworkMessageFilter.FilterTx filter) { // Set all the object properties for the channel this.toLinkTx = toLink; this.theAckChannel = ackChannel; this.data = chanData; this.remoteLocation = loc; this.localLocation = new NetChannelLocation(Node.getInstance().getNodeID(), chanData.vcn); this.data.immunityLevel = immunity; this.messageFilter = filter; // We now must either register with the Link connecting us to the input end, or we connect directly to the // channel if it is local if (link != null) { // We are connected to a remote Node. Register with Link this.linkConnectedTo = link; this.linkConnectedTo.registerChannel(this.data); // Set the localised parameters accordingly this.isLocal = false; this.localChannel = null; } else { // We are connected to an input end on this Node. Set the localised parameters this.isLocal = true; // Get hold of the local channel data structure this.localChannel = ChannelManager.getInstance().getChannel(this.remoteLocation.getVCN()); // Set the Link connected to to null this.linkConnectedTo = null; } } /** * Poisons the underlying channel. * * @param strength * The strength of the poison being placed on the channel */ public void poison(int strength) { // First check the state of the channel if (this.data.state == ChannelDataState.DESTROYED || this.data.state == ChannelDataState.BROKEN) // In this case we do nothing. Destroyed and broken are considered stronger than poisoned return; // Now check if the strength of the poison is greater than a previous poison if (strength > this.data.poisonLevel) { // Change the current poison level this.data.poisonLevel = strength; // Now check if the poison level is strong enough to poison us. if (strength > this.data.immunityLevel) { // The poison is strong enough. We need to change our state to poisoned. // We need to lock on the state to ensure no link is using it as we change it synchronized (this.data) { // Now change our state this.data.state = ChannelDataState.POISONED; } // Now we need to send the poison. Create the poison message NetworkMessage msg = new NetworkMessage(); msg.type = NetworkProtocol.POISON; msg.attr1 = this.remoteLocation.getVCN(); msg.attr2 = strength; // Now we must send the poison. Check if we are locally connected if (this.isLocal) { // Now check the state of the local input end. Acquire lock synchronized (this.localChannel) { // We only need to forward the message if the opposite channel is in OK_INPUT if (this.localChannel.state == ChannelDataState.OK_INPUT) // Write the message this.toLinkTx.write(msg); } } // We are not locally connected. Just forward the poison this.toLinkTx.write(msg); } // Poison is not above our immunity level. Do nothing. } } /** * Gets the NetChannelLocation that this channel is connected to (i.e. the input end location) * * @return The NetChannelLocation that this channel is connected to */ public NetLocation getLocation() { return this.remoteLocation; } /** * Gets the local NetChannelLocation that represents this channel. * * @return The local location of the output end */ NetChannelLocation localLocation() { return this.localLocation; } /** * Writes an object to the input end * * @param object * The object to send to the input end. * @throws JCSPNetworkException * Thrown if something goes wrong in the network architecture * @throws PoisonException * Thrown if the channel has been poisoned */ public void write(Object object) throws JCSPNetworkException, PoisonException { // First we do a state check, and throw an exception if necessary if (this.data.state == ChannelDataState.DESTROYED) throw new JCSPNetworkException("Channel has been destroyed"); if (this.data.state == ChannelDataState.BROKEN) throw new JCSPNetworkException("Channel has broken"); if (this.data.state == ChannelDataState.POISONED) throw new NetworkPoisonException(this.data.poisonLevel); // The channel is in a suitable state to do a write. Continue write operation // First check that no pending messages have been left for us. This can happen if we did an async write and // then were rejected, poisoned, or if the link went down. if (this.theAckChannel.pending()) { NetworkMessage msg = (NetworkMessage)this.theAckChannel.read(); // Lock onto our state object as we may be changing our state synchronized (this.data) { // A previous ASYNC_SEND was rejected. Break channel. if (msg.type == NetworkProtocol.REJECT_CHANNEL) { this.data.state = ChannelDataState.BROKEN; // Remove ourselves from the ChannelManager ChannelManager.getInstance().removeChannel(this.data); throw new JCSPNetworkException("Channel rejected during previous send"); } // The link to the input end has gone down. Break the channel else if (msg.type == NetworkProtocol.LINK_LOST) { this.data.state = ChannelDataState.BROKEN; // Remove ourselves from the ChannelManager ChannelManager.getInstance().removeChannel(this.data); throw new JCSPNetworkException("Link to Node lost. Send cannot complete"); } // A previous ASYNC_SEND resulted in us being poisoned. Poison the channel. There is nothing else that // can be done, as the input end has effectively gone. else if (msg.type == NetworkProtocol.POISON) { this.data.state = ChannelDataState.POISONED; this.data.poisonLevel = msg.attr2; throw new NetworkPoisonException(msg.attr2); } // This shouldn't really happen, but possibly someone ACK'd us when they were not meant to. Throw // exception. else { Node.err.log(this.getClass(), "Channel " + this.data.vcn + " reports unexpected message."); throw new JCSPNetworkException("NetChannelOutput received an unexpected exception"); } } } // Create a new SEND message. NetworkMessage msg = new NetworkMessage(); msg.type = NetworkProtocol.SEND; msg.attr1 = this.remoteLocation.getVCN(); msg.attr2 = this.data.vcn; try { // Pass the message through the filter to convert it into bytes for transfer. Standard method is to convert // an object into a byte array via object serialization, but implementation specific methods can be // developed. // See NetworkMessageFilter and ObjectNetworkMessageFilter. msg.data = this.messageFilter.filterTX(object); // Now we must determine how to send the message. If it is to a remote Node, simply write to the Link. if (!this.isLocal) { this.toLinkTx.write(msg); } // If the input end is actually on this Node, then we attached our ackChannel to the message so the input // channel can send the ACK directly to us else { // Acquire lock on the input ends data structure synchronized (this.localChannel) { // Now check the local channels state and behave accordingly switch (this.localChannel.state) { case ChannelDataState.OK_INPUT: // We have an input end. Send message msg.toLink = this.data.toChannel; this.toLinkTx.write(msg); break; case ChannelDataState.POISONED: // The input end has been poisoned. Set our state and throw exception. // We don't need to acquire a lock. Only we can be operating on the channel this.data.state = ChannelDataState.POISONED; this.data.poisonLevel = this.localChannel.poisonLevel; throw new NetworkPoisonException(this.localChannel.poisonLevel); default: // In all other circumstances, we cause a network exception. Set state to broken // We do not need to acquire a lock. Only we can be operating on the channel this.data.state = ChannelDataState.BROKEN; // Remove ourselves from the ChannelManager ChannelManager.getInstance().removeChannel(this.data); throw new JCSPNetworkException("Channel rejected during send"); } } } } catch (IOException ioe) { throw new JCSPNetworkException("Error when trying to convert the message for sending"); } // Now we wait for a reply on our ackChannel NetworkMessage reply = (NetworkMessage)this.theAckChannel.read(); // The SEND was rejected. Break channel. if (reply.type == NetworkProtocol.REJECT_CHANNEL) { this.data.state = ChannelDataState.BROKEN; // Remove ourselves from the ChannelManager ChannelManager.getInstance().removeChannel(this.data); throw new JCSPNetworkException("Channel rejected during send"); } // The link to the input end has gone down. Break the channel else if (reply.type == NetworkProtocol.LINK_LOST) { this.data.state = ChannelDataState.BROKEN; // Remove ourselves from the ChannelManager ChannelManager.getInstance().removeChannel(this.data); throw new JCSPNetworkException("Link to Node lost. Send cannot complete"); } // The SEND resulted in us being poisoned. Poison the channel. There is nothing else that // can be done, as the input end has effectively gone. else if (reply.type == NetworkProtocol.POISON) { this.data.state = ChannelDataState.POISONED; this.data.poisonLevel = msg.attr2; throw new NetworkPoisonException(msg.attr2); } // We received an ACK. Return. else if (reply.type == NetworkProtocol.ACK) { return; } // This shouldn't happen. Throw exception. else { Node.err.log(this.getClass(), "Channel " + this.data.vcn + " reports unexpected message."); throw new JCSPNetworkException("NetChannelOutput received an unexpected exception"); } } /** * Asynchronously writes an object to the channel * * @param object * The object being written to the channel * @throws JCSPNetworkException * Thrown when something goes wrong in the network architecture * @throws PoisonException * Thrown if the channel is poisoned */ public void asyncWrite(Object object) throws JCSPNetworkException, PoisonException { // First we do a state check, and throw an exception if necessary if (this.data.state == ChannelDataState.DESTROYED) throw new JCSPNetworkException("Channel has been destroyed"); if (this.data.state == ChannelDataState.BROKEN) throw new JCSPNetworkException("Channel has broken"); if (this.data.state == ChannelDataState.POISONED) throw new NetworkPoisonException(this.data.poisonLevel); // The channel is in a suitable state to do a write. Continue write operation // First check that no pending messages have been left for us. This can happen if we did an async write and // then were rejected, poisoned, or if the link went down. if (this.theAckChannel.pending()) { NetworkMessage msg = (NetworkMessage)this.theAckChannel.read(); // Lock onto our state object as we may be changing our state synchronized (this.data) { // A previous ASYNC_SEND was rejected. Break channel. if (msg.type == NetworkProtocol.REJECT_CHANNEL) { this.data.state = ChannelDataState.BROKEN; // Remove ourselves from the ChannelManager ChannelManager.getInstance().removeChannel(this.data); // Now we may need to unregister from the Link if (!this.isLocal) { this.linkConnectedTo.deRegisterChannel(this.data); } throw new JCSPNetworkException("Channel rejected during previous send"); } // The link to the input end has gone down. Break the channel else if (msg.type == NetworkProtocol.LINK_LOST) { this.data.state = ChannelDataState.BROKEN; // Remove ourselves from the ChannelManager ChannelManager.getInstance().removeChannel(this.data); // Now we may need to unregister from the Link if (!this.isLocal) { this.linkConnectedTo.deRegisterChannel(this.data); } throw new JCSPNetworkException("Link to Node lost. Send cannot complete"); } // A previous ASYNC_SEND resulted in us being poisoned. Poison the channel. There is nothing else that // can be done, as the input end has effectively gone. else if (msg.type == NetworkProtocol.POISON) { this.data.state = ChannelDataState.POISONED; this.data.poisonLevel = msg.attr2; throw new NetworkPoisonException(msg.attr2); } // This shouldn't really happen, but possibly someone ACK'd us when they were not meant to. Throw // exception. else { Node.err.log(this.getClass(), "Channel " + this.data.vcn + " reports unexpected message."); throw new JCSPNetworkException("NetChannelOutput received an unexpected exception"); } } } // Create a new SEND message. NetworkMessage msg = new NetworkMessage(); msg.type = NetworkProtocol.ASYNC_SEND; msg.attr1 = this.remoteLocation.getVCN(); msg.attr2 = this.data.vcn; try { // Pass the message through the filter to convert it into bytes for transfer. Standard method is to convert // an object into a byte array via object serialization, but implementation specific methods can be // developed. // See NetworkMessageFilter and ObjectNetworkMessageFilter. msg.data = this.messageFilter.filterTX(object); // Now we must determine how to send the message. If it is to a remote Node, simply write to the Link. if (!this.isLocal) { this.toLinkTx.write(msg); } // If the input end is actually on this Node, then we attached our ackChannel to the message so the input // channel can send the ACK directly to us else { // Acquire lock on the input ends data structure synchronized (this.localChannel) { // Now check the local channels state and behave accordingly switch (this.localChannel.state) { case ChannelDataState.OK_INPUT: // We have an input end. Send message msg.toLink = this.data.toChannel; this.toLinkTx.write(msg); break; case ChannelDataState.POISONED: // The input end has been poisoned. Set our state and throw exception. // We don't need to acquire a lock. Only we can be operating on the channel this.data.state = ChannelDataState.POISONED; this.data.poisonLevel = this.localChannel.poisonLevel; throw new NetworkPoisonException(this.localChannel.poisonLevel); default: // In all other circumstances, we cause a network exception. Set state to broken // We do not need to acquire a lock. Only we can be operating on the channel this.data.state = ChannelDataState.BROKEN; // Remove ourselves from the ChannelManager ChannelManager.getInstance().removeChannel(this.data); throw new JCSPNetworkException("Channel rejected during send"); } } } } catch (IOException ioe) { throw new JCSPNetworkException("Error when trying to convert the message for sending"); } // We are asynchronous, so we simply return. } /** * Gets the channel data state for this channel. * * @return ChannelData for this channel */ final ChannelData getChannelData() { return this.data; } /** * Destroys the channel and removes it from the ChannelManager. */ public void destroy() { // Lock the channel data state synchronized (this.data) { // Set state to DESTROYED this.data.state = ChannelDataState.DESTROYED; // Remove channel from ChannelManager ChannelManager.getInstance().removeChannel(this.data); // Deregister from the Link if required. May be local if (this.linkConnectedTo != null) this.linkConnectedTo.deRegisterChannel(this.data); } } /** * Sets the underlying message filter * * @param encoder * The new message filter to use */ public void setEncoder(FilterTx encoder) { this.messageFilter = encoder; } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/ConnectionDataState.java 0000644 0000000 0000000 00000001023 11072626250 020544 0 ustar /** * */ package org.jcsp.net2; /** * @author Kevin Chalmers */ final class ConnectionDataState { static final byte INACTIVE = 0; static final byte CLIENT_STATE_CLOSED = 1; static final byte CLIENT_STATE_OPEN = 2; static final byte CLIENT_STATE_MADE_REQ = 3; static final byte SERVER_STATE_CLOSED = 4; static final byte SERVER_STATE_OPEN = 5; static final byte SERVER_STATE_RECEIVED = 6; static final byte DESTROYED = 7; static final byte BROKEN = 8; } jcsp-1.1-rc4.orig/src/org/jcsp/net2/NetConnectionServer.java 0000644 0000000 0000000 00000000233 11072626250 020611 0 ustar package org.jcsp.net2; import org.jcsp.lang.ConnectionServer; public interface NetConnectionServer extends Networked, ConnectionServer { } jcsp-1.1-rc4.orig/src/org/jcsp/net2/NetSharedChannelInput.java 0000644 0000000 0000000 00000001072 11072626250 021044 0 ustar package org.jcsp.net2; import org.jcsp.lang.SharedChannelInput; /** * Defines a networked ChannelInput that is safe to be used by multiple concurrent processes. For more information see * NetChannelInput and SharedChannelInput. To create an instance, see the relevant factory method. * * @see NetChannelInput * @see SharedChannelInput * @see NetChannel * @author Kevin Chalmers (updated from Quickstone Technologies) */ public interface NetSharedChannelInput extends SharedChannelInput, NetChannelInput { // Nothing new to declare } jcsp-1.1-rc4.orig/src/org/jcsp/net2/NetworkMessageFilter.java 0000644 0000000 0000000 00000003673 11072626250 020773 0 ustar package org.jcsp.net2; import java.io.IOException; /** * This class defines what is required for the internal networked channel filter. These filters are used to encode and * decode objects into a byte array equivalent. This enables data independence between separate platforms, as well as * data separation from the communication. Two filters are supplied with JCSP; a Object filter and a raw data filter. * The former will encode and decode messages using the standard object serialization techniques. The latter will expect * byte arrays only, and will do no encoding or decoding. The object filter is the default created by the network * factory methods. * * @see ObjectNetworkMessageFilter * @see RawNetworkMessageFilter * @author Kevin Chalmers */ public final class NetworkMessageFilter { /** * The filter used to decode an incoming message * * @author Kevin Chalmers */ public interface FilterRx { /** * Decodes an incoming byte array back into an object * * @param bytes * The bytes to be decoded * @return The recreated Object * @throws IOException * Thrown if something goes wrong during the decoding */ public Object filterRX(byte[] bytes) throws IOException; } /** * The filter used to encode an outgoing message * * @author Kevin Chalmers */ public interface FilterTx { /** * Encodes an object into an array of bytes for sending * * @param obj * The object to convert into bytes * @return The byte array representation of the Object * @throws IOException * Thrown if something goes wrong during the encoding */ public byte[] filterTX(Object obj) throws IOException; } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/NodeID.java 0000644 0000000 0000000 00000015060 11072626250 015762 0 ustar package org.jcsp.net2; import java.io.Serializable; /** * This class is used to uniquely identify a Node within the entire JCSP network of Nodes in operation. This is to allow * ease to identify individual Nodes when IDs come in, and to quickly find them within tables of other Links to allow * usage of existing connections. This is different to a NodeAddress, which is a symbolic name representing a Node, and * which therefore may be repeated. The hope here is that by using enough pieces of data the Node should have a unique * identification. This is done by gathering the information on the current system time in milliseconds, the current * free memory of the JVM, the hash code of a newly created object, the name of the Node, if there is one, and the * address of the Node itself. Having this much information should provide us with a unique ID. Other implementations of * the protocol can use other means of identifying a Node uniquely, but they must use the same amount of data, e.g. * string(number 64 bits) - string(number 64 bits) - string (number 32 bits) - string - address string, when * communicating with another JCSP Node for the sake of compatibility. * * @author Kevin Chalmers */ public final class NodeID implements Comparable, Serializable { /** * The SUID of this class */ private static final long serialVersionUID = 1L; /** * Current time in milliseconds */ private final long time; /** * Current amount of free memory to the JVM */ private final long mem; /** * Hash code of a object */ private final int hashCode; /** * Name of the Node */ private final String name; /** * Address of the Node */ private final NodeAddress address; /** * Constructor taking the name and the address of the Node * * @param nodeName * Symbolic name of the Node * @param nodeAddress * Symbolic address of the Node */ NodeID(String nodeName, NodeAddress nodeAddress) { this.time = System.currentTimeMillis(); this.mem = Runtime.getRuntime().freeMemory(); this.hashCode = new Object().hashCode(); this.name = nodeName; this.address = nodeAddress; } /** * Constructor taking the full details for a remote Node connection * * @param long1 * The time component of the remote Node * @param long2 * The memory component of the remote Node * @param int1 * The hashCode component of the remote Node * @param nodeName * The name component of the remote Node * @param nodeAddress * The NodeAddress component of the remote Node */ public NodeID(long long1, long long2, int int1, String nodeName, NodeAddress nodeAddress) { this.time = long1; this.mem = long2; this.hashCode = int1; this.name = nodeName; this.address = nodeAddress; } /** * Compares this NodeID with another NodeID. * * @param arg0 * @return -1, 0 or 1 if less than, equal, or greater than the other NodeID */ public int compareTo(final Object arg0) { // Check if other object is a NodeID. If not throw exception if (!(arg0 instanceof NodeID)) throw new IllegalArgumentException("Attempting to compare NodeID to an object that is not a NodeID"); NodeID other = (NodeID)arg0; // Compare to other NodeID values if (other.time < this.time) return 1; else if (other.time > this.time) return -1; else { // Time part is equal if (other.mem < this.mem) return 1; else if (other.mem > this.mem) return -1; else { // Memory part is equal if (other.hashCode < this.hashCode) return 1; else if (other.hashCode > this.hashCode) return -1; else { // Hashcode part is equal if (!(other.name.equals(this.name))) return this.name.compareTo(other.name); return this.address.compareTo(other.address); } } } } /** * Checks if the given object is equal to this NodeID * * @param arg0 * @return True if equal, false otherwise */ public boolean equals(Object arg0) { return this.compareTo(arg0) == 0; } /** * Returns the hashCode for this object * * @return Hashcode for the NodeID */ public int hashCode() { return this.hashCode; } /** * Converts the NodeID into a string for communication with other implementations, or for display purposes. * * @return String representation of the NodeID */ public String toString() { return this.time + "-" + this.mem + "-" + this.hashCode + "-" + this.name + "-" + this.address.toString(); } /** * Gets the NodeAddress part of the NodeID * * @return The NodeAddress part of the NodeID */ public NodeAddress getNodeAddress() { return this.address; } /** * Converts a string representation of a NodeID back to a NodeID object * * @param str * The string version of a NodeID * @return A new NodeID created from the String representation */ public static NodeID parse(String str) { // Split the string into its separate parts String[] pieces = new String[5]; int index = 0; int last = 0; for (int i = 0; i < 5; i++) { index = str.indexOf("-", index + 1); if (index == -1) index = str.length(); pieces[i] = str.substring(last, index); last = index + 1; } // Get the relevant parts long time = Long.parseLong(pieces[0]); long mem = Long.parseLong(pieces[1]); int hashCode = Integer.parseInt(pieces[2]); String name = pieces[3]; // Parse the address NodeAddress addr = NodeAddress.parse(pieces[4]); // Return the NodeID return new NodeID(time, mem, hashCode, name, addr); } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/NetChannelOutput.java 0000644 0000000 0000000 00000003055 11072626250 020121 0 ustar package org.jcsp.net2; import org.jcsp.lang.ChannelOutput; /** * An interface defining a ChannelOutput that is networked. For information on how to an object of this type, see * ChannelOutput. For information on how to create a NetChannelOutput, see the the relevant factory. ** The only method that this interface defines is asyncSend. This is considered a dangerous method to use, and careful * consideration must be taken. The inclusion of asyncSend is to provide the impression of a simple infinitely buffered * networked channel, without having to create extra buffers beyond what the channel uses. *
* * @see ChannelOutput * @see Networked * @see NetChannel * @author Kevin Chalmers (updated from Quickstone Technologies) */ public interface NetChannelOutput extends ChannelOutput, Networked { /** * Sends a message to the input end of the channel asynchronously (no blocking) * * @param obj * The object to send to the input end * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture * @throws NetworkPoisonException * Thrown if the channel is poisoned */ public void asyncWrite(Object obj) throws JCSPNetworkException, NetworkPoisonException; /** * Sets the underlying encoder for the channel * * @param encoder * The encoder to use for the channel. */ public void setEncoder(NetworkMessageFilter.FilterTx encoder); } jcsp-1.1-rc4.orig/src/org/jcsp/net2/NetworkProtocol.java 0000644 0000000 0000000 00000006534 11072626250 020041 0 ustar package org.jcsp.net2; /** * This class defines the constants used within the Link interactions. This is the network protocol for JCSP. This is an * internal class to JCSP, used specifically between Links and the Links and the networked constructs. * * @author Kevin Chalmers */ final class NetworkProtocol { /** * Empty constructor. This is a static set of values */ private NetworkProtocol() { // Empty constructor } /** * A SEND message from an output end to an input end */ final static byte SEND = 1; /** * An ACKnowledgment that releases an output end after a write */ final static byte ACK = 2; /** * An ENROLLment from a client end of a NetBarrier to a server end */ final static byte ENROLL = 3; /** * A RESIGNation of a client end of a NetBarrier from a server end */ final static byte RESIGN = 4; /** * A SYNChronization message sent from a client end of a NetBarrier to a server end when the client's local * processes have all synchronised */ final static byte SYNC = 5; /** * RELEASEs a waiting client end of a NetBarrier when the server end has completely been synced with */ final static byte RELEASE = 6; /** * Rejects a message sent from a NetBarrier. */ final static byte REJECT_BARRIER = 7; /** * Rejects a message sent from a NetChannelOutput */ final static byte REJECT_CHANNEL = 8; /** * Signifies that a Link has been lost */ final static byte LINK_LOST = 9; /** * Mobility message. Still to be defined */ final static byte MOVED = 10; /** * Mobility message. Still to be defined */ final static byte ARRIVED = 11; /** * A POISON message sent to poison a channel end */ final static byte POISON = 12; /** * An Asynchronous send operation */ final static byte ASYNC_SEND = 13; /** * The initial message sent from a client connection end to a server end */ final static byte OPEN = 14; /** * The subsequent communications from a client connection before closing */ final static byte REQUEST = 15; /** * The reply from the server end of a connection */ final static byte REPLY = 16; /** * A reply from the server end of a connection which also closes the connection */ final static byte REPLY_AND_CLOSE = 17; /** * An asynchronous open message */ final static byte ASYNC_OPEN = 18; /** * An asynchronous request to a connection server */ final static byte ASYNC_REQUEST = 19; /** * An asynchronous reply from the server */ final static byte ASYNC_REPLY = 20; /** * An asynchronous reply and close */ final static byte ASYNC_REPLY_AND_CLOSE = 21; /** * An acknowledgement of the initial OPEN or REQUEST by a client connection end */ final static byte REQUEST_ACK = 22; /** * An acknowledgement of a connection server REPLY */ final static byte REPLY_ACK = 23; /** * Rejects a message from a networked connection */ final static byte REJECT_CONNECTION = 24; } jcsp-1.1-rc4.orig/src/org/jcsp/net2/Mutex.java 0000644 0000000 0000000 00000002057 11072626250 015764 0 ustar package org.jcsp.net2; import org.jcsp.lang.ProcessInterruptedException; /** * A package-visible class that implements a straightforward mutex, for use by Net2AnyChannel * * @author Neil Brown */ class Mutex { /** * Flag to mark the mutex as claimed */ private boolean claimed = false; /** * Claims the mutex for exclusive access */ void claim() { synchronized (this) { while (this.claimed) { try { wait(); } catch (InterruptedException e) { throw new ProcessInterruptedException("*** Thrown from Mutex.claim()\n" + e.toString()); } } this.claimed = true; } } /** * Releases the mutex for exclusive access */ void release() { synchronized (this) { this.claimed = false; notify(); } } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/LinkFactory.java 0000644 0000000 0000000 00000017671 11072626250 017117 0 ustar package org.jcsp.net2; import org.jcsp.lang.ProcessManager; /** * This class is used to create a new Link from a given NodeID or NodeAddress. ** It is perfectly reasonable for a user to create a Link to another Node without utilising the normal connection * methods. This class is therefore made public to allow such an occurrence. *
** Example, using TCP/IP *
*
*
* TCPIPNodeAddress address = new TCPIPNodeAddress("192.168.1.100", 5000);
*
* Link link = LinkFactory.getLink(address);
*
* The getLink method will either return an existing Link if one exists, or it shall create a new one if necessary. *
** Using this method allows quick creation of channels / barrier on a remote Node without going through the normal name * servers. For example: *
*
*
* NetChannelLocation loc = new NetChannelLocation(link.getRemoteNodeID(), 100);
*
* NetChannelOutput out = NetChannelEnd.one2net(loc);
*
* This method is generally considered faster than using the CNS, or creating channels just using the address and VCN. * It does require the user to know the address and channel number that is to be connected too. *
* * @see Link * @see NodeAddress * @see NodeID * @author Kevin Chalmers (updated from Quickstone Technologies) */ public final class LinkFactory { /** * Default private constructor. Not used. */ private LinkFactory() { // Empty constructor } /** * Creates a new Link or gets an existing one from the the given NodeID. * * @param nodeID * NodeID of the Node to connect to. * @return A Link connected to the remote Node of given NodeID * @throws JCSPNetworkException * Thrown if there is a problem connecting to the Node * @throws IllegalArgumentException * Thrown if an attempt is made to connect to the local Node */ public static Link getLink(NodeID nodeID) throws JCSPNetworkException, IllegalArgumentException { if (nodeID.equals(Node.getInstance().getNodeID())) throw new IllegalArgumentException("Attempted to connect to the local Node"); // Log start of Link creation Node.log.log(LinkFactory.class, "Trying to get link to " + nodeID.toString()); // First check if Link to NodeID exists. Request the Link from the Link Manager Link toReturn = LinkManager.getInstance().requestLink(nodeID); if (toReturn != null) { // A Link already exists to given NodeID. Log and return existing Link Node.log.log(LinkFactory.class, "Link to " + nodeID.toString() + " already exists. Returning existing Link"); return toReturn; } // An existing Link does not exist within the Link Manager. Log, and then create Link via the address Node.log.log(LinkFactory.class, "Link does not exist to " + nodeID.toString() + ". Creating new Link"); toReturn = nodeID.getNodeAddress().createLink(); // Now attempt to connect the Link. If connect fails, then the opposite node already has a connection to us. // This may occur during connection if the opposite end registered its Link prior to us doing so. In such // a circumstance, the Link should eventually appear in the LinkManager. if (!toReturn.connect()) { // Connect failed. Get NodeID of remote Node (this will have been set during the connect operation) NodeID remoteID = toReturn.getRemoteNodeID(); // Log failed connect Node.log.log(LinkFactory.class, "Failed to connect to " + remoteID.toString()); // Set the Link to return to null toReturn = null; // Loop until the Link is connected. This is a possible weakness. Although it is believed that the // opposite end will eventually connect, we may have a problem if this continually loops. For information, // log every attempt. while (toReturn == null) { try { // Go to sleep for a bit, and give the Link a chance to register Thread.sleep(100); // Log start of attempt Node.log.log(LinkFactory.class, "Attempting to retrieve Link to " + remoteID.toString()); // Retrieve Link from LinkManager toReturn = LinkManager.getInstance().requestLink(remoteID); } catch (InterruptedException ie) { // Ignore. Should never really happen } } // Return the Link retrieved from the LinkManager return toReturn; } // Connection succeeded. Register Link with the LinkManager toReturn.registerLink(); // Now start the Link ProcessManager proc = new ProcessManager(toReturn); proc.setPriority(toReturn.priority); proc.start(); // Return the Link return toReturn; } /** * Creates a new Link, or retrieves an existing one, from a NodeAddress * * @param addr * The NodeAddress of the Node to connect to * @return A new Link connected to the node at the given NodeAddress * @throws JCSPNetworkException * Thrown if anything goes wrong during the connection */ public static Link getLink(NodeAddress addr) throws JCSPNetworkException { // Log start of creation Node.log.log(LinkFactory.class, "Trying to get link to " + addr.toString()); // Create Link from address Link toReturn = addr.createLink(); // Now attempt to connect the Link. If connect fails, then the opposite node already has a connection to us. // This may occur during connection if the opposite end registered its Link prior to us doing so. In such // a circumstance, the Link should eventually appear in the LinkManager. if (!toReturn.connect()) { // Connect failed. Get NodeID of remote Node (this will have been set during the connect operation) NodeID remoteID = toReturn.getRemoteNodeID(); // Log failed connect Node.log.log(LinkFactory.class, "Failed to connect to " + remoteID.toString()); // Set the Link to return to null toReturn = null; // Loop until the Link is connected. This is a possible weakness. Although it is believed that the // opposite end will eventually connect, we may have a problem if this continually loops. For information, // log every attempt. while (toReturn == null) { try { // Go to sleep for a bit, and give the Link a chance to register Thread.sleep(100); // Log start of attempt Node.log.log(LinkFactory.class, "Attempting to retrieve Link to " + remoteID.toString()); // Retrieve Link from LinkManager toReturn = LinkManager.getInstance().requestLink(remoteID); } catch (InterruptedException ie) { // Ignore. Should never really happen } } // Return the Link retrieved from the LinkManager return toReturn; } // Connection succeeded. Register Link with the LinkManager toReturn.registerLink(); // Now start the Link new ProcessManager(toReturn).start(); // Return the Link return toReturn; } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/ChannelData.java 0000644 0000000 0000000 00000003041 11072626250 017016 0 ustar package org.jcsp.net2; import org.jcsp.lang.ChannelInput; import org.jcsp.lang.ChannelOutput; /** * A class that is used to keep track of the state of a network channel. For a description of networked channels, see * the relevant documentation. * * @see org.jcsp.net2.NetChannelInput * @see org.jcsp.net2.NetChannelOutput * @author Kevin Chalmers */ final class ChannelData { /** * The virtual channel number. A unique number on the Node for identifying a channel. */ int vcn = -1; /** * The current state of the channel. */ byte state = ChannelDataState.INACTIVE; /** * The channel output used to connect to the network channel object. For a networked input end this is used to * communicate input messages from connected output ends. For output channels this is usually used for * acknowledgement, but may also be used for passing link lost and poison messages. */ ChannelOutput toChannel = null; /** * Indicates the level of poison that has been placed on the channel, if relevant. */ int poisonLevel = -1; /** * Indicates the immunity level to poison this channel has */ int immunityLevel = Integer.MAX_VALUE; /** * The other end of the toChannel. This will be set whenever a channel is used in a mobile manner. Any received * messages when the channel is moved are written to the normal channel, and they can then be accessed via this end. */ ChannelInput fromChannel = null; } jcsp-1.1-rc4.orig/src/org/jcsp/net2/NetworkPoisonException.java 0000644 0000000 0000000 00000001252 11072626250 021356 0 ustar package org.jcsp.net2; import org.jcsp.lang.PoisonException; /** * An exception thrown when a networked channel is poisoned. See the poison exception in the core package for more * information * * @see PoisonException * @author Kevin Chalmers */ public final class NetworkPoisonException extends PoisonException { /** * The SUID of the class */ private static final long serialVersionUID = 1L; /** * Creates a new NetworkPoisonException * * @param strength * The strength of the poison */ protected NetworkPoisonException(int strength) { super(strength); } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/Networked.java 0000644 0000000 0000000 00000001177 11072626250 016626 0 ustar package org.jcsp.net2; /** * Defines a standard JCSP synchronization mechanism which is also networked. For concrete examples of this class, see * NetBarrier, and the networked channels * * @see NetBarrier * @see NetChannelInput * @see NetChannelOutput * @author Kevin Chalmers (updated from Quickstone Technologies) */ public interface Networked { /** * Gets the networked location of the Networked construct * * @return The location of the construct */ public NetLocation getLocation(); /** * Destroys the Networked construct */ public void destroy(); } jcsp-1.1-rc4.orig/src/org/jcsp/net2/cns/ 0000755 0000000 0000000 00000000000 11410045051 014564 5 ustar jcsp-1.1-rc4.orig/src/org/jcsp/net2/cns/CNSNetworkMessageFilter.java 0000644 0000000 0000000 00000010665 11072626250 022121 0 ustar package org.jcsp.net2.cns; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import org.jcsp.net2.NetChannelLocation; import org.jcsp.net2.NetworkMessageFilter; /** * This filter is used by the CNS and CNSService to transmit messages between one another in a manner that is platform * independent. This is an internal class to JCSP, and is created automatically by the CNS and CNSService. For more * information, see the relevant documentation. * * @see CNS * @see CNSService * @see NetworkMessageFilter * @author Kevin Chalmers */ final class CNSNetworkMessageFilter { /** * The encoding filter used to convert a CNSMessage into bytes * * @author Kevin Chalmers */ static final class FilterTX implements NetworkMessageFilter.FilterTx { /** * The byte stream we will use to retrieve the byte message from */ private final ByteArrayOutputStream baos; /** * The data stream, used to write the parts of the CNSMessage to */ private final DataOutputStream dos; /** * Creates a new CNS encoding filter */ FilterTX() { this.baos = new ByteArrayOutputStream(8192); this.dos = new DataOutputStream(this.baos); } /** * Converts an object (a CNSMessage) into bytes * * @param obj * The CNSMessage to convert * @return The byte equivalent of the CNSMessage * @throws IOException * Thrown if something goes wrong during the conversion */ public byte[] filterTX(Object obj) throws IOException { // First ensure we have a CNSMessage if (!(obj instanceof CNSMessage)) throw new IOException("Attempted to send a non CNSMessage on a CNSMessage channel"); CNSMessage msg = (CNSMessage)obj; // Now reset the byte stream this.baos.reset(); // Write the parts of the CNSMessage to the stream this.dos.writeByte(msg.type); this.dos.writeBoolean(msg.success); if (msg.location1 != null) this.dos.writeUTF(msg.location1.toString()); else this.dos.writeUTF("null"); if (msg.location2 != null) this.dos.writeUTF(msg.location2.toString()); else this.dos.writeUTF("null"); this.dos.writeUTF(msg.name); // Flush the stream this.dos.flush(); // Get the bytes return this.baos.toByteArray(); } } /** * The filter used to convert a CNSMessage from its byte representation back into an object * * @author Kevin Chalmers */ static final class FilterRX implements NetworkMessageFilter.FilterRx { /** * The input end to read the message back from */ private ByteArrayInputStream byteIn; /** * The data input stream used to read in the parts of the message */ private DataInputStream dis; /** * Creates a new decoding CNSMessage filter */ FilterRX() { // Nothing to do } /** * Decodes the byte equivalent of a CNSMessage * * @param bytes * The byte equivalent of a CNSMessage * @return The recreated CNSMessage * @throws IOException * Thrown if something goes wrong during the recreation */ public Object filterRX(byte[] bytes) throws IOException { this.byteIn = new ByteArrayInputStream(bytes); this.dis = new DataInputStream(byteIn); // Recreate the message CNSMessage msg = new CNSMessage(); msg.type = this.dis.readByte(); msg.success = this.dis.readBoolean(); msg.location1 = NetChannelLocation.parse(this.dis.readUTF()); msg.location2 = NetChannelLocation.parse(this.dis.readUTF()); msg.name = this.dis.readUTF(); return msg; } } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/cns/CNSService.java 0000644 0000000 0000000 00000010617 11072626250 017412 0 ustar package org.jcsp.net2.cns; import org.jcsp.net2.JCSPNetworkException; import org.jcsp.net2.NetChannel; import org.jcsp.net2.NetChannelInput; import org.jcsp.net2.NetChannelLocation; import org.jcsp.net2.NetChannelOutput; import org.jcsp.net2.Node; import org.jcsp.net2.NodeID; /** * This is the service object used to register and resolve channel names with a Channel Name Server. This provides a * client front end. * * @author Kevin Chalmers (updated from Quickstone Technologies) */ public final class CNSService { /** * The channel to send messages to the CNS upon */ private final NetChannelOutput toCNS; /** * The incoming channel to receive messages from the CNS from */ private final NetChannelInput fromCNS; /** * Creates a new CNSService * * @param cnsNode * The NodeID of the Node with the CNS on it * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public CNSService(NodeID cnsNode) throws JCSPNetworkException { // Create the input and output channel this.toCNS = NetChannel.one2net(new NetChannelLocation(cnsNode, 1), new CNSNetworkMessageFilter.FilterTX()); this.fromCNS = NetChannel.net2one(new CNSNetworkMessageFilter.FilterRX()); // We now need to logon to the CNS CNSMessage message = new CNSMessage(); message.type = CNSMessageProtocol.LOGON_MESSAGE; message.location1 = (NetChannelLocation)this.fromCNS.getLocation(); this.toCNS.write(message); // Wait for logon reply message CNSMessage logonReply = (CNSMessage)this.fromCNS.read(); // Check if we logged on OK if (logonReply.success == false) { Node.err.log(this.getClass(), "Failed to logon to CNS"); throw new JCSPNetworkException("Failed to Logon to CNS"); } Node.log.log(this.getClass(), "Logged into CNS"); } /** * Registers an input end with the CNS * * @param name * The name to register the channel with * @param in * The NetChannelInput to register with the CNS * @return True if the channel was successfully registered, false otherwise */ public boolean register(String name, NetChannelInput in) { // Ensure that only one registration can happen at a time synchronized (this) { // Create a new registration message CNSMessage message = new CNSMessage(); message.type = CNSMessageProtocol.REGISTER_REQUEST; message.name = name; message.location1 = (NetChannelLocation)this.fromCNS.getLocation(); message.location2 = (NetChannelLocation)in.getLocation(); // Write registration message to the CNS this.toCNS.write(message); // Read in reply CNSMessage reply = (CNSMessage)this.fromCNS.read(); return reply.success; } } /** * Resolves a name on the CNS, retrieving the NetChannelLocation for the channel * * @param name * The name to resolve * @return The NetChannelLocation of the channel declared name * @throws JCSPNetworkException * Thrown if something goes wrong in the underlying architecture */ public NetChannelLocation resolve(String name) throws JCSPNetworkException { // Create a temporary channel to receive the incoming NetChannelLocation NetChannelInput in = NetChannel.net2one(new CNSNetworkMessageFilter.FilterRX()); // Create a resolution message CNSMessage message = new CNSMessage(); message.type = CNSMessageProtocol.RESOLVE_REQUEST; message.location1 = (NetChannelLocation)in.getLocation(); message.name = name; // Write the resolution message to the CNS this.toCNS.write(message); // Read in reply CNSMessage reply = (CNSMessage)in.read(); // Destroy the temporary channel in.destroy(); // Now return the resolved location, or throw an exception if (reply.success == true) return reply.location1; throw new JCSPNetworkException("Failed to resolve channel named: " + name); } } jcsp-1.1-rc4.orig/src/org/jcsp/net2/cns/CNSMessage.java 0000644 0000000 0000000 00000001352 11072626250 017372 0 ustar package org.jcsp.net2.cns; import org.jcsp.net2.NetChannelLocation; /** * A message sent between a CNS and a CNSService. This is an internal structure to JCSP. * * @author Kevin Chalmers */ final class CNSMessage { /** * The message type. See CNSMessageProtocol */ byte type = 0; /** * Whether the previous message was successful */ boolean success = false; /** * Location parameter. Usually the location to register */ NetChannelLocation location1 = null; /** * Location parameter. Usually the reply location */ NetChannelLocation location2 = null; /** * Name to register or resolve */ String name = ""; } jcsp-1.1-rc4.orig/src/org/jcsp/net2/cns/CNSMessageProtocol.java 0000644 0000000 0000000 00000002624 11072626250 021117 0 ustar package org.jcsp.net2.cns; /** * This class defines the message types that can be sent to and from the CNS. This is internal to JCSP * * @author Kevin Chalmers */ final class CNSMessageProtocol { /** * Empty, private constructor. We do not create instances of this class. */ private CNSMessageProtocol() { // Empty constructor } /** * A message sent from a CNSService to a CNS allowing logging on */ static final byte LOGON_MESSAGE = 1; /** * The reply from a Logon */ static final byte LOGON_REPLY_MESSAGE = 2; /** * Register a name with the CNS */ static final byte REGISTER_REQUEST = 3; /** * Resolve a location from the CNS */ static final byte RESOLVE_REQUEST = 4; /** * *** Not currently used *** */ static final byte LEASE_REQUEST = 5; /** * *** Not currently used *** */ static final byte DEREGISTER_REQUEST = 6; /** * A reply from a registration request */ static final byte REGISTER_REPLY = 7; /** * A reply from a resolve request */ static final byte RESOLVE_REPLY = 8; /** * *** Not currently used *** */ static final byte LEASE_REPLY = 9; /** * *** Not currently used *** */ static final byte DEREGISTER_REPLY = 10; } jcsp-1.1-rc4.orig/src/org/jcsp/net2/cns/CNS.java 0000644 0000000 0000000 00000203416 11072626250 016072 0 ustar package org.jcsp.net2.cns; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import org.jcsp.lang.Alternative; import org.jcsp.lang.AltingChannelInput; import org.jcsp.lang.CSProcess; import org.jcsp.lang.Guard; import org.jcsp.net2.JCSPNetworkException; import org.jcsp.net2.Link; import org.jcsp.net2.LinkFactory; import org.jcsp.net2.NetAltingChannelInput; import org.jcsp.net2.NetChannel; import org.jcsp.net2.NetChannelLocation; import org.jcsp.net2.NetChannelOutput; import org.jcsp.net2.NetSharedChannelInput; import org.jcsp.net2.NetSharedChannelOutput; import org.jcsp.net2.NetworkMessageFilter; import org.jcsp.net2.Node; import org.jcsp.net2.NodeAddress; import org.jcsp.net2.NodeID; /** ** This class is the Channel Name Server's main server process class. *
*
* This class should only be instantiated at Nodes wishing to run a server process. Although this class does not need to
* be used by clients wishing to interact with a server, it does provide some convenient static methods for client code
* to use. There are static versions of the methods provided in CNSService and there are also static
* factory methods for constructing CNS registered channel objects.
*
*
Server Installation
* ** Channel Name Servers may be run either on a dedicated Node or else on the same Node as one of the user Nodes. The * former approach is recommended for most situations but for smaller scale use, the latter approach may suffice. *
** The following example initialises a Node and installs a Channel Name Server. It then proceeds to install a CNS client * service and creates and resolves a channel. The example does not proceed to do anything else but could be used as the * framework for an application wishing to host its own Channel Name Server. *
*
*
* import org.jcsp.lang.*;
*
* import org.jcsp.net2.*;
* import org.jcsp.net2.cns.*;
* import org.jcsp.net2.tcpip.*;
* import java.io.IOException;
* public class CNSInSameJVM implements CSProcess {
* //main method for running example
* public static void main(String[] args) {
* CNSInSameJVM proc = new CNSInSameJVM();
* proc.run();
* }
* public void run() {
* NodeKey key = null;
* NodeID localNodeID = null;
* try {
* //Initialize a Node that does not have a CNS client
* key = Node.getInstance().init(new TCPIPNodeAddress(7890));
* new ProcessManager(CNS.getInstance()).start();
* //Dedicated server code could stop here
* //Initialise the CNS client
* //use the local NodeID to connect to the CNS
* localNodeID = Node.getInstance().getNodeID();
* CNS.init(localNodeID);
* // creating Channel named "in"
* NetChannelInput in = CNS.net2one("in");
* //resolve the channel
* NetChannelOutput out = CNS.one2net("in");
* //could now use these channels for something!!
* //but this is only a test so will terminate
* } catch (NodeInitFailedException e) {
* e.printStackTrace();
* } catch (IOException e) {
* e.printStackTrace();
* }
* Node.log.log(this, "Done."); } }
*
*
Channel Factory Methods
* *
* In order to construct a ChannelInput object which can be resolved by other users of a channel name
* server, a client simply needs to to do this:
*
* NetChannelInput in = CNS.net2one("Fred");
*
*
* Another process using the same channel name server can create a ChannelOutput that will send objects
* to this channel by do this:
*
* NetChannelOutput out = CNS.one2net("Fred");
*
* * When these factory methods are called, various resources are used within the JCSP infrastructure. A channel name will * be registered and held in the channel name server. These resources are taken for the duration of the JCSP Node's * runtime. *
** This is an example "Hello World" program which contains two inner classes with main methods, each of which can be run * in separate JVMs. *
* *
* import org.jcsp.lang.*;
* import org.jcsp.net2.*;
* import org.jcsp.net2.cns.*;
*
* public class TestCNS
* {
* public static class Rx
* {
* public static void main(String[] args)
* {
* try
* {
* Node.getInstance().init(new TCPIPNodeAddress(7890));
* NetChannelInput in = CNS.net2one("rx.in");
* System.out.println(in.read());
* }
* catch (Exception e)
* {
* e.printStackTrace();
* }
* }
* }
*
* public static class Tx
* {
* public static void main(String[] args)
* {
* try
* {
* Node.getInstance().init(new TCPIPNodeAddress(7890));
* NetChannelOutput out = CNS.one2net("rx.in");
* out.write("Hello World");
* }
* catch (Exception e)
* {
* e.printStackTrace();
* }
* }
* }
* }
*
*
* * This code can be compiled and then the following run at two command prompts: *
** java TestCNS$Rx *
** java TestCNS$Tx *
*
* The programs will connect to a default channel name server. The Rx program will create a NetChannelInput
* and wait for a message on the channel. Once it has received the message, it prints it, then terminates. The Tx
* program creates a NetChannelOutput that will send to the Rx program's input channel. It sends a "Hello
* World" message. Once this has been accepted by the Rx process, it terminates.
*
-
*/
private final HashMap channelRegister = new HashMap();
/**
* The map of currently waiting resolves; name->reply-location
*/
private final HashMap waitingResolves = new HashMap();
/**
* The map of currently logged clients; NodeID->reply-channel
*/
private final HashMap loggedClients = new HashMap();
/**
* A channel used to receive incoming link lost notifications
*/
private final AltingChannelInput lostLink = Node.getInstance().getLinkLostEventChannel();
/**
* Private empty constructor
*/
private CNS()
{
// Empty constructor
}
/**
* Gets the singleton instance of the CNS
*
* @return The singleton instance of the CNS
*/
public static CNS getInstance()
{
return instance;
}
/**
* Initialises the factory methods to allow creation of channels with the CNS
*
* @param cnsNode
* The Node that the CNS is located on
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static void initialise(NodeID cnsNode)
throws JCSPNetworkException
{
// First check that we are not already initialised
if (CNS.initialised)
throw new JCSPNetworkException("The CNS is already initialised");
// We are not initialised. Attempt to do so.
// First, we need to create the CNSService
CNS.service = new CNSService(cnsNode);
// Now set initialised to true
CNS.initialised = true;
// We are now connected
}
/**
* Initialises the factory methods to allow creation of channels with the CNS
*
* @param cnsNode
* The Node that the CNS is located on
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static void initialise(NodeAddress cnsNode)
throws JCSPNetworkException
{
// First check that we are not already initialised
if (CNS.initialised)
throw new JCSPNetworkException("The CNS is already initialised");
// We are not initialised. Attempt to do so.
// First, we need to get the NodeID
Link link = LinkFactory.getLink(cnsNode);
// Now create the CNSService
CNS.service = new CNSService(link.getRemoteNodeID());
// Now set initialised to true
CNS.initialised = true;
// We are now connected
}
/**
* The run method for the CNS process
*/
public void run()
{
// Create the channel to receive incoming messages on. The index is 1.
NetAltingChannelInput in = NetChannel.numberedNet2One(1, new CNSNetworkMessageFilter.FilterRX());
// Now we wish to alternate upon this channel, and the link lost channel
Alternative alt = new Alternative(new Guard[] { this.lostLink, in });
// Loop forever
while (true)
{
// Select next available Guard. Give priority to link failure
switch (alt.priSelect())
{
// We have lost the connection to a Node
case 0:
// Read in the NodeID of the lost Node
NodeID lostNode = (NodeID)this.lostLink.read();
// Log loss of connection
Node.log.log(this.getClass(), "Lost Link to: " + lostNode.toString());
// First remove the logged client
this.loggedClients.remove(lostNode);
// Next get the ArrayList of any channels registered by that Node
ArrayList registeredChans = (ArrayList)this.channelRegister.get(lostNode);
// If this ArrayList is null, we have no registrations.
if (registeredChans != null)
{
// There are registered channels
// Remove the list from the HashMap
this.channelRegister.remove(lostNode);
// Now remove all the channels registered by that Node
for (Iterator iter = registeredChans.iterator(); iter.hasNext();)
{
String toRemove = (String)iter.next();
this.registeredChannels.remove(toRemove);
Node.log.log(this.getClass(), toRemove + " deregistered");
}
}
break;
// We have received a new incoming message
case 1:
{
// Read in the message
CNSMessage message = (CNSMessage)in.read();
// Now behave based on the type of the message
switch (message.type)
{
// We have received a LOGON_MESSAGE
case CNSMessageProtocol.LOGON_MESSAGE:
{
// Log the logon attempt
Node.log.log(this.getClass(), "Logon received from: "
+ message.location1.getNodeID().toString());
// try-catch loop. We don't want the CNS to fail
try
{
// Check if the Node is already logged on
NetChannelOutput out = (NetChannelOutput)this.loggedClients.get(message.location1
.getNodeID());
// If out is null, no previous log on received
if (out != null)
{
// This Node is already logged on. Send fail message
// Log failed attempt
Node.err.log(this.getClass(), message.location1.getNodeID().toString()
+ " already logged on. Rejecting");
// Create reply channel to the Node.
NetChannelOutput toNewRegister = NetChannel.one2net(message.location1,
new CNSNetworkMessageFilter.FilterTX());
// Create the reply message
CNSMessage reply = new CNSMessage();
reply.type = CNSMessageProtocol.LOGON_REPLY_MESSAGE;
reply.success = false;
// Asynchronously write to Node. We don't want the CNS to block
toNewRegister.asyncWrite(reply);
// Destroy the temporary channel
toNewRegister.destroy();
}
else
{
// Node hasn't previously registered
// Log registration
Node.log.log(this.getClass(), message.location1.getNodeID().toString()
+ " successfully logged on");
// Create the reply channel
NetChannelOutput toNewRegister = NetChannel.one2net(message.location1,
new CNSNetworkMessageFilter.FilterTX());
// Add the Node and the reply channel to the logged clients table
this.loggedClients.put(message.location1.getNodeID(), toNewRegister);
// Create reply message
CNSMessage reply = new CNSMessage();
reply.type = CNSMessageProtocol.LOGON_REPLY_MESSAGE;
reply.success = true;
// Write reply to the logging on Node asynchronously
toNewRegister.asyncWrite(reply);
}
}
catch (JCSPNetworkException jne)
{
// We do nothing. We have caught this to ensure nothing goes wrong during the I/O
}
break;
}
// A Node is attempting to register a channel
case CNSMessageProtocol.REGISTER_REQUEST:
{
// Log registration
Node.log.log(this.getClass(), "Registration for " + message.name + " received");
// Catch any JCSPNetworkException
try
{
// Get the reply channel from our logged clients map
NetChannelOutput out = (NetChannelOutput)this.loggedClients.get(message.location1
.getNodeID());
// Check if the Node has logged on with us
if (out == null)
{
// The Node is not logged on. Send failure message
Node.err.log(this.getClass(), "Registration failed. "
+ message.location1.getNodeID() + " not logged on");
// Create the channel to reply to
out = NetChannel.one2net(message.location1, new CNSNetworkMessageFilter.FilterTX());
// Create the reply message
CNSMessage reply = new CNSMessage();
reply.type = CNSMessageProtocol.REGISTER_REPLY;
reply.success = false;
// Write the reply asynchronously. Do not block the CNS
out.asyncWrite(reply);
// Destroy the temporary channel
out.destroy();
}
// The Node is registered, now check if the name is
else if (this.registeredChannels.containsKey(message.name))
{
// The name is already registered. Inform the register
// Log the failed registration
Node.err.log(this.getClass(), "Registration failed. " + message.name
+ " already registered");
// Create reply message
CNSMessage reply = new CNSMessage();
reply.type = CNSMessageProtocol.REGISTER_REPLY;
reply.success = false;
// Write the reply asynchronously. Do not block the CNS
out.asyncWrite(reply);
}
else
{
// Name is not already registered.
// Log successful registration
Node.log.log(this.getClass(), "Registration of " + message.name + "succeded");
// Now check if any client end is waiting for this name
ArrayList pending = (ArrayList)this.waitingResolves.get(message.name);
if (pending != null)
{
// We have waiting resolves. Complete
for (Iterator iter = pending.iterator(); iter.hasNext();)
{
NetChannelOutput toPending = null;
// We now catch internally any JCSPNetworkExceptions
try
{
// Get the next waiting message
CNSMessage msg = (CNSMessage)iter.next();
// Log resolve completion
Node.log.log(this.getClass(), "Queued resolve of " + message.name
+ " by " + msg.location1.getNodeID()
+ " completed");
// Create the channel to the resolver
toPending = NetChannel.one2net(msg.location1,
new CNSNetworkMessageFilter.FilterTX());
// Create the reply message
CNSMessage reply = new CNSMessage();
reply.type = CNSMessageProtocol.RESOLVE_REPLY;
reply.location1 = message.location2;
reply.success = true;
// Write the reply asynchronously to the waiting resolver
toPending.asyncWrite(reply);
}
catch (JCSPNetworkException jne)
{
// Something went wrong as we tried to send the resolution completion.
// Do nothing
}
finally
{
// Destroy the temporary channel if necessary
if (toPending != null)
toPending.destroy();
}
}
// Remove the name from the pending resolves
this.waitingResolves.remove(message.name);
}
// We have completed any pending resolves on this channel. Now we register the
// channel
this.registeredChannels.put(message.name, message.location2);
// Now we add the registered channel to the channels registered by this Node
ArrayList registered = (ArrayList)this.channelRegister.get(message.location1
.getNodeID());
// If the ArrayList is null, we have no previous registrations
if (registered == null)
{
// Create a new ArrayList to store the registered names with
registered = new ArrayList();
// Add it to the channel register
this.channelRegister.put(message.location1.getNodeID(), registered);
}
// Add the name to the ArrayList
registered.add(message.name);
// Log the successful registration
Node.log.log(this.getClass(), message.name + " registered to " + message.location2);
// Create the reply message
CNSMessage reply = new CNSMessage();
reply.type = CNSMessageProtocol.REGISTER_REPLY;
reply.success = true;
// Write it asynchronously to the registering Node
out.asyncWrite(reply);
}
}
catch (JCSPNetworkException jne)
{
// Something went wrong during the I/O operations. Ignore
}
}
break;
// We have received a resolve request
case CNSMessageProtocol.RESOLVE_REQUEST:
{
// Log resolve request
Node.log.log(this.getClass(), "Resolve request for " + message.name + " received");
// Catch any JCSP Network Exception
try
{
// Check if the resolving Node is logged on
NetChannelOutput out = (NetChannelOutput)this.loggedClients.get(message.location1
.getNodeID());
// If the channel is null, then the Node has yet to log on with us
if (out == null)
{
// Node is not logged on
// Log failed resolution
Node.err.log(this.getClass(), "Resolve failed. " + message.location1.getNodeID()
+ " not logged on");
// Create connection to the resolver
out = NetChannel.one2net(message.location1, new CNSNetworkMessageFilter.FilterTX());
// Create the reply message
CNSMessage reply = new CNSMessage();
reply.type = CNSMessageProtocol.RESOLVE_REPLY;
reply.success = false;
// Write message asynchronously to the Node
out.asyncWrite(reply);
// Destroy temporary channel
out.destroy();
}
else
{
// Node is logged on. Now we check if the name is already registered
NetChannelLocation loc = (NetChannelLocation)this.registeredChannels
.get(message.name);
// If the location is null, then the name has yet to be registered.
if (loc == null)
{
// The name is not registered. We need to queue the resolve until it does
// Log the queueing of the resolve
Node.log.log(this.getClass(), message.name
+ " not registered. Queueing resolve by "
+ message.location1.getNodeID().toString());
// Check if any other resolvers are waiting for the channel
ArrayList pending = (ArrayList)this.waitingResolves.get(message.name);
// If the ArrayList is null, no one else is waiting
if (pending == null)
{
// No one else is waiting. Create a new list and add it to the waiting
// resolves
pending = new ArrayList();
this.waitingResolves.put(message.name, pending);
}
// Add this resolve message to the list of waiting resolvers
pending.add(message);
}
else
{
// The location is not null. Send it to the resolver
// Log successful resolution
Node.log.log(this.getClass(), "Resolve request completed. " + message.name
+ " location being sent to "
+ message.location1.getNodeID());
// Create channel to the resolver
NetChannelOutput toPending = NetChannel.one2net(message.location1,
new CNSNetworkMessageFilter.FilterTX());
// Create the reply message
CNSMessage reply = new CNSMessage();
reply.type = CNSMessageProtocol.RESOLVE_REPLY;
reply.location1 = loc;
reply.success = true;
// Write the reply to the resolver asynchronously
toPending.asyncWrite(reply);
// Destroy the temporary channel
toPending.destroy();
}
}
}
catch (JCSPNetworkException jne)
{
// Something went wrong during the I/O. Ignore. Do not bring down the CNS
}
break;
}
}
}
}
}
}
/**
* Creates a new NetAltingChannelInput registered with the given name
*
* @param name
* The name to register with the CNS
* @deprecated Use net2one instead
* @return A new NetAltingChannelInput registered with the given name
* @throws IllegalStateException
* Thrown if the CNS has not been initialised
* @throws IllegalArgumentException
* Thrown if the channel name is already registered
*/
public static NetAltingChannelInput createNet2One(String name)
throws IllegalStateException, IllegalArgumentException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Create a new channel
NetAltingChannelInput toReturn = NetChannel.net2one();
// Attempt to register
if (CNS.service.register(name, toReturn))
return toReturn;
// Failed to register channel. Destroy the channel and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the CNS");
}
/**
* Creates a new NetSharedChannelInput registered with the given name
*
* @param name
* The name to register with the CNS
* @deprecated Use net2any instead
* @return A new NetSharedChannelInput registered with the given name
* @throws IllegalStateException
* Thrown if the CNS has not been initialised
* @throws IllegalArgumentException
* Thrown if the channel name is already registered
*/
public static NetSharedChannelInput createNet2Any(String name)
throws IllegalStateException, IllegalArgumentException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Create a new channel
NetSharedChannelInput toReturn = NetChannel.net2any();
// Attempt to register
if (CNS.service.register(name, toReturn))
return toReturn;
// Failed to register channel. Destroy the channel and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the CNS");
}
/**
* Creates a new NetChannelOutput connected to the input channel registered with the given name
*
* @param name
* The name to resolve
* @deprecated Use one2net instead
* @return A new NetChannelOutput connected to the input with the registered name
* @throws IllegalStateException
* Thrown if the connection to the CNS is not initialised
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput createOne2Net(String name)
throws IllegalStateException, JCSPNetworkException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Resolve the location of the channel
NetChannelLocation loc = CNS.service.resolve(name);
// Create and return a new channel
return NetChannel.one2net(loc);
}
/**
* Creates a new NetSharedChannelOutput connected to the input channel registered with the given name
*
* @param name
* The name to resolve
* @deprecated Use one2net instead
* @return A new NetChannelOutput connected to the input with the registered name
* @throws IllegalStateException
* Thrown if the connection to the CNS is not initialised
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput createAny2Net(String name)
throws JCSPNetworkException, IllegalStateException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Resolve the location of the channel
NetChannelLocation loc = CNS.service.resolve(name);
// Create and return a new channel
return NetChannel.any2net(loc);
}
/**
* Creates a new NetAltingChannelInput registered with the given name
*
* @param name
* The name to register with the CNS
* @return A new NetAltingChannelInput registered with the given name
* @throws IllegalStateException
* Thrown if the CNS has not been initialised
* @throws IllegalArgumentException
* Thrown if the channel name is already registered
*/
public static NetAltingChannelInput net2one(String name)
throws IllegalStateException, IllegalArgumentException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Create a new channel
NetAltingChannelInput toReturn = NetChannel.net2one();
// Attempt to register
if (CNS.service.register(name, toReturn))
return toReturn;
// Failed to register channel. Destroy the channel and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the CNS");
}
/**
* Creates a new NetAltingChannelInput registered with the given name
*
* @param name
* The name to register with the CNS
* @param immunityLevel
* The immunity to poison the channel has
* @return A new NetAltingChannelInput registered with the given name
* @throws IllegalStateException
* Thrown if the CNS has not been initialised
* @throws IllegalArgumentException
* Thrown if the channel name is already registered
*/
public static NetAltingChannelInput net2one(String name, int immunityLevel)
throws IllegalArgumentException, IllegalStateException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Create a new channel
NetAltingChannelInput toReturn = NetChannel.net2one(immunityLevel);
// Attempt to register
if (CNS.service.register(name, toReturn))
return toReturn;
// Failed to register channel. Destroy the channel and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the CNS");
}
/**
* Creates a new NetAltingChannelInput registered with the given name
*
* @param name
* The name to register with the CNS
* @param filter
* The filter used to decode incoming messages
* @return A new NetAltingChannelInput registered with the given name
* @throws IllegalStateException
* Thrown if the CNS has not been initialised
* @throws IllegalArgumentException
* Thrown if the channel name is already registered
*/
public static NetAltingChannelInput net2one(String name, NetworkMessageFilter.FilterRx filter)
throws IllegalArgumentException, IllegalStateException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Create a new channel
NetAltingChannelInput toReturn = NetChannel.net2one(filter);
// Attempt to register
if (CNS.service.register(name, toReturn))
return toReturn;
// Failed to register channel. Destroy the channel and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the CNS");
}
/**
* Creates a new NetAltingChannelInput registered with the given name
*
* @param name
* The name to register with the CNS
* @param immunityLevel
* The immunity level to poison that the channel has
* @param filter
* The filter used to decode incoming messages
* @return A new NetAltingChannelInput registered with the given name
* @throws IllegalStateException
* Thrown if the CNS has not been initialised
* @throws IllegalArgumentException
* Thrown if the channel name is already registered
*/
public static NetAltingChannelInput net2one(String name, int immunityLevel, NetworkMessageFilter.FilterRx filter)
throws IllegalArgumentException, IllegalStateException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Create a new channel
NetAltingChannelInput toReturn = NetChannel.net2one(immunityLevel, filter);
// Attempt to register
if (CNS.service.register(name, toReturn))
return toReturn;
// Failed to register channel. Destroy the channel and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the CNS");
}
/**
* Creates a new NetSharedChannelInput registered with the given name
*
* @param name
* The name to register with the CNS
* @return A new NetSharedChannelInput registered with the given name
* @throws IllegalStateException
* Thrown if the CNS has not been initialised
* @throws IllegalArgumentException
* Thrown if the channel name is already registered
*/
public static NetSharedChannelInput net2any(String name)
throws IllegalArgumentException, IllegalStateException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Create a new channel
NetSharedChannelInput toReturn = NetChannel.net2any();
// Attempt to register
if (CNS.service.register(name, toReturn))
return toReturn;
// Failed to register channel. Destroy the channel and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the CNS");
}
/**
* Creates a new NetSharedChannelInput registered with the given name
*
* @param name
* The name to register with the CNS
* @param immunityLevel
* The immunity level to poison that the channel has
* @return A new NetSharedChannelInput registered with the given name
* @throws IllegalStateException
* Thrown if the CNS has not been initialised
* @throws IllegalArgumentException
* Thrown if the channel name is already registered
*/
public static NetSharedChannelInput net2any(String name, int immunityLevel)
throws IllegalArgumentException, IllegalStateException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Create a new channel
NetSharedChannelInput toReturn = NetChannel.net2any(immunityLevel);
// Attempt to register
if (CNS.service.register(name, toReturn))
return toReturn;
// Failed to register channel. Destroy the channel and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the CNS");
}
/**
* Creates a new NetSharedChannelInput registered with the given name
*
* @param name
* The name to register with the CNS
* @param filter
* The filter used to decode incoming messages
* @return A new NetSharedChannelInput registered with the given name
* @throws IllegalStateException
* Thrown if the CNS has not been initialised
* @throws IllegalArgumentException
* Thrown if the channel name is already registered
*/
public static NetSharedChannelInput net2any(String name, NetworkMessageFilter.FilterRx filter)
throws IllegalArgumentException, IllegalStateException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Create a new channel
NetSharedChannelInput toReturn = NetChannel.net2any(filter);
// Attempt to register
if (CNS.service.register(name, toReturn))
return toReturn;
// Failed to register channel. Destroy the channel and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the CNS");
}
/**
* Creates a new NetSharedChannelInput registered with the given name
*
* @param name
* The name to register with the CNS
* @param immunityLevel
* The immunity to poison that this channel has
* @param filter
* The filter used to decode incoming messages
* @return A new NetSharedChannelInput registered with the given name
* @throws IllegalStateException
* Thrown if the CNS has not been initialised
* @throws IllegalArgumentException
* Thrown if the channel name is already registered
*/
public static NetSharedChannelInput net2any(String name, int immunityLevel, NetworkMessageFilter.FilterRx filter)
throws IllegalArgumentException, IllegalStateException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Create a new channel
NetSharedChannelInput toReturn = NetChannel.net2any(immunityLevel, filter);
// Attempt to register
if (CNS.service.register(name, toReturn))
return toReturn;
// Failed to register channel. Destroy the channel and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the CNS");
}
/**
* Creates a new NetAltingChannelInput registered with the given name
*
* @param name
* The name to register with the CNS
* @param index
* The index to create the channel with
* @return A new NetAltingChannelInput registered with the given name
* @throws IllegalStateException
* Thrown if the CNS has not been initialised
* @throws IllegalArgumentException
* Thrown if the channel name is already registered
*/
public static NetAltingChannelInput numberedNet2One(String name, int index)
throws IllegalStateException, IllegalArgumentException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Create a new channel
NetAltingChannelInput toReturn = NetChannel.numberedNet2One(index);
// Attempt to register
if (CNS.service.register(name, toReturn))
return toReturn;
// Failed to register channel. Destroy the channel and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the CNS");
}
/**
* Creates a new NetAltingChannelInput registered with the given name
*
* @param name
* The name to register with the CNS
* @param index
* The index to create the channel with
* @param immunityLevel
* The immunity level to poison that the channel has
* @return A new NetAltingChannelInput registered with the given name
* @throws IllegalStateException
* Thrown if the CNS has not been initialised
* @throws IllegalArgumentException
* Thrown if the channel name is already registered
*/
public static NetAltingChannelInput numberedNet2One(String name, int index, int immunityLevel)
throws IllegalStateException, IllegalArgumentException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Create a new channel
NetAltingChannelInput toReturn = NetChannel.numberedNet2One(index, immunityLevel);
// Attempt to register
if (CNS.service.register(name, toReturn))
return toReturn;
// Failed to register channel. Destroy the channel and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the CNS");
}
/**
* Creates a new NetAltingChannelInput registered with the given name
*
* @param name
* The name to register with the CNS
* @param index
* The index to create the channel with
* @param filter
* The filter used to decode incoming messages
* @return A new NetAltingChannelInput registered with the given name
* @throws IllegalStateException
* Thrown if the CNS has not been initialised
* @throws IllegalArgumentException
* Thrown if the channel name is already registered
*/
public static NetAltingChannelInput numberedNet2One(String name, int index, NetworkMessageFilter.FilterRx filter)
throws IllegalStateException, IllegalArgumentException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Create a new channel
NetAltingChannelInput toReturn = NetChannel.numberedNet2One(index, filter);
// Attempt to register
if (CNS.service.register(name, toReturn))
return toReturn;
// Failed to register channel. Destroy the channel and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the CNS");
}
/**
* Creates a new NetAltingChannelInput registered with the given name
*
* @param name
* The name to register with the CNS
* @param index
* The index to create the channel with
* @param immunityLevel
* The immunity level to poison that the channel has
* @param filter
* The filter used to decode incoming messages
* @return A new NetAltingChannelInput registered with the given name
* @throws IllegalStateException
* Thrown if the CNS has not been initialised
* @throws IllegalArgumentException
* Thrown if the channel name is already registered
*/
public static NetAltingChannelInput numberedNet2One(String name, int index, int immunityLevel,
NetworkMessageFilter.FilterRx filter)
throws IllegalStateException, IllegalArgumentException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Create a new channel
NetAltingChannelInput toReturn = NetChannel.numberedNet2One(index, immunityLevel, filter);
// Attempt to register
if (CNS.service.register(name, toReturn))
return toReturn;
// Failed to register channel. Destroy the channel and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the CNS");
}
/**
* Creates a new NetSharedChannelInput registered with the given name
*
* @param name
* The name to register with the CNS
* @param index
* The index to create the channel with
* @return A new NetSharedChannelInput registered with the given name
* @throws IllegalStateException
* Thrown if the CNS has not been initialised
* @throws IllegalArgumentException
* Thrown if the channel name is already registered
*/
public static NetSharedChannelInput numberedNet2Any(String name, int index)
throws IllegalStateException, IllegalArgumentException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Create a new channel
NetSharedChannelInput toReturn = NetChannel.numberedNet2Any(index);
// Attempt to register
if (CNS.service.register(name, toReturn))
return toReturn;
// Failed to register channel. Destroy the channel and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the CNS");
}
/**
* Creates a new NetSharedChannelInput registered with the given name
*
* @param name
* The name to register with the CNS
* @param index
* The index to create the channel with
* @param immunityLevel
* The immunity to poison that this channel has
* @return A new NetSharedChannelInput registered with the given name
* @throws IllegalStateException
* Thrown if the CNS has not been initialised
* @throws IllegalArgumentException
* Thrown if the channel name is already registered
*/
public static NetSharedChannelInput numberedNet2Any(String name, int index, int immunityLevel)
throws IllegalStateException, IllegalArgumentException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Create a new channel
NetSharedChannelInput toReturn = NetChannel.numberedNet2Any(index, immunityLevel);
// Attempt to register
if (CNS.service.register(name, toReturn))
return toReturn;
// Failed to register channel. Destroy the channel and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the CNS");
}
/**
* Creates a new NetSharedChannelInput registered with the given name
*
* @param name
* The name to register with the CNS
* @param index
* The index to create the channel with
* @param filter
* The filter used to decode incoming messages
* @return A new NetSharedChannelInput registered with the given name
* @throws IllegalStateException
* Thrown if the CNS has not been initialised
* @throws IllegalArgumentException
* Thrown if the channel name is already registered
*/
public static NetSharedChannelInput numberedNet2Any(String name, int index, NetworkMessageFilter.FilterRx filter)
throws IllegalStateException, IllegalArgumentException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Create a new channel
NetSharedChannelInput toReturn = NetChannel.numberedNet2Any(index, filter);
// Attempt to register
if (CNS.service.register(name, toReturn))
return toReturn;
// Failed to register channel. Destroy the channel and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the CNS");
}
/**
* Creates a new NetSharedChannelInput registered with the given name
*
* @param name
* The name to register with the CNS
* @param index
* The index to create the channel with
* @param immunityLevel
* The immunity to poison that this channel has
* @param filter
* The filter used to decode incoming messages
* @return A new NetSharedChannelInput registered with the given name
* @throws IllegalStateException
* Thrown if the CNS has not been initialised
* @throws IllegalArgumentException
* Thrown if the channel name is already registered
*/
public static NetSharedChannelInput numberedNet2Any(String name, int index, int immunityLevel,
NetworkMessageFilter.FilterRx filter)
throws IllegalStateException, IllegalArgumentException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Create a new channel
NetSharedChannelInput toReturn = NetChannel.numberedNet2Any(index, immunityLevel, filter);
// Attempt to register
if (CNS.service.register(name, toReturn))
return toReturn;
// Failed to register channel. Destroy the channel and throw exception
toReturn.destroy();
throw new IllegalArgumentException("Failed to register " + name + " with the CNS");
}
/**
* Creates a new NetChannelOutput connected to the input channel registered with the given name
*
* @param name
* The name to resolve
* @return A new NetChannelOutput connected to the input with the registered name
* @throws IllegalStateException
* Thrown if the connection to the CNS is not initialised
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(String name)
throws IllegalStateException, JCSPNetworkException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Resolve the location of the channel
NetChannelLocation loc = CNS.service.resolve(name);
// Create and return a new channel
return NetChannel.one2net(loc);
}
/**
* Creates a new NetChannelOutput connected to the input channel registered with the given name
*
* @param name
* The name to resolve
* @param immunityLevel
* The immunity to poison that this channel has
* @return A new NetChannelOutput connected to the input with the registered name
* @throws IllegalStateException
* Thrown if the connection to the CNS is not initialised
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(String name, int immunityLevel)
throws IllegalStateException, JCSPNetworkException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Resolve the location of the channel
NetChannelLocation loc = CNS.service.resolve(name);
// Create and return a new channel
return NetChannel.one2net(loc, immunityLevel);
}
/**
* Creates a new NetChannelOutput connected to the input channel registered with the given name
*
* @param name
* The name to resolve
* @param filter
* The filter used to encode outgoing messages
* @return A new NetChannelOutput connected to the input with the registered name
* @throws IllegalStateException
* Thrown if the connection to the CNS is not initialised
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(String name, NetworkMessageFilter.FilterTx filter)
throws IllegalStateException, JCSPNetworkException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Resolve the location of the channel
NetChannelLocation loc = CNS.service.resolve(name);
// Create and return a new channel
return NetChannel.one2net(loc, filter);
}
/**
* Creates a new NetChannelOutput connected to the input channel registered with the given name
*
* @param name
* The name to resolve
* @param immunityLevel
* The immunity to poison that this channel has
* @param filter
* The filter used to encode outgoing messages
* @return A new NetChannelOutput connected to the input with the registered name
* @throws IllegalStateException
* Thrown if the connection to the CNS is not initialised
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(String name, int immunityLevel, NetworkMessageFilter.FilterTx filter)
throws IllegalStateException, JCSPNetworkException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Resolve the location of the channel
NetChannelLocation loc = CNS.service.resolve(name);
// Create and return a new channel
return NetChannel.one2net(loc, immunityLevel, filter);
}
/**
* Creates a new NetSharedChannelOutput connected to the input channel registered with the given name
*
* @param name
* The name to resolve
* @return A new NetSharedChannelOutput connected to the input with the registered name
* @throws IllegalStateException
* Thrown if the connection to the CNS is not initialised
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(String name)
throws IllegalStateException, JCSPNetworkException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Resolve the location of the channel
NetChannelLocation loc = CNS.service.resolve(name);
// Create and return a new channel
return NetChannel.any2net(loc);
}
/**
* Creates a new NetSharedChannelOutput connected to the input channel registered with the given name
*
* @param name
* The name to resolve
* @param immunityLevel
* The immunity to poison that this channel has
* @return A new NetSharedChannelOutput connected to the input with the registered name
* @throws IllegalStateException
* Thrown if the connection to the CNS is not initialised
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(String name, int immunityLevel)
throws IllegalStateException, JCSPNetworkException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Resolve the location of the channel
NetChannelLocation loc = CNS.service.resolve(name);
// Create and return a new channel
return NetChannel.any2net(loc, immunityLevel);
}
/**
* Creates a new NetSharedChannelOutput connected to the input channel registered with the given name
*
* @param name
* The name to resolve
* @param filter
* The filter used to encode outgoing messages
* @return A new NetSharedChannelOutput connected to the input with the registered name
* @throws IllegalStateException
* Thrown if the connection to the CNS is not initialised
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(String name, NetworkMessageFilter.FilterTx filter)
throws IllegalStateException, JCSPNetworkException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Resolve the location of the channel
NetChannelLocation loc = CNS.service.resolve(name);
// Create and return a new channel
return NetChannel.any2net(loc, filter);
}
/**
* Creates a new NetSharedChannelOutput connected to the input channel registered with the given name
*
* @param name
* The name to resolve
* @param immunityLevel
* The immunity level to poison that this channel has
* @param filter
* The filter used to encode outgoing messages
* @return A new NetSharedChannelOutput connected to the input with the registered name
* @throws IllegalStateException
* Thrown if the connection to the CNS is not initialised
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(String name, int immunityLevel, NetworkMessageFilter.FilterTx filter)
throws IllegalStateException, JCSPNetworkException
{
// Check if the CNS connection is initialised
if (!CNS.initialised)
throw new IllegalStateException("The connection to the CNS has not been initialised");
// Resolve the location of the channel
NetChannelLocation loc = CNS.service.resolve(name);
// Create and return a new channel
return NetChannel.any2net(loc, filter);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/net2/NodeAddress.java 0000644 0000000 0000000 00000012032 11072626250 017047 0 ustar package org.jcsp.net2;
import java.io.Serializable;
import java.util.Hashtable;
/**
* This abstract class defines encapsulates the address of a Node within a JCSP networked system. Specific protocols
* must provide concrete implementations of this class to allow Node initialisation and connection. One concrete example
* is provided in the org.jcsp.net2.tcpip package.
*
* @see Node
* @author Kevin Chalmers (updated from Quickstone Technologies)
*/
public abstract class NodeAddress
implements Serializable, Comparable
{
/**
* String representing the protocol in used
*/
protected String protocol;
/**
* String representation of the address
*/
protected String address;
/**
* The table of installed protocols on this Node
*/
private static Hashtable installedProtocols = new Hashtable();
/**
* Gets the string representing the protocol
*
* @return The String representation of the protocol part of the NodeAddress
*/
public String getProtocol()
{
return this.protocol;
}
/**
* Gets a string representing the address
*
* @return The String representation of the address part of the NodeAddress
*/
public String getAddress()
{
return this.address;
}
/**
* Converts the NodeAddress into a String. The form is [protocol]\\[address]
*
* @return A String representation of this NodeAddress
*/
public String toString()
{
return this.protocol + "\\\\" + this.address;
}
/**
* Gets the hash code of this object
*
* @return Hashcode for this NodeAddress
*/
public int hashCode()
{
return this.address.hashCode();
}
/**
* Checks if this NodeAddress is equal to another
*
* @param obj
* The NodeAddress to compare to
* @return True if object is equal to this NodeAddress, false otherwise
*/
public boolean equals(final Object obj)
{
if (!(obj instanceof NodeAddress))
return false;
NodeAddress other = (NodeAddress)obj;
return (this.protocol.equals(other.protocol) && this.address.equals(other.address));
}
/**
* Compares this NodeAddress to another
*
* @param arg0
* The NodeAddress to compare to
* @return 1 if object is greater than this one, 0 if they are equal, -1 otherwise
*/
public int compareTo(final Object arg0)
{
if (!(arg0 instanceof NodeAddress))
return -1;
NodeAddress other = (NodeAddress)arg0;
if (!this.protocol.equals(other.protocol))
return this.protocol.compareTo(other.protocol);
return this.address.compareTo(other.address);
}
/**
* Creates a Link connected to this address
*
* @return A new Link connected to this address
* @throws JCSPNetworkException
* If something goes wrong during the creation of the Link
*/
protected abstract Link createLink()
throws JCSPNetworkException;
/**
* Creates a LinkServer listening on this address
*
* @return A new LinkServer listening on this address
* @throws JCSPNetworkException
* If something goes wrong during the creation of the LinkServer
*/
protected abstract LinkServer createLinkServer()
throws JCSPNetworkException;
/**
* Retrieves the correct protocol handler for the implemented address type. This is used during Node initialisation
*
* @return the ProtocolID for this address type
*/
protected abstract ProtocolID getProtocolID();
/**
* Parses a string representation of a NodeAddress back to its object form
*
* @param str
* The string to parse
* @return A new NodeAddress created from a String form
* @throws IllegalArgumentException
* Thrown if the string is not for a recognised protocol.
*/
public static NodeAddress parse(String str)
throws IllegalArgumentException
{
int index = str.indexOf("\\\\");
ProtocolID protocol = (ProtocolID)NodeAddress.installedProtocols.get(str.substring(0, index));
if (protocol != null)
{
return protocol.parse(str.substring(index+4));
}
throw new IllegalArgumentException("Unknown protocol used for parsing NodeAddress");
}
/**
* Installs a new Protocol on the Node
*
* @param name
* Name of the protocol to install
* @param protocol
* ProtocolID installed
*/
public synchronized static void installProtocol(String name, ProtocolID protocol)
{
if (!NodeAddress.installedProtocols.containsKey(name))
NodeAddress.installedProtocols.put(name, protocol);
// If the protocol is already installed, we do nothing.
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/net2/BarrierDataState.java 0000644 0000000 0000000 00000001754 11072626250 020046 0 ustar package org.jcsp.net2;
/**
* Describes the possible states that a networked Barrier might be in.
*
* @author Kevin Chalmers
*/
final class BarrierDataState
{
/**
* Empty private constructor. This is simply a protocol.
*/
private BarrierDataState()
{
// Empty constructor
}
/**
* Barrier is inactive. It has not been initialised yet.
*/
static final byte INACTIVE = 0;
/**
* Barrier is in OK state, and is a server end. Has been initialised.
*/
static final byte OK_SERVER = 1;
/**
* Barrier is in OK state, and is a client end. Has been initialised
*/
static final byte OK_CLIENT = 2;
/**
* Barrier is broken.
*/
static final byte BROKEN = 3;
/**
* Barrier has been destroyed
*/
static final byte DESTROYED = 4;
/**
* Barrier has resigned from the server front end.
*/
static final byte RESIGNED = 5;
}
jcsp-1.1-rc4.orig/src/org/jcsp/net2/NetAltingConnectionServer.java 0000644 0000000 0000000 00000006732 11072626250 021762 0 ustar package org.jcsp.net2;
import org.jcsp.lang.AltingChannelInput;
import org.jcsp.lang.AltingConnectionServer;
import org.jcsp.lang.Any2OneChannel;
import org.jcsp.lang.Channel;
import org.jcsp.util.InfiniteBuffer;
public final class NetAltingConnectionServer
extends AltingConnectionServer
implements NetConnectionServer
{
private final AltingChannelInput requestIn;
private final AltingChannelInput openIn;
private final NetConnectionLocation location;
private final NetworkMessageFilter.FilterRx inputFilter;
private final NetworkMessageFilter.FilterTx outputFilter;
private final ConnectionData data;
private final NetworkMessage lastRead = null;
private final Link linkConnectedTo = null;
static NetAltingConnectionServer create(int index, NetworkMessageFilter.FilterRx filterRX,
NetworkMessageFilter.FilterTx filterTX)
throws IllegalArgumentException
{
ConnectionData data = new ConnectionData();
Any2OneChannel requestChan = Channel.any2one(new InfiniteBuffer());
Any2OneChannel openChan = Channel.any2one(new InfiniteBuffer());
data.toConnection = requestChan.out();
data.openServer = openChan.out();
data.state = ConnectionDataState.SERVER_STATE_CLOSED;
ConnectionManager.getInstance().create(index, data);
return new NetAltingConnectionServer(openChan.in(), requestChan.in(), data, filterRX, filterTX);
}
static NetAltingConnectionServer create(NetworkMessageFilter.FilterRx filterRX,
NetworkMessageFilter.FilterTx filterTX)
{
ConnectionData data = new ConnectionData();
Any2OneChannel requestChan = Channel.any2one(new InfiniteBuffer());
Any2OneChannel openChan = Channel.any2one(new InfiniteBuffer());
data.toConnection = requestChan.out();
data.openServer = openChan.out();
data.state = ConnectionDataState.SERVER_STATE_CLOSED;
ConnectionManager.getInstance().create(data);
return new NetAltingConnectionServer(openChan.in(), requestChan.in(), data, filterRX, filterTX);
}
private NetAltingConnectionServer(AltingChannelInput openChan, AltingChannelInput requestChan,
ConnectionData connData, NetworkMessageFilter.FilterRx filterRX, NetworkMessageFilter.FilterTx filterTX)
throws JCSPNetworkException
{
super(openChan);
this.openIn = openChan;
this.requestIn = requestChan;
this.data = connData;
this.inputFilter = filterRX;
this.outputFilter = filterTX;
this.location = new NetConnectionLocation(Node.getInstance().getNodeID(), this.data.vconnn);
}
public void destroy()
{
// TODO Auto-generated method stub
}
public NetLocation getLocation()
{
// TODO Auto-generated method stub
return null;
}
public void reply(Object data, boolean close)
throws IllegalStateException
{
// TODO Auto-generated method stub
}
public void reply(Object data)
throws IllegalStateException
{
// TODO Auto-generated method stub
}
public void replyAndClose(Object data)
throws IllegalStateException
{
// TODO Auto-generated method stub
}
public Object request()
throws IllegalStateException
{
// TODO Auto-generated method stub
return null;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/net2/Net2OneChannel.java 0000644 0000000 0000000 00000066005 11072626250 017430 0 ustar package org.jcsp.net2;
import java.io.IOException;
import org.jcsp.lang.AltingChannelInput;
import org.jcsp.lang.Any2OneChannel;
import org.jcsp.lang.Channel;
import org.jcsp.net2.NetworkMessageFilter.FilterRx;
import org.jcsp.util.InfiniteBuffer;
/**
* A concrete implementation of a NetAltingChannelInput. This is a hidden class created by the architecture. To create
* an instance of this object, use the NetChannel factory, or the CNS.
*
* @see NetChannelInput
* @see NetAltingChannelInput
* @see NetChannel
* @author Kevin Chalmers (updated from Quickstone Technologies)
*/
final class Net2OneChannel
extends NetAltingChannelInput
{
/**
* The input channel coming into the networked channel input object from Links or locally connected net channel
* outputs.
*/
private final AltingChannelInput in;
/**
* The ChannelData structure representing this channel.
*/
private final ChannelData data;
/**
* The lastRead ChannelMessage. Used during an extended read operation to allow the ACK message to be sent to the
* correct Node.
*/
private NetworkMessage lastRead = null;
/**
* The filter used to convert the incoming byte array into an object
*/
private NetworkMessageFilter.FilterRx messageFilter;
/**
* The location of this channel
*/
private final NetChannelLocation location;
/**
* Static factory method used to create a new Net2OneChannel. Used internally within the architecture.
*
* @param poisonImmunity
* The immunity level of the channel
* @param filter
* The filter on the channel used to convert read bytes into an object
* @return A new Net2OneChannel
*/
static Net2OneChannel create(int poisonImmunity, NetworkMessageFilter.FilterRx filter)
{
// Create a new ChannelData object
ChannelData data = new ChannelData();
// Create a new infinitely buffered any2one channel connecting the Links to the channel object
Any2OneChannel chan = Channel.any2one(new InfiniteBuffer());
// Add the output end to the ChannelData object
data.toChannel = chan.out();
// Set the immunity level
data.immunityLevel = poisonImmunity;
// Initialise the ChannelData object with the ChannelManager
ChannelManager.getInstance().create(data);
// Return a new Net2OneChannel
return new Net2OneChannel(chan.in(), data, filter);
}
/**
* Static factory method used to create a new Net2OneChannel with a given index. Used internally within the
* architecture
*
* @param index
* The index to create the channel with
* @param poisonImmunity
* The immunity level of the channel
* @param filter
* The filter used to take the incoming byte array and convert it into an object
* @return A new Net2OneChannel
* @throws IllegalArgumentException
* Thrown if the index given is already allocated within the ChannelManager
*/
static Net2OneChannel create(int index, int poisonImmunity, NetworkMessageFilter.FilterRx filter)
throws IllegalArgumentException
{
// Create a new ChannelData object
ChannelData data = new ChannelData();
// Create a new infinitely buffered any2one channel connecting the Links to the channel object
Any2OneChannel chan = Channel.any2one(new InfiniteBuffer());
// Add the output end to the ChannelData object
data.toChannel = chan.out();
// Set the immunity level
data.immunityLevel = poisonImmunity;
// Initialise the ChannelData object with the ChannelManager. Use the index given
ChannelManager.getInstance().create(index, data);
// Return a new Net2OneChannel
return new Net2OneChannel(chan.in(), data, filter);
}
/**
* Private constructor for creating a new instance of a Net2OneChannel. This is called by the create method to
* create the channel.
*
* @param input
* The input channel connecting to the networked channel.
* @param chanData
* The ChannelData object representing the networked channel.
* @param filter
* The filter used to convert the incoming byte array to an object
* @throws JCSPNetworkException
*/
private Net2OneChannel(AltingChannelInput input, ChannelData chanData, NetworkMessageFilter.FilterRx filter)
throws JCSPNetworkException
{
// Set the wrapper's alting channel input so the channel can be used as a guard
super(input);
// Set the various properties
this.in = input;
this.data = chanData;
this.data.state = ChannelDataState.OK_INPUT;
this.location = new NetChannelLocation(Node.getInstance().getNodeID(), this.data.vcn);
this.messageFilter = filter;
}
/**
* Ends an extended read operation.
*
* @throws IllegalStateException
* Thrown if the method is called when the channel is not in an extended read state
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
* @throws NetworkPoisonException
* Thrown if the channel has been poisoned
*/
public void endRead()
throws IllegalStateException, JCSPNetworkException, NetworkPoisonException
{
// First check the state of the channel. These are sanity checks. Really, if the channel is in an extended
// read state then it should not be destroyed or poisoned
if (this.data.state == ChannelDataState.DESTROYED)
throw new JCSPNetworkException("The channel has been destroyed");
if (this.data.state == ChannelDataState.POISONED)
throw new NetworkPoisonException(this.data.poisonLevel);
// Now check if a extended read is in progress
if (this.lastRead != null)
{
// We are performing an extended read. Now check if we should be actually sending a reply
if (this.lastRead.type != NetworkProtocol.ASYNC_SEND)
{
// The last message wasn't an asynchronous send, therefore we need to send the ACK
// Create ACK message
NetworkMessage ack = new NetworkMessage();
ack.type = NetworkProtocol.ACK;
// Destination is source of lastRead
ack.attr1 = this.lastRead.attr2;
// Attribute 2 is not used
ack.attr2 = -1;
// Write the acknowledgement back to the sender
this.lastRead.toLink.write(ack);
}
// Set the lastRead to null. End of extended read operation
this.lastRead = null;
}
else
{
// We are not performing an extended read. This is a problem. Thrown an exception
throw new IllegalStateException("End read was called on a channel not in an extended read state");
}
}
/**
* Checks if any data is waiting on the channel.
*
* @return True if data is ready, false otherwise.
* @throws JCSPNetworkException
* Thrown if the channel has been destroyed
* @throws NetworkPoisonException
* Thrown if the channel has poisoned
*/
public boolean pending()
throws JCSPNetworkException, NetworkPoisonException
{
// First check the state of the channel.
if (this.data.state == ChannelDataState.DESTROYED)
throw new JCSPNetworkException("The channel has been destroyed");
if (this.data.state == ChannelDataState.POISONED)
throw new NetworkPoisonException(this.data.poisonLevel);
// Return if the channel has any pending messages
return this.in.pending();
}
/**
* Poisons the underlying channel
*
* @param strength
* The strength of the poison
*/
public void poison(int strength)
{
// First check the state of the channel
if (this.data.state == ChannelDataState.DESTROYED)
// In this case we do nothing. Destroyed is considered stronger than poisoned
return;
// Now check if the strength of the poison is greater than a previous poison
if (strength > this.data.poisonLevel)
{
// Change the current poison level
this.data.poisonLevel = strength;
// Now check if the poison level is strong enough to poison us.
if (strength > this.data.immunityLevel)
{
// The poison is strong enough. We need to change our state to poisoned.
// We need to lock on the state to ensure no link is using it as we change it
synchronized (this.data)
{
// Now change our state
this.data.state = ChannelDataState.POISONED;
}
// Are we extended? If so send poison back there first
if (this.lastRead != null)
{
// We are extended. Send poison as an acknowledgement
NetworkMessage poison = new NetworkMessage();
poison.type = NetworkProtocol.POISON;
poison.attr1 = this.lastRead.attr2;
poison.attr2 = this.data.poisonLevel;
this.lastRead.toLink.write(poison);
this.lastRead = null;
}
// Now we must send POISON to any waiting SEND messages
while (this.in.pending())
{
// We have an incoming message. Read the message.
NetworkMessage pending = (NetworkMessage)this.in.read();
switch (pending.type)
{
// We have three possible outcomes. Either the message is a send of some sort, another poison,
// or neither of these (which should not be really possible)
// We must reply to sends with a POISON
case NetworkProtocol.SEND:
case NetworkProtocol.ASYNC_SEND:
// Create a new POISON message
NetworkMessage poison = new NetworkMessage();
poison.type = NetworkProtocol.POISON;
// Destination is the source of the previous message
poison.attr1 = pending.attr2;
// Attribute 2 is the poison level
poison.attr2 = this.data.poisonLevel;
// Write poison message to the channel attached to pending message
pending.toLink.write(poison);
break;
case NetworkProtocol.POISON:
// We have received another poison message. We now check if it is stronger than the previous
// poison.
if (pending.attr2 > this.data.poisonLevel)
{
// We have stronger poison. Increase the poison level
this.data.poisonLevel = pending.attr2;
}
// Poison is not greater than the previous poison. Do nothing.
break;
default:
// In any other case, we do nothing.
break;
}
}
}
// Poison is not above our immunity level. Do nothing.
}
// Strength of the poison is not above our previous poison level. Do nothing.
}
/**
* Reads the next message from the channel
*
* @return The message read from the channel
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
* @throws NetworkPoisonException
* Thrown if the channel is poisoned
* @throws IllegalStateException
* Thrown if the channel is in an extended read state
*/
public Object read()
throws JCSPNetworkException, NetworkPoisonException, IllegalStateException
{
// First check our state
if (this.data.state == ChannelDataState.DESTROYED)
throw new JCSPNetworkException("Channel has been destroyed");
if (this.data.state == ChannelDataState.POISONED)
throw new NetworkPoisonException(this.data.poisonLevel);
// Now check if we are in an extended read state
if (this.lastRead != null)
{
// We are in an extended read. Throw exception
throw new IllegalStateException("The channel is in an extended read state");
}
// We are in an OK state to perform a read.
// We need to loop until we return a message, or throw an exception
while (true)
{
// Read in the next message
NetworkMessage msg = (NetworkMessage)this.in.read();
// Now we need to decode the message and act accordingly
try
{
switch (msg.type)
{
// We can either receive a SEND, ASYNC_SEND, or POISON message
case NetworkProtocol.SEND:
{
// We have received a SEND
// Convert the message into the object again. This may throw an IOException
Object toReturn = this.messageFilter.filterRX(msg.data);
// We have a SEND, we need to acknowledge.
// Create an ACK message
NetworkMessage ack = new NetworkMessage();
ack.type = NetworkProtocol.ACK;
// Destination is source of the previous message
ack.attr1 = msg.attr2;
// Attribute 2 is unused
ack.attr2 = -1;
// Write ACK to the channel attached to the message
msg.toLink.write(ack);
// Return read object
return toReturn;
}
case NetworkProtocol.ASYNC_SEND:
{
// We have received an ASYNC_SEND
// Convert the message into the object again. This may throw an IOException
Object toReturn = this.messageFilter.filterRX(msg.data);
// Return read object
return toReturn;
}
case NetworkProtocol.POISON:
// First we change our poison level. Poison level is Attribute 2 of the message
this.data.poisonLevel = msg.attr2;
// The Link checked our immunity level, so this poison message must be greater than our immunity
// We need to lock on the state to ensure no link is using it as we change it
synchronized (this.data)
{
// Now change our state
this.data.state = ChannelDataState.POISONED;
}
// Now we must send POISON to any waiting SEND messages
while (this.in.pending())
{
// We have an incoming message. Read the message.
NetworkMessage pending = (NetworkMessage)this.in.read();
switch (pending.type)
{
// We have three possible outcomes. Either the message is a send of some sort, another
// poison, or neither of these (which should not be really possible)
// We must reply to sends with a POISON
case NetworkProtocol.SEND:
case NetworkProtocol.ASYNC_SEND:
// Create a new POISON message
NetworkMessage poison = new NetworkMessage();
poison.type = NetworkProtocol.POISON;
// Destination is the source of the previous message
poison.attr1 = pending.attr2;
// Attribute 2 is the poison level
poison.attr2 = this.data.poisonLevel;
// Write poison message to the channel attached to pending message
pending.toLink.write(poison);
break;
case NetworkProtocol.POISON:
// We have received another poison message. We now check if it is stronger than the
// previous poison.
if (pending.attr2 > this.data.poisonLevel)
{
// We have stronger poison. Increase the poison level
this.data.poisonLevel = pending.attr2;
}
// Poison is not greater than the previous poison. Do nothing.
break;
default:
// In any other case, we do nothing.
break;
}
}
// We now throw the poison exception
throw new NetworkPoisonException(this.data.poisonLevel);
}
}
// The filter may have thrown an IOException. Deal with it here and throw a JCSPNetworkException instead
catch (IOException ioe)
{
throw new JCSPNetworkException("Incoming message was corrupted");
}
}
}
/**
* Performs an extended read operation on the channel
*
* @return The message read from the channel
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
* @throws IllegalStateException
* Thrown if the channel is already in an extended read state
* @throws NetworkPoisonException
* Thrown if the channel is poisoned.
*/
public Object startRead()
throws JCSPNetworkException, IllegalStateException, NetworkPoisonException
{
// First check our state
if (this.data.state == ChannelDataState.DESTROYED)
throw new JCSPNetworkException("Channel has been destroyed");
if (this.data.state == ChannelDataState.POISONED)
throw new NetworkPoisonException(this.data.poisonLevel);
// Now check if we are in an extended read state
if (this.lastRead != null)
{
// We are in an extended read. Throw exception
throw new IllegalStateException("The channel is in an extended read state");
}
// We are in an OK state to perform a read.
// We need to loop until we return a message, or throw an exception
while (true)
{
// Read in the next message
NetworkMessage msg = (NetworkMessage)this.in.read();
// Now we need to decode the message and act accordingly
try
{
switch (msg.type)
{
// We can either receive a SEND, ASYNC_SEND, or POISON message
case NetworkProtocol.SEND:
case NetworkProtocol.ASYNC_SEND:
{
// We have received a SEND or ASYNC_SEND
// Convert the message into the object again. This may throw an IOException
Object toReturn = this.messageFilter.filterRX(msg.data);
// Now set the lastRead to the incoming message so we can acknowledge during the endRead
// operation
this.lastRead = msg;
return toReturn;
}
case NetworkProtocol.POISON:
// First we change our poison level. Poison level is Attribute 2 of the message
this.data.poisonLevel = msg.attr2;
// The Link checked our immunity level, so this poison message must be greater than our immunity
// We need to lock on the state to ensure no link is using it as we change it
synchronized (this.data)
{
// Now change our state
this.data.state = ChannelDataState.POISONED;
}
// Now we must send POISON to any waiting SEND messages
while (this.in.pending())
{
// We have an incoming message. Read the message.
NetworkMessage pending = (NetworkMessage)this.in.read();
switch (pending.type)
{
// We have three possible outcomes. Either the message is a send of some sort, another
// poison, or neither of these (which should not be really possible)
// We must reply to sends with a POISON
case NetworkProtocol.SEND:
case NetworkProtocol.ASYNC_SEND:
// Create a new POISON message
NetworkMessage poison = new NetworkMessage();
poison.type = NetworkProtocol.POISON;
// Destination is the source of the previous message
poison.attr1 = pending.attr2;
// Attribute 2 is the poison level
poison.attr2 = this.data.poisonLevel;
// Write poison message to the channel attached to pending message
pending.toLink.write(poison);
break;
case NetworkProtocol.POISON:
// We have received another poison message. We now check if it is stronger than the
// previous poison.
if (pending.attr2 > this.data.poisonLevel)
{
// We have stronger poison. Increase the poison level
this.data.poisonLevel = pending.attr2;
}
// Poison is not greater than the previous poison. Do nothing.
break;
default:
// In any other case, we do nothing.
break;
}
}
// We now throw the poison exception
throw new NetworkPoisonException(this.data.poisonLevel);
}
}
// The filter may have thrown an IOException. Deal with it here and throw a JCSPNetworkException instead
catch (IOException ioe)
{
throw new JCSPNetworkException("Incoming message was corrupted");
}
}
}
/**
* Returns the NetChannelLocation of the channel
*
* @return Location of this channel
*/
public NetLocation getLocation()
{
return this.location;
}
/**
* Destroys the underlying channel
*/
public void destroy()
{
// First acquire a lock on the channel
synchronized (this.data)
{
// Now we can change our state
this.data.state = ChannelDataState.DESTROYED;
}
// Remove the channel from the ChannelManager
ChannelManager.getInstance().removeChannel(this.data);
// Check if we are in an extended read. If so we need to reject the last message
if (this.lastRead != null)
{
// We are extended. Send a reject to the pending message
NetworkMessage reject = new NetworkMessage();
reject.type = NetworkProtocol.REJECT_CHANNEL;
reject.attr1 = this.lastRead.attr2;
reject.attr2 = -1;
this.lastRead.toLink.write(reject);
this.lastRead = null;
}
// Now we must reject any incoming messages, except poison
while (this.in.pending())
{
// We have a pending message. Deal with it.
NetworkMessage msg = (NetworkMessage)this.in.read();
// Check that it is not a poison
if (msg.type != NetworkProtocol.POISON)
{
// The message is not a poison message, and therefore must be a send or some type. Reject the message
// Create REJECT_CHANNEL message
NetworkMessage reject = new NetworkMessage();
reject.type = NetworkProtocol.REJECT_CHANNEL;
// Destination is the source of the incoming message
reject.attr1 = msg.attr2;
// Attribute 2 is not used
reject.attr2 = -1;
// Write reject to the channel attached to the incoming message
msg.toLink.write(reject);
}
}
}
/**
* Gets the channel data object for this channel.
*
* @return The ChannelData for this Channel
*/
final ChannelData getChannelData()
{
return this.data;
}
/**
* Sets the underlying message filter
*
* @param decoder
* The message filter to use
*/
public void setDecoder(FilterRx decoder)
{
this.messageFilter = decoder;
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/net2/RawNetworkMessageFilter.java 0000644 0000000 0000000 00000003531 11072626250 021436 0 ustar package org.jcsp.net2;
import java.io.IOException;
/**
* A NetworkMessageFilter used to send and receive raw byte data.
*
* @see NetworkMessageFilter
* @author Kevin Chalmers
*/
public final class RawNetworkMessageFilter
{
/**
* The receiving filter
*
* @author Kevin Chalmers
*/
public static final class FilterRX
implements NetworkMessageFilter.FilterRx
{
/**
* Creates a new RawNetworkMessageFilter.FilterRX
*/
public FilterRX()
{
// Nothing to do
}
/**
* Decodes an incoming byte array. Does nothing
*
* @param bytes
* The bytes received in an incoming message
* @return The same bytes as is passed in
*/
public Object filterRX(byte[] bytes)
{
return bytes;
}
}
/**
* The sending Filter
*
* @author Kevin Chalmers
*/
public static final class FilterTX
implements NetworkMessageFilter.FilterTx
{
/**
* Creates a new output filter
*/
public FilterTX()
{
// Nothing to do
}
/**
* Will send a byte array as raw bytes
*
* @param obj
* The object to send. This must be a byte array
* @return The same byte array as sent in
* @throws IOException
* Thrown if the sent object is not a byte array
*/
public byte[] filterTX(Object obj)
throws IOException
{
if (!(obj instanceof byte[]))
throw new IOException("Raw data filter received an object that was not a byte[]");
return (byte[])obj;
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/net2/ChannelManager.java 0000644 0000000 0000000 00000007275 11072626250 017534 0 ustar package org.jcsp.net2;
import java.util.Hashtable;
/**
* A class used to manage the networked channels on the Node. This is an internal object to JCSP networking. For a
* description of networked channels, see the relevant documentation.
*
* @see org.jcsp.net2.NetChannelInput
* @see org.jcsp.net2.NetChannelOutput
* @author Kevin Chalmers
*/
final class ChannelManager
{
/**
* The index for the next channel to be created. We start at 50 as it allows us to have up to 50 default channels,
* for example for use to connect to a Channel Name Server.
*/
private static int index = 50;
/**
* The table containing the channels. An Integer (object wrapped int) is used as the key, and the ChannelData as the
* value.
*/
private final Hashtable channels = new Hashtable();
/**
* Singleton instance of the ChannelManager
*/
private static ChannelManager instance = new ChannelManager();
/**
* Private default constructor. Used for the singleton instance.
*/
private ChannelManager()
{
// Empty constructor
}
/**
* Allows getting of the singleton instance.
*
* @return The singleton instance of the ChannelManager
*/
static ChannelManager getInstance()
{
return instance;
}
/**
* Allocates a new number to the channel, and stores it in the table.
*
* @param cd
* The ChannelData for the channel
*/
synchronized void create(ChannelData cd)
{
// First allocate a new number for the channel
Integer objIndex = new Integer(index);
while (this.channels.get(objIndex) != null)
objIndex = new Integer(++index);
// Set the index of the ChannelData
cd.vcn = index;
// Now put the channel in the channel Hashtable
this.channels.put(objIndex, cd);
// Finally increment the index for the next channel to be created
index++;
}
/**
* Stores a channel in the given index in the table.
*
* @param idx
* The index to use for the channel
* @param cd
* The ChannelData for the channel
* @throws IllegalArgumentException
* If a channel of the given index already exists.
*/
synchronized void create(int idx, ChannelData cd)
throws IllegalArgumentException
{
// First check that a channel of the given index does not exist. If it does, throw an exception
Integer objIndex = new Integer(idx);
if (this.channels.get(objIndex) != null)
throw new IllegalArgumentException("Channel of given number already exists.");
// Set the index of the channel data
cd.vcn = idx;
// Now add the channel to the channels table
this.channels.put(objIndex, cd);
// Update the index if necessary
if (idx == ChannelManager.index)
ChannelManager.index++;
}
/**
* Retrieves a channel from the table
*
* @param idx
* Index in the table to retrieve the channel from.
* @return The ChannelData object for the channel.
*/
ChannelData getChannel(int idx)
{
Integer objIndex = new Integer(idx);
return (ChannelData)this.channels.get(objIndex);
}
/**
* Removes a channel from the table.
*
* @param data
* ChannelData for channel to remove
*/
void removeChannel(ChannelData data)
{
Integer objIndex = new Integer(data.vcn);
this.channels.remove(objIndex);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/net2/NetChannel.java 0000644 0000000 0000000 00000072313 11072626250 016703 0 ustar /**
*
*/
package org.jcsp.net2;
/**
* A static factory object used to create networked channels. This class basically wraps around a
* StandardNetChannelEndFactory and allows static access to its channel creation methods.
*
* @see NetChannelEndFactory
* @see StandardNetChannelEndFactory
* @author Kevin Chalmers
*/
public final class NetChannel
{
/**
* The factory used to create the networked channels
*/
private static StandardNetChannelEndFactory factory = new StandardNetChannelEndFactory();
/**
* Empty, private default constructor. This is a static access class.
*/
private NetChannel()
{
// Empty constructor
}
/**
* Creates a new NetAltingChannelInput
*
* @deprecated Use net2one instead
* @return A new NetAltingChannelInput
*/
public static NetAltingChannelInput createNet2One()
{
return factory.net2one();
}
/**
* Creates a new NetSharedChannelInput
*
* @deprecated Use net2any instead
* @return A new NetSharedChannelInput
*/
public static NetSharedChannelInput createNet2Any()
{
return factory.net2any();
}
/**
* Creates a new NetChannelOutput connected to the input channel end with the given location
*
* @deprecated Use one2net instead
* @param loc
* The location to connect the output end to
* @return A new NetChannelOutput connected to the input end at the given location
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput createOne2Net(NetChannelLocation loc)
throws JCSPNetworkException
{
return factory.one2net(loc);
}
/**
* Creates a new NetSharedChannelOutput connected to the input end at the given location
*
* @deprecated Use any2net instead
* @param loc
* The location to connect the output end to
* @return A new NetSharedChannelOutput connected to the input end at the given location
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput createAny2Net(NetChannelLocation loc)
throws JCSPNetworkException
{
return factory.any2net(loc);
}
/**
* Creates a new NetAltingChannelInput
*
* @return A new NetAltingChannelInput
*/
public static NetAltingChannelInput net2one()
{
return factory.net2one();
}
/**
* Creates a new NetAltingChannelInput with the given immunity level for poison
*
* @param immunityLevel
* The immunity level for poison
* @return A new NetAltingChannelInput
*/
public static NetAltingChannelInput net2one(int immunityLevel)
{
return factory.net2one(immunityLevel);
}
/**
* Creates a new NetAltingChannelInput which uses the given filter to decode incoming messages
*
* @param filter
* The filter used to decode incoming messages
* @return A new NetAltingChannelInput
*/
public static NetAltingChannelInput net2one(NetworkMessageFilter.FilterRx filter)
{
return factory.net2one(filter);
}
/**
* Creates a new NetAltingChannelInput with the given poison immunity level which uses the given filter to decode
* incoming messages
*
* @param immunityLevel
* The immunity level to poison for the created channel
* @param filter
* The filter used to decode incoming messages
* @return A new NetAltingChannelInput
*/
public static NetAltingChannelInput net2one(int immunityLevel, NetworkMessageFilter.FilterRx filter)
{
return factory.net2one(immunityLevel, filter);
}
/**
* Creates a new NetSharedChannelInput
*
* @return A new NetSharedChannelInput
*/
public static NetSharedChannelInput net2any()
{
return factory.net2any();
}
/**
* Creates a new NetSharedChannelInput with the given poison immunity level
*
* @param immunityLevel
* The immunity level to poison for this channel
* @return A new NetSharedChannelInput
*/
public static NetSharedChannelInput net2any(int immunityLevel)
{
return factory.net2any(immunityLevel);
}
/**
* Creates a new NetSharedChannelInput which uses the given filter to decode incoming messages
*
* @param filter
* The filter used to decode incoming messages
* @return A new NetSharedChannelInput
*/
public static NetSharedChannelInput net2any(NetworkMessageFilter.FilterRx filter)
{
return factory.net2any(filter);
}
/**
* Creates a new NetSharedChannelInput with the given poison immunity level, which uses the given filter to decode
* messages
*
* @param immunityLevel
* The immunity level to poison for this channel
* @param filter
* The filter used to decode incoming messages
* @return A new NetSharedChannelInput
*/
public static NetSharedChannelInput net2any(int immunityLevel, NetworkMessageFilter.FilterRx filter)
{
return factory.net2any(immunityLevel, filter);
}
/**
* Creates a new NetAltingChannelInput with the given index
*
* @param index
* The index to create the channel with
* @return A new NetAltingChannelInput
* @throws IllegalArgumentException
* Thrown if a channel with the given index already exists
*/
public static NetAltingChannelInput numberedNet2One(int index)
throws IllegalArgumentException
{
return factory.numberedNet2One(index);
}
/**
* Creates a new NetAltingChannelInput with the given index and the given poison immunity level
*
* @param index
* The index to create the channel with
* @param immunityLevel
* The immunity to poison that the channel has
* @return A new NetAltingChannelInput
* @throws IllegalArgumentException
* Thrown if a channel with the given index already exists
*/
public static NetAltingChannelInput numberedNet2One(int index, int immunityLevel)
throws IllegalArgumentException
{
return factory.numberedNet2One(index, immunityLevel);
}
/**
* Creates a new NetAltingChannelInput with the given index that uses the given filter to decode incoming messages
*
* @param index
* The index to create the channel with
* @param filter
* The filter used to decode incoming messages
* @return A new NetAltingChannelInput
* @throws IllegalArgumentException
* Thrown if a channel with the given index already exists
*/
public static NetAltingChannelInput numberedNet2One(int index, NetworkMessageFilter.FilterRx filter)
throws IllegalArgumentException
{
return factory.numberedNet2One(index, filter);
}
/**
* Creates a new NetAltingChannelInput with the given index and given poison immunity, which uses the given filter
* to decode incoming messages
*
* @param index
* The index to create the channel with
* @param immunityLevel
* The immunity to poison that the channel has
* @param filter
* The filter used to decode incoming messages
* @return A new NetAltingChannelInput
* @throws IllegalArgumentException
* Thrown if a channel with the given index already exists
*/
public static NetAltingChannelInput numberedNet2One(int index, int immunityLevel,
NetworkMessageFilter.FilterRx filter)
throws IllegalArgumentException
{
return factory.numberedNet2One(index, immunityLevel, filter);
}
/**
* Creates a new NetSharedChannelInput with the given index
*
* @param index
* The index to create the channel with
* @return A new NetSharedChannelInput
* @throws IllegalArgumentException
* Thrown if a channel with the given index already exists
*/
public static NetSharedChannelInput numberedNet2Any(int index)
throws IllegalArgumentException
{
return factory.numberedNet2Any(index);
}
/**
* Creates a new NetSharedChannelInput with the given index and poison immunity level
*
* @param index
* The index to create the channel with
* @param immunityLevel
* The immunity to poison the channel has
* @return A new NetSharedChannelInput
* @throws IllegalArgumentException
* Thrown if a channel with the given index already exists
*/
public static NetSharedChannelInput numberedNet2Any(int index, int immunityLevel)
throws IllegalArgumentException
{
return factory.numberedNet2Any(index, immunityLevel);
}
/**
* Creates a new NetSharedChannelInput with the given index that uses the given filter to decode incoming messages
*
* @param index
* The index to create the channel with
* @param filter
* The filter used to decode incoming messages
* @return A new NetSharedChannelInput
* @throws IllegalArgumentException
* Thrown if a channel with the given index already exists
*/
public static NetSharedChannelInput numberedNet2Any(int index, NetworkMessageFilter.FilterRx filter)
throws IllegalArgumentException
{
return factory.numberedNet2Any(index, filter);
}
/**
* Creates a new NetSharedChannelInput with the given index and poison immunity level, which uses the given filter
* to decode incoming messages.
*
* @param index
* The index to create the channel with
* @param immunityLevel
* The immunity level to poison that the channel has
* @param filter
* The filter used to decode incoming messages
* @return A new NetSharedChannelInput
* @throws IllegalArgumentException
* Thrown if a channel with the given index already exists.
*/
public static NetSharedChannelInput numberedNet2Any(int index, int immunityLevel,
NetworkMessageFilter.FilterRx filter)
throws IllegalArgumentException
{
return factory.numberedNet2Any(index, immunityLevel, filter);
}
/**
* Creates a new NetChannelOutput connected to the input end with the given NetChannelLocation
*
* @param loc
* The location of the input end of the channel
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NetChannelLocation loc)
throws JCSPNetworkException
{
return factory.one2net(loc);
}
/**
* Creates a new NetChannelOutput connected to the input end with the given NetChannelLocation, and having the given
* poison immunity level
*
* @param loc
* The location of the input end of the channel
* @param immunityLevel
* The immunity to poison that this channel has
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NetChannelLocation loc, int immunityLevel)
throws JCSPNetworkException
{
return factory.one2net(loc, immunityLevel);
}
/**
* Creates a new NetChannelOutput connected to the input end with the given NetChannelLocation, and uses the given
* filter to encode outgoing messages
*
* @param loc
* The location of the input end of the channel
* @param filter
* The filter used to encode outgoing messages
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NetChannelLocation loc, NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.one2net(loc, filter);
}
/**
* Creates a new NetChannelOutput connected to the given location with the given poison immunity level, and uses the
* given filter to encode outgoing messages.
*
* @param loc
* The location of the input end of the channel
* @param immunityLevel
* The immunity to poison that this channel has
* @param filter
* The filter used to encode outgoing messages
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NetChannelLocation loc, int immunityLevel,
NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.one2net(loc, immunityLevel, filter);
}
/**
* Creates a new NetSharedChannelOutput connected to the input end at the given location
*
* @param loc
* The location of the input end of the channel
* @return A new NetSharedChannelInput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NetChannelLocation loc)
throws JCSPNetworkException
{
return factory.any2net(loc);
}
/**
* Creates a new NetSharedChannelOutput connected to the input end at the given location and with the given poison
* immunity level
*
* @param loc
* The location of the input end of the channel
* @param immunityLevel
* The immunity to poison that the channel has
* @return A new NetSharedChannelInput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NetChannelLocation loc, int immunityLevel)
throws JCSPNetworkException
{
return factory.any2net(loc, immunityLevel);
}
/**
* Creates a new NetSharedChannelOutput connected to the input end with the given location, and uses the given
* filter to encode outgoing messages
*
* @param loc
* The location of the input end of the channel
* @param filter
* The filter used to encode outgoing messages
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NetChannelLocation loc, NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.any2net(loc, filter);
}
/**
* Creates a new NetSharedChannelOutput connected to the input end with the given location and with the given
* immunity level, which uses the given filter to encode outgoing messages.
*
* @param loc
* The location of the input end of the channel
* @param immunityLevel
* The immunity to poison that this channel has
* @param filter
* The filter used to encode outgoing messages
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NetChannelLocation loc, int immunityLevel,
NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.any2net(loc, immunityLevel, filter);
}
/**
* Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node
*
* @param nodeID
* The NodeID of the node that the input channel resides on
* @param vcn
* The Virtual Channel Number of the input channel
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NodeID nodeID, int vcn)
throws JCSPNetworkException
{
return factory.one2net(nodeID, vcn);
}
/**
* Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node, and with the given
* poison immunity level
*
* @param nodeID
* The NodeID of the Node that the input channel resides on
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison of the channel
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NodeID nodeID, int vcn, int immunityLevel)
throws JCSPNetworkException
{
return factory.one2net(nodeID, vcn, immunityLevel);
}
/**
* Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node, which uses the
* given filter to encode outgoing messages
*
* @param nodeID
* The NodeID of the Node that the input channel resides on
* @param vcn
* The Virtual Channel Number of the input channel
* @param filter
* The filter to encode outgoing messages
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong with the underlying architecture
*/
public static NetChannelOutput one2net(NodeID nodeID, int vcn, NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.one2net(nodeID, vcn, filter);
}
/**
* Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node, with the given
* poison immunity level and uses the given filter to encode outgoing messages
*
* @param nodeID
* The NodeID of the Node that the input channel resides on
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison that the channel has
* @param filter
* The filter that encodes the outgoing messages
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong with the underlying architecture
*/
public static NetChannelOutput one2net(NodeID nodeID, int vcn, int immunityLevel,
NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.one2net(nodeID, vcn, immunityLevel, filter);
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node
*
* @param nodeID
* The NodeID of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NodeID nodeID, int vcn)
throws JCSPNetworkException
{
return factory.any2net(nodeID, vcn);
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node and the given
* poison immunity
*
* @param nodeID
* The NodeID of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison that the channel has
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NodeID nodeID, int vcn, int immunityLevel)
throws JCSPNetworkException
{
return factory.any2net(nodeID, vcn, immunityLevel);
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node, which uses
* the given filter to encode outgoing messages
*
* @param nodeID
* The NodeID of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param filter
* The filter used to encode the outgoing messages
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NodeID nodeID, int vcn, NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.any2net(nodeID, vcn, filter);
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node, with the
* given poison immunity level, which uses the given filter to encode outgoing messages
*
* @param nodeID
* The NodeID of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison that the channel has
* @param filter
* The filter used to encode outgoing messages
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NodeID nodeID, int vcn, int immunityLevel,
NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.any2net(nodeID, vcn, immunityLevel, filter);
}
/**
* Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NodeAddress nodeAddr, int vcn)
throws JCSPNetworkException
{
return factory.one2net(nodeAddr, vcn);
}
/**
* Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node with the given
* poison immunity
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison the channel has
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NodeAddress nodeAddr, int vcn, int immunityLevel)
throws JCSPNetworkException
{
return factory.one2net(nodeAddr, vcn, immunityLevel);
}
/**
* Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node which uses the given
* filter to encode outgoing messages
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param filter
* The filter used to encode outgoing messages
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NodeAddress nodeAddr, int vcn, NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.one2net(nodeAddr, vcn, filter);
}
/**
* Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node which has the given
* poison immunity and uses the given filter to encode outgoing messages
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison that the channel has
* @param filter
* The filter used to encode outgoing messages
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NodeAddress nodeAddr, int vcn, int immunityLevel,
NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.one2net(nodeAddr, vcn, immunityLevel, filter);
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn)
throws JCSPNetworkException
{
return factory.any2net(nodeAddr, vcn);
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node which has the
* given poison immunity
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison that the channel has
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn, int immunityLevel)
throws JCSPNetworkException
{
return factory.any2net(nodeAddr, vcn, immunityLevel);
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node which uses the
* given filter to encode outgoing messages
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param filter
* The immunity to poison that the channel has
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn, NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.any2net(nodeAddr, vcn, filter);
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node that has the
* given poison immunity level and uses the given filter to encode outgoing messages
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison that the channel has
* @param filter
* The filter used to encode outgoing messages
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn, int immunityLevel,
NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.any2net(nodeAddr, vcn, immunityLevel, filter);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/net2/NetChannelEnd.java 0000644 0000000 0000000 00000072456 11072626250 017342 0 ustar package org.jcsp.net2;
/**
* A static factory object used to create networked channels. This class basically wraps around a
* StandardNetChannelEndFactory and allows static access to its channel creation methods.
*
* @see NetChannelEndFactory
* @see StandardNetChannelEndFactory
* @deprecated To conform with the core package naming scheme, the class NetChannel has also been provided
* @author Kevin Chalmers
*/
public final class NetChannelEnd
{
/**
* The factory used to create the networked channels
*/
private static StandardNetChannelEndFactory factory = new StandardNetChannelEndFactory();
/**
* Empty, private default constructor. This is a static access class.
*/
private NetChannelEnd()
{
// Empty constructor
}
/**
* Creates a new NetAltingChannelInput
*
* @deprecated Use net2one instead
* @return A new NetAltingChannelInput
*/
public static NetAltingChannelInput createNet2One()
{
return factory.net2one();
}
/**
* Creates a new NetSharedChannelInput
*
* @deprecated Use net2any instead
* @return A new NetSharedChannelInput
*/
public static NetSharedChannelInput createNet2Any()
{
return factory.net2any();
}
/**
* Creates a new NetChannelOutput connected to the input channel end with the given location
*
* @deprecated Use one2net instead
* @param loc
* The location to connect the output end to
* @return A new NetChannelOutput connected to the input end at the given location
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput createOne2Net(NetChannelLocation loc)
throws JCSPNetworkException
{
return factory.one2net(loc);
}
/**
* Creates a new NetSharedChannelOutput connected to the input end at the given location
*
* @deprecated Use any2net instead
* @param loc
* The location to connect the output end to
* @return A new NetSharedChannelOutput connected to the input end at the given location
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput createAny2Net(NetChannelLocation loc)
throws JCSPNetworkException
{
return factory.any2net(loc);
}
/**
* Creates a new NetAltingChannelInput
*
* @return A new NetAltingChannelInput
*/
public static NetAltingChannelInput net2one()
{
return factory.net2one();
}
/**
* Creates a new NetAltingChannelInput with the given immunity level for poison
*
* @param immunityLevel
* The immunity level for poison
* @return A new NetAltingChannelInput
*/
public static NetAltingChannelInput net2one(int immunityLevel)
{
return factory.net2one(immunityLevel);
}
/**
* Creates a new NetAltingChannelInput which uses the given filter to decode incoming messages
*
* @param filter
* The filter used to decode incoming messages
* @return A new NetAltingChannelInput
*/
public static NetAltingChannelInput net2one(NetworkMessageFilter.FilterRx filter)
{
return factory.net2one(filter);
}
/**
* Creates a new NetAltingChannelInput with the given poison immunity level which uses the given filter to decode
* incoming messages
*
* @param immunityLevel
* The immunity level to poison for the created channel
* @param filter
* The filter used to decode incoming messages
* @return A new NetAltingChannelInput
*/
public static NetAltingChannelInput net2one(int immunityLevel, NetworkMessageFilter.FilterRx filter)
{
return factory.net2one(immunityLevel, filter);
}
/**
* Creates a new NetSharedChannelInput
*
* @return A new NetSharedChannelInput
*/
public static NetSharedChannelInput net2any()
{
return factory.net2any();
}
/**
* Creates a new NetSharedChannelInput with the given poison immunity level
*
* @param immunityLevel
* The immunity level to poison for this channel
* @return A new NetSharedChannelInput
*/
public static NetSharedChannelInput net2any(int immunityLevel)
{
return factory.net2any(immunityLevel);
}
/**
* Creates a new NetSharedChannelInput which uses the given filter to decode incoming messages
*
* @param filter
* The filter used to decode incoming messages
* @return A new NetSharedChannelInput
*/
public static NetSharedChannelInput net2any(NetworkMessageFilter.FilterRx filter)
{
return factory.net2any(filter);
}
/**
* Creates a new NetSharedChannelInput with the given poison immunity level, which uses the given filter to decode
* messages
*
* @param immunityLevel
* The immunity level to poison for this channel
* @param filter
* The filter used to decode incoming messages
* @return A new NetSharedChannelInput
*/
public static NetSharedChannelInput net2any(int immunityLevel, NetworkMessageFilter.FilterRx filter)
{
return factory.net2any(immunityLevel, filter);
}
/**
* Creates a new NetAltingChannelInput with the given index
*
* @param index
* The index to create the channel with
* @return A new NetAltingChannelInput
* @throws IllegalArgumentException
* Thrown if a channel with the given index already exists
*/
public static NetAltingChannelInput numberedNet2One(int index)
throws IllegalArgumentException
{
return factory.numberedNet2One(index);
}
/**
* Creates a new NetAltingChannelInput with the given index and the given poison immunity level
*
* @param index
* The index to create the channel with
* @param immunityLevel
* The immunity to poison that the channel has
* @return A new NetAltingChannelInput
* @throws IllegalArgumentException
* Thrown if a channel with the given index already exists
*/
public static NetAltingChannelInput numberedNet2One(int index, int immunityLevel)
throws IllegalArgumentException
{
return factory.numberedNet2One(index, immunityLevel);
}
/**
* Creates a new NetAltingChannelInput with the given index that uses the given filter to decode incoming messages
*
* @param index
* The index to create the channel with
* @param filter
* The filter used to decode incoming messages
* @return A new NetAltingChannelInput
* @throws IllegalArgumentException
* Thrown if a channel with the given index already exists
*/
public static NetAltingChannelInput numberedNet2One(int index, NetworkMessageFilter.FilterRx filter)
throws IllegalArgumentException
{
return factory.numberedNet2One(index, filter);
}
/**
* Creates a new NetAltingChannelInput with the given index and given poison immunity, which uses the given filter
* to decode incoming messages
*
* @param index
* The index to create the channel with
* @param immunityLevel
* The immunity to poison that the channel has
* @param filter
* The filter used to decode incoming messages
* @return A new NetAltingChannelInput
* @throws IllegalArgumentException
* Thrown if a channel with the given index already exists
*/
public static NetAltingChannelInput numberedNet2One(int index, int immunityLevel,
NetworkMessageFilter.FilterRx filter)
throws IllegalArgumentException
{
return factory.numberedNet2One(index, immunityLevel, filter);
}
/**
* Creates a new NetSharedChannelInput with the given index
*
* @param index
* The index to create the channel with
* @return A new NetSharedChannelInput
* @throws IllegalArgumentException
* Thrown if a channel with the given index already exists
*/
public static NetSharedChannelInput numberedNet2Any(int index)
throws IllegalArgumentException
{
return factory.numberedNet2Any(index);
}
/**
* Creates a new NetSharedChannelInput with the given index and poison immunity level
*
* @param index
* The index to create the channel with
* @param immunityLevel
* The immunity to poison the channel has
* @return A new NetSharedChannelInput
* @throws IllegalArgumentException
* Thrown if a channel with the given index already exists
*/
public static NetSharedChannelInput numberedNet2Any(int index, int immunityLevel)
throws IllegalArgumentException
{
return factory.numberedNet2Any(index, immunityLevel);
}
/**
* Creates a new NetSharedChannelInput with the given index that uses the given filter to decode incoming messages
*
* @param index
* The index to create the channel with
* @param filter
* The filter used to decode incoming messages
* @return A new NetSharedChannelInput
* @throws IllegalArgumentException
* Thrown if a channel with the given index already exists
*/
public static NetSharedChannelInput numberedNet2Any(int index, NetworkMessageFilter.FilterRx filter)
throws IllegalArgumentException
{
return factory.numberedNet2Any(index, filter);
}
/**
* Creates a new NetSharedChannelInput with the given index and poison immunity level, which uses the given filter
* to decode incoming messages.
*
* @param index
* The index to create the channel with
* @param immunityLevel
* The immunity level to poison that the channel has
* @param filter
* The filter used to decode incoming messages
* @return A new NetSharedChannelInput
* @throws IllegalArgumentException
* Thrown if a channel with the given index already exists.
*/
public static NetSharedChannelInput numberedNet2Any(int index, int immunityLevel,
NetworkMessageFilter.FilterRx filter)
throws IllegalArgumentException
{
return factory.numberedNet2Any(index, immunityLevel, filter);
}
/**
* Creates a new NetChannelOutput connected to the input end with the given NetChannelLocation
*
* @param loc
* The location of the input end of the channel
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NetChannelLocation loc)
throws JCSPNetworkException
{
return factory.one2net(loc);
}
/**
* Creates a new NetChannelOutput connected to the input end with the given NetChannelLocation, and having the given
* poison immunity level
*
* @param loc
* The location of the input end of the channel
* @param immunityLevel
* The immunity to poison that this channel has
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NetChannelLocation loc, int immunityLevel)
throws JCSPNetworkException
{
return factory.one2net(loc, immunityLevel);
}
/**
* Creates a new NetChannelOutput connected to the input end with the given NetChannelLocation, and uses the given
* filter to encode outgoing messages
*
* @param loc
* The location of the input end of the channel
* @param filter
* The filter used to encode outgoing messages
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NetChannelLocation loc, NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.one2net(loc, filter);
}
/**
* Creates a new NetChannelOutput connected to the given location with the given poison immunity level, and uses the
* given filter to encode outgoing messages.
*
* @param loc
* The location of the input end of the channel
* @param immunityLevel
* The immunity to poison that this channel has
* @param filter
* The filter used to encode outgoing messages
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NetChannelLocation loc, int immunityLevel,
NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.one2net(loc, immunityLevel, filter);
}
/**
* Creates a new NetSharedChannelOutput connected to the input end at the given location
*
* @param loc
* The location of the input end of the channel
* @return A new NetSharedChannelInput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NetChannelLocation loc)
throws JCSPNetworkException
{
return factory.any2net(loc);
}
/**
* Creates a new NetSharedChannelOutput connected to the input end at the given location and with the given poison
* immunity level
*
* @param loc
* The location of the input end of the channel
* @param immunityLevel
* The immunity to poison that the channel has
* @return A new NetSharedChannelInput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NetChannelLocation loc, int immunityLevel)
throws JCSPNetworkException
{
return factory.any2net(loc, immunityLevel);
}
/**
* Creates a new NetSharedChannelOutput connected to the input end with the given location, and uses the given
* filter to encode outgoing messages
*
* @param loc
* The location of the input end of the channel
* @param filter
* The filter used to encode outgoing messages
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NetChannelLocation loc, NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.any2net(loc, filter);
}
/**
* Creates a new NetSharedChannelOutput connected to the input end with the given location and with the given
* immunity level, which uses the given filter to encode outgoing messages.
*
* @param loc
* The location of the input end of the channel
* @param immunityLevel
* The immunity to poison that this channel has
* @param filter
* The filter used to encode outgoing messages
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NetChannelLocation loc, int immunityLevel,
NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.any2net(loc, immunityLevel, filter);
}
/**
* Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node
*
* @param nodeID
* The NodeID of the node that the input channel resides on
* @param vcn
* The Virtual Channel Number of the input channel
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NodeID nodeID, int vcn)
throws JCSPNetworkException
{
return factory.one2net(nodeID, vcn);
}
/**
* Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node, and with the given
* poison immunity level
*
* @param nodeID
* The NodeID of the Node that the input channel resides on
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison of the channel
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NodeID nodeID, int vcn, int immunityLevel)
throws JCSPNetworkException
{
return factory.one2net(nodeID, vcn, immunityLevel);
}
/**
* Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node, which uses the
* given filter to encode outgoing messages
*
* @param nodeID
* The NodeID of the Node that the input channel resides on
* @param vcn
* The Virtual Channel Number of the input channel
* @param filter
* The filter to encode outgoing messages
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong with the underlying architecture
*/
public static NetChannelOutput one2net(NodeID nodeID, int vcn, NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.one2net(nodeID, vcn, filter);
}
/**
* Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node, with the given
* poison immunity level and uses the given filter to encode outgoing messages
*
* @param nodeID
* The NodeID of the Node that the input channel resides on
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison that the channel has
* @param filter
* The filter that encodes the outgoing messages
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong with the underlying architecture
*/
public static NetChannelOutput one2net(NodeID nodeID, int vcn, int immunityLevel,
NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.one2net(nodeID, vcn, immunityLevel, filter);
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node
*
* @param nodeID
* The NodeID of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NodeID nodeID, int vcn)
throws JCSPNetworkException
{
return factory.any2net(nodeID, vcn);
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node and the given
* poison immunity
*
* @param nodeID
* The NodeID of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison that the channel has
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NodeID nodeID, int vcn, int immunityLevel)
throws JCSPNetworkException
{
return factory.any2net(nodeID, vcn, immunityLevel);
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node, which uses
* the given filter to encode outgoing messages
*
* @param nodeID
* The NodeID of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param filter
* The filter used to encode the outgoing messages
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NodeID nodeID, int vcn, NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.any2net(nodeID, vcn, filter);
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node, with the
* given poison immunity level, which uses the given filter to encode outgoing messages
*
* @param nodeID
* The NodeID of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison that the channel has
* @param filter
* The filter used to encode outgoing messages
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NodeID nodeID, int vcn, int immunityLevel,
NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.any2net(nodeID, vcn, immunityLevel, filter);
}
/**
* Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NodeAddress nodeAddr, int vcn)
throws JCSPNetworkException
{
return factory.one2net(nodeAddr, vcn);
}
/**
* Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node with the given
* poison immunity
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison the channel has
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NodeAddress nodeAddr, int vcn, int immunityLevel)
throws JCSPNetworkException
{
return factory.one2net(nodeAddr, vcn, immunityLevel);
}
/**
* Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node which uses the given
* filter to encode outgoing messages
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param filter
* The filter used to encode outgoing messages
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NodeAddress nodeAddr, int vcn, NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.one2net(nodeAddr, vcn, filter);
}
/**
* Creates a new NetChannelOutput connected to the channel with the given vcn on the given Node which has the given
* poison immunity and uses the given filter to encode outgoing messages
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison that the channel has
* @param filter
* The filter used to encode outgoing messages
* @return A new NetChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetChannelOutput one2net(NodeAddress nodeAddr, int vcn, int immunityLevel,
NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.one2net(nodeAddr, vcn, immunityLevel, filter);
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn)
throws JCSPNetworkException
{
return factory.any2net(nodeAddr, vcn);
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node which has the
* given poison immunity
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison that the channel has
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn, int immunityLevel)
throws JCSPNetworkException
{
return factory.any2net(nodeAddr, vcn, immunityLevel);
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node which uses the
* given filter to encode outgoing messages
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param filter
* The immunity to poison that the channel has
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn, NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.any2net(nodeAddr, vcn, filter);
}
/**
* Creates a new NetSharedChannelOutput connected to the channel with the given vcn on the given Node that has the
* given poison immunity level and uses the given filter to encode outgoing messages
*
* @param nodeAddr
* The NodeAddress of the Node to connect to
* @param vcn
* The Virtual Channel Number of the input channel
* @param immunityLevel
* The immunity to poison that the channel has
* @param filter
* The filter used to encode outgoing messages
* @return A new NetSharedChannelOutput
* @throws JCSPNetworkException
* Thrown if something goes wrong in the underlying architecture
*/
public static NetSharedChannelOutput any2net(NodeAddress nodeAddr, int vcn, int immunityLevel,
NetworkMessageFilter.FilterTx filter)
throws JCSPNetworkException
{
return factory.any2net(nodeAddr, vcn, immunityLevel, filter);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/net2/JCSPNetworkException.java 0000644 0000000 0000000 00000001511 11072626250 020644 0 ustar package org.jcsp.net2;
/**
* This is the general exception thrown when something bad happens in the underlying architecture. Currently this is
* generalised for the sake of simplicity. However, a number of different errors may occur internally, and therefore
* this exception may be specialised into particular exception types in the future.
*
* @author Kevin Chalmers
*/
public final class JCSPNetworkException
extends RuntimeException
{
/**
* Default serial ID. Given for the sake of completeness.
*/
private static final long serialVersionUID = 1L;
/**
* Constructor for a new JCSPNetworkException
*
* @param message
* The message for the exception
*/
public JCSPNetworkException(String message)
{
super(message);
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/net2/NodeKey.java 0000644 0000000 0000000 00000000500 11072626250 016207 0 ustar package org.jcsp.net2;
/**
* A unique object for allowing access to privileged operations on the Node. Returned when a Node is initialised.
*
* @author Kevin Chalmers
*/
public final class NodeKey
{
/**
* Creates a NodeKey
*/
NodeKey()
{
// Empty constructor
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/net2/NetChannelInput.java 0000644 0000000 0000000 00000001301 11072626250 017710 0 ustar package org.jcsp.net2;
import org.jcsp.lang.ChannelInput;
/**
* This interface defines a ChannelInput that is also networked. For information on ChannelInput see the relevant class.
* For information on how to create a NetChannelInput, see the relevant factory class
*
* @see ChannelInput
* @see Networked
* @see NetChannel
* @author Kevin Chalmers (updated from Quickstone Technologies)
*/
public interface NetChannelInput
extends ChannelInput, Networked
{
/**
* Sets the underlying decoder for the channel
*
* @param decoder
* The new decoder to use.
*/
public void setDecoder(NetworkMessageFilter.FilterRx decoder);
}
jcsp-1.1-rc4.orig/src/org/jcsp/net2/NetBarrier.java 0000644 0000000 0000000 00000115572 11072626250 016726 0 ustar package org.jcsp.net2;
import java.util.LinkedList;
import org.jcsp.lang.AltingChannelInput;
import org.jcsp.lang.Any2OneChannel;
import org.jcsp.lang.Barrier;
import org.jcsp.lang.Channel;
import org.jcsp.lang.ChannelOutput;
import org.jcsp.lang.ProcessInterruptedException;
import org.jcsp.util.InfiniteBuffer;
/**
* This class is a networked implementation of the standard JCSP Barrier.
*
* The NetBarrier is a networked version of the JCSP Barrier, a synchronization primitive similar to the standard event * in CSP. The networked implementation follows the standard interface for a local Barrier, with the addition of the * interface defining a networked construct. Internally, the two constructs behave differently due to the distributed * nature of the NetBarrier. *
*Client and Server Ends
** Unlike a normal Barrier, a NetBarrier has two types, based on whether the Barrier is the hosting end or an attached, * synchronizing end. These are differentiated between as server and client ends. The server end, like the input end of * a networked channel, will be declared first. The location of this server end can then be used to connect a number of * client ends to. The server end can declare an initial number of expected client ends, which it waits for enrolls from * before beginning any sync operations. This value can be set to 0 if need be. Each end of a barrier must also declare * the number of local syncing processes, creating a two tier construct: *
** Process ---> NetBarrier (client) ---> NetBarrier (server) *
*Creating NetBarriers
** To create a NetBarrier, a similar method is used as a networked channel. A Barrier Name Server is provided for * declaring named barriers, or the NetBarrierEnd factory can be used. First, creation of a sever end: *
*
*
* int locallyEnrolled = 5;
*
* int remoteEnrolled = 1;
* NetBarrier bar = NetBarrierEnd.netBarrier(locallyEnrolled, remoteEnrolled);
*
* A client end requires the location of this barrier to allow creation: *
*
*
* NetBarrierLocation loc;
*
* int locallyEnrolled = 5;
* NetBarrier bar = NetBarrierEnd.netBarrier(loc, locallyEnrolled);
*
* These barriers can then be used as normal. *
*IMPLMENTATION NOTE
** To save on resources, a NetBarrier does not have an internal process controlling it (although other implementations * may decide to do this). Because of this, the declaring (server) end of the barrier must always have at least one * process enrolled with it to ensure that the SYNC operation occurs. If there is a danger that the enrolled processes * on the server node will become 0, it is safer to define a process that is only responsible for SYNCing with the * barrier. This minor overhead in certain circumstances is seen as a better approach than all NetBarriers being a * process within JCSP, where processes are expensive in resources. *
*
*
* public void run() {
*
* while (true) {
* bar.sync(); }}
*
Process Diagram
*
Description
* Deparaplex is a process to convert the single stream of * Object[] packets sent from a {@link Paraplex} process on the other * end of its in channel back to separate streams (its out * channels). It assumes that {@link Paraplex} operates on the same * size array of channels as its out array. It conforms to * contract required by {@link Paraplex} for a process receiving its packets. ** In each cycle, it inputs one packet and outputs its contents in parallel * to each of its output channels. * The parallel output means that the process will wait until each item is accepted * by every channel -- in whatever order is demanded by its environment. * The ordering of the channels in the out array, therefore, makes * no difference to the functionality of this process. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| in | *Object[] | ** A packet carrying the paraplexed data. * |
| Output Channels | *||
| out[] | *Object | ** Most channels in this package carry integers. * | *
Example
*
* import org.jcsp.lang.*;
* import org.jcsp.plugNplay.*;
*
* public class DeparaplexExample {
*
* public static void main (String[] args) {
*
* final One2OneChannel[] a = Channel.one2oneArray (3);
* final One2OneChannel b = Channel.one2one ();
* final One2OneChannel[] c = Channel.one2oneArray (3);
* final One2OneChannel d = Channel.one2one ();
*
* new Parallel (
* new CSProcess[] {
* new Numbers (a[0].out ()),
* new Squares (a[1].out ()),
* new Fibonacci (a[2].out ()),
* new Paraplex (Channel.getInputArray (a), b.out ()),
* new Deparaplex (b.in (), Channel.getOutputArray (c)),
* new Paraplex (Channel.getInputArray (c), d.out ()),
* new CSProcess () {
* public void run () {
* System.out.println ("\n\t\tNumbers\t\tSquares\t\tFibonacci\n");
* while (true) {
* Object[] data = (Object[]) d.in ().read ();
* for (int i = 0; i < data.length; i++) {
* System.out.print ("\t\t" + data[i]);
* }
* System.out.println ();
* }
* }
* }
* }
* ).run ();
* }
*
* }
*
*
* @see org.jcsp.plugNplay.Paraplex
* @see org.jcsp.plugNplay.Multiplex
* @see org.jcsp.plugNplay.Demultiplex
*
* @author P.H. Welch
*/
public final class Deparaplex implements CSProcess
{
/** The input Channel */
private final ChannelInput in;
/** The output Channels */
private final ChannelOutput[] out;
/**
* Construct a new Deparaplex process with the input Channel in and the output
* Channels out. The ordering of the Channels in the out array make
* no difference to the functionality of this process.
*
* @param in the input channel
* @param out the output Channels
*/
public Deparaplex(final ChannelInput in, final ChannelOutput[] out)
{
this.in = in;
this.out = out;
}
/**
* The main body of this process.
*/
public void run()
{
final ProcessWrite[] outputProcess = new ProcessWrite[out.length];
for (int i = 0; i < out.length; i++)
outputProcess[i] = new ProcessWrite(out[i]);
Parallel parOutput = new Parallel(outputProcess);
while (true)
{
Object[] data = (Object[]) in.read();
for (int i = 0; i < data.length; i++)
outputProcess[i].value = data[i];
parOutput.run();
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/Plex.java 0000644 0000000 0000000 00000012436 11105701167 016675 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.plugNplay;
import org.jcsp.lang.*;
/**
* Fair multiplexes its input Object stream array into one output stream.
* Process Diagram
*
Description
* Plex is a process whose output stream is a fair multiplexing * of its input streams. It makes no assumptions about the traffic patterns occuring * on the input streams and ensures that no input stream will be starved by busy siblings. * It guarantees that if an input stream has data pending, no other stream will be * serviced twice before that data is serviced. *Channel Protocols
*| Input Channels | *||
|---|---|---|
| in[] | *java.lang.Object | ** The input streams. * | *
| Output Channels | *||
| out | *java.lang.Object | ** The multiplexed output stream. * | *
Example
* The following example shows how to use Plex in a small program. *
* import org.jcsp.lang.*;
* import org.jcsp.plugNplay.*;
*
* public class PlexExample {
*
* public static void main (String[] argv) {
*
* final One2OneChannel[] a = Channel.one2oneArray (3);
* final One2OneChannel[] b = Channel.one2oneArray (3);
* final One2OneChannel c = Channel.one2one ();
*
* new Parallel (
* new CSProcess[] {
* new Numbers (a[0].out ()),
* new Fibonacci (a[1].out ()),
* new Squares (a[2].out ()),
* new Sign ("Numbers ", a[0].in (), b[0].out ()),
* new Sign (" Fibonacci ", a[1].in (), b[1].out ()),
* new Sign (" Squares ", a[2].in (), b[2].out ()),
* new Plex (Channel.getInputArray (b), c.out ()),
* new Printer (c.in (), "", "\n")
* }
* ).run ();
*
* }
*
* }
*
* *
Implemntation Note
* For information, here is the run method for this process: * *
* public void run () {
* Alternative alt = new Alternative (in); // in is the input channel array
* while (true) {
* out.write (in[alt.fairSelect ()].read ()); // out is the output channel
* }
* }
*
*
* @see org.jcsp.plugNplay.Plex2
* @see org.jcsp.plugNplay.Multiplex
*
* @author P.H. Welch
*/
public final class Plex implements CSProcess
{
/** The first input Channel */
private final AltingChannelInput[] in;
/** The output Channel */
private final ChannelOutput out;
/**
* Construct a new Plex process with input channels
* in and output channel out.
* The ordering of the input channels makes no difference
* to the behaviour of this process.
*
* @param in the input channels
* @param out the output channel
*/
public Plex(AltingChannelInput[] in, ChannelOutput out)
{
this.in = in;
this.out = out;
}
/**
* The main body of this process.
*/
public void run()
{
Alternative alt = new Alternative(in);
while (true)
out.write(in[alt.fairSelect()].read());
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/Fibonacci.java 0000644 0000000 0000000 00000011041 11105701167 017631 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.plugNplay;
import org.jcsp.lang.*;
/**
* This generates the Fibonacci sequence on its output channel.
*
* CSProcess Diagram
*External View
* ** ___________ * | | out * | Fibonacci |------> * |___________| **
Internal View
* *
* ________________________________
* | |
* | ____________ ________ |
* | | | | | | out
* | | {@link Prefix Prefix (0)} |-->--| {@link Delta2 Delta2} |------>--
* | |____________| |________| |
* | | | |
* | ^ V |
* | ______|_____ ___|___ |
* | | | | | |
* | | {@link Prefix Prefix (1)} |--<--| {@link Pairs Pairs} | |
* | |____________| |_______| |
* | |
* | Fibonacci |
* |________________________________|
*
* Description
* FibonacciInt generates the sequence of Fibonacci * Numbers on its output channel. *Channel Protocols
*| Output Channels | *||
|---|---|---|
| out | *java.lang.Integer | ** The output will always be of type Integer. * | *
Process Diagram
*
Description
* Sign converts each input Object to a String, * prefixing it with a user-defined sign. **
Channel Protocols
*| Input Channels | *||
|---|---|---|
| in | *java.lang.Object | ** The Channel accepts any class of data. * | *
| Output Channels | *||
| out | *java.lang.String | ** The output will always be of type String. * | *
Example
* The following example shows how to use Sign in a small program. *
* import org.jcsp.lang.*;
* import org.jcsp.plugNplay.*;
*
* public class SignExample {
*
* public static void main (String[] argv) {
*
* final One2OneChannel[] a = Channel.one2oneArray (3);
* final One2OneChannel[] b = Channel.one2oneArray (3);
* final One2OneChannel c = Channel.one2one ();
*
* new Parallel (
* new CSProcess[] {
* new Numbers (a[0].out ()),
* new Fibonacci (a[1].out ()),
* new Squares (a[2].out ()),
* new Sign ("Numbers ", a[0].in (), b[0].out ()),
* new Sign (" Fibonacci ", a[1].in (), b[1].out ()),
* new Sign (" Squares ", a[2].in (), b[2].out ()),
* new Plex (Channel.getInputArray (b), c.out ()),
* new Printer (c.in (), "", "\n")
* }
* ).run ();
*
* }
*
* }
*
* * * @see org.jcsp.plugNplay.ints.SignInt * * @author P.H. Welch and P.D. Austin */ public final class Sign implements CSProcess { /** The user-defined sign to attach to each item */ private final String sign; /** The input Channel */ private final ChannelInput in; /** The output Channel */ private final ChannelOutput out; /** * Construct a new Sign process with the input Channel in and the * output Channel out. * * @param sign the user-defined signature to attach to each item. * @param in the input Channel. * @param out the output Channel. */ public Sign(final String sign, final ChannelInput in, final ChannelOutput out) { this.sign = sign; this.in = in; this.out = out; } /** * The main body of this process. */ public void run() { while (true) out.write(sign + in.read()); } } jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/Regular.java 0000644 0000000 0000000 00000007477 11105701167 017377 0 ustar /************************************************************************* * * * JCSP ("CSP for Java") libraries * * Copyright (C) 1996-2008 Peter Welch and Paul Austin. * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This library is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, * * USA. * * * * Author contact: P.H.Welch@kent.ac.uk * * * *************************************************************************/ package org.jcsp.plugNplay; import org.jcsp.lang.*; /** * This process generates a constant stream of Integers at a regular rate. *
Process Diagram
** _____________ * | | out * | Regular (n) |-->-- * |_____________| **
Description
* This process generates a constant stream of Integers at a regular rate * – at least, it does its best! * If the consumption of data is less than the set rate, that rate cannot be sustained. * If the consumption failure is only temporary, the set rate will be restored * when consumption resumes. ** The interval (in msecs) defining the output flow rate is given by a constructor argument. *
Channel Protocols
*| Output Channels | *||
|---|---|---|
| out | *java.lang.Integer | ** A constant value is sent down this channel at a regular rate. * | *
Process Diagram
*
* __________________
* | |
* | |
* | |
* | |
* {@link #FramedButton configure} | | {@link #FramedButton event}
* ----->-----| FramedButton |----->-----
* (java.lang.String) | | (java.lang.String)
* (java.lang.Boolean) | |
* ({@link org.jcsp.awt.ActiveButton.Configure ActiveButton.Configure}) | |
* | |
* |__________________|
*
* Description
* This process provides a free-standing button in its own frame. It is just * an {@link org.jcsp.awt.ActiveButton} wrapped in an {@link org.jcsp.awt.ActiveClosingFrame}, * but saves us the trouble of constructing it. ** Wire it to application processes with a configure * channel (for setting its label, enabling/disabling and all other * configuration options) and an event channel (on which the * current label is sent when the button is clicked). *
** Initially, the button label is an empty java.lang.String. * To set the button label, send a java.lang.String down * the configure channel. *
** Initially, the button is enabled. * To disable the button, send java.lang.Boolean.FALSE * down the configure channel. * To enable, send java.lang.Boolean.TRUE. *
** For other configuration options, send objects implementing * the {@link org.jcsp.awt.ActiveButton.Configure} interface. *
** IMPORTANT: it is essential that event channels from this process are * always serviced -- otherwise the Java Event Thread will be blocked and the GUI * will stop responding. A simple way to guarantee this is to use channels * configured with overwriting buffers. * For example: *
* final One2OneChannel myButtonEvent = * Channel.one2one (new OverWriteOldestBuffer (n)); ** This will ensure that the Java Event Thread will never be blocked. * Slow or inattentive readers may miss rapidly generated events, but * the n most recent events will always be available. * *
Example
* This runs a framed button in parallel with a simple application process * (in-lined in the {@link org.jcsp.lang.Parallel Parallel} below). * The application process configures the button with the first of an array * of String labels, reporting and changing it each time the button * is pressed. *
* import org.jcsp.lang.*;
* import org.jcsp.util.*;
* import org.jcsp.plugNplay.*;
*
* public class FramedButtonExample {
*
* public static void main (String argv[]) {
*
* // initial pixel sizes for the button frame
*
* final int pixDown = 100;
* final int pixAcross = 250;
*
* // labels for the button
*
* final String[] label = {"JCSP", "Rocket Science", "occam-pi", "Goodbye World"};
*
* // the event channel is wired up to the button & reports all button presses ...
*
* final One2OneChannel event = Channel.one2one (new OverWriteOldestBuffer (10));
*
* // the configure channel is wired up to the button ...
*
* final One2OneChannel configure = Channel.one2one ();
*
* // make the framed button (connecting up its wires) ...
*
* final FramedButton button =
* new FramedButton (
* "FramedButton Demo", pixDown, pixAcross, configure.in (), event.out ()
* );
*
* // testrig ...
*
* new Parallel (
*
* new CSProcess[] {
*
* button,
*
* new CSProcess () {
*
* public void run () {
*
* int i = 0;
*
* while (true) {
* configure.out ().write (label[i]);
* i = (i + 1) % label.length;
* final String s = (String) event.in ().read ();
* System.out.println ("Button `" + s + "' pressed ...");
* }
*
* }
*
* }
*
* }
* ).run ();
*
* }
*
* }
*
*
* @see org.jcsp.awt.ActiveButton
* @see org.jcsp.plugNplay.FramedButtonArray
* @see org.jcsp.plugNplay.FramedButtonGrid
* @see org.jcsp.plugNplay.FramedScrollbar
*
* @author P.H. Welch
*
*/
//}}}
public final class FramedButton implements CSProcess {
/** The frame for the button */
private final ActiveClosingFrame activeClosingFrame;
/** The button */
private final ActiveButton button;
/**
* Construct a framed button process.
* * * @param title the title for the frame (must not be null) * @param pixDown the pixel hieght of the frame (must be at least 100) * @param pixAcross the pixel width of the frame (must be at least 100) * @param configure the configure channel for the button (must not be null) * @param event the event channel from the button (must not be null) * */ public FramedButton (String title, int pixDown, int pixAcross, ChannelInput configure, ChannelOutput event) { // check everything ... if (title == null) { throw new IllegalArgumentException ( "From FramedButton (title == null)" ); } if ((pixDown < 100) || (pixAcross < 100)) { throw new IllegalArgumentException ( "From FramedButton (pixDown < 100) || (pixAcross < 100)" ); } if ((configure == null) || (event == null)) { throw new IllegalArgumentException ( "From FramedButtonGrid (configure == null) || (event == null)" ); } // OK - now build ... activeClosingFrame = new ActiveClosingFrame (title); final ActiveFrame activeFrame = activeClosingFrame.getActiveFrame (); button = new ActiveButton (configure, event); activeFrame.setSize (pixAcross, pixDown); activeFrame.add (button); activeFrame.setVisible (true); } /** * The main body of this process. */ public void run () { new Parallel ( new CSProcess[] { activeClosingFrame, button } ).run (); } } jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/DynamicDelta.java 0000644 0000000 0000000 00000016035 11105701167 020322 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.plugNplay; import java.util.*; import org.jcsp.lang.*; /** * This process broadcasts objects arriving on its input channel in parallel * to its output channel array -- those output channels can be changed dynamically. * *
Process Diagram
*
Description
* A DynamicDelta process is a broadcasting node whose array of broadcasting * channels can be changed dynamically. Any process can become one of the recipients * of the broadcast by sending the DynamicDelta a channel on which it will be * listening. A process may leave the broadcast be re-sending that same channel. ** In each cycle, DynamicDelta waits for either its in or configure * channel to become ready, giving priority to configure. *
* Anything arriving from in is broadcast in parallel down each element * of its array of out channels. *
* The configure channel delivers ChannelOutput channels -- anything * else is discarded. If the delivered ChannelOutput channel is not * one of the channels already in the output array, it is added -- otherwise it is removed. *
*
*
Channel Protocols
*| Input Channels | *||
|---|---|---|
| in | *java.lang.Object | ** The in Channel can accept data of any Class. * | *
| in | *org.jcsp.lang.ChannelOutput | ** The configure Channel accepts Objects of type {@link org.jcsp.lang.ChannelOutput} only. * | *
| Output Channels | *||
| out[] | *java.lang.Object | ** The output Channels will carry a broadcast of whatever * is sent down the in Channel. * | *
Process Diagram
*
Description
* ProcessRead is a process that performs a single read * from its in channel and then terminates. It stores * the read Object in the public value field of * this process (which is safe to examine after the process * has terminated and before it is next run). ** ProcessRead declaration, construction and use should normally * be localised within a single method -- so we feel no embarassment about * its public field. Its only (envisaged) purpose is as described in * the example below. *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| in | *java.lang.Object | ** The in Channel can accept data of any Class. * | *
Example
* ProcessRead is designed to simplify reading in parallel * from channels. Make as many instances as there * are channels, binding each instance to a different channel, * together with a {@link org.jcsp.lang.Parallel} object in which to run them: *
* ChannelInput in0, in1;
* .
* .
* .
* ProcessRead read0 = new ProcessRead (in0);
* ProcessRead read1 = new ProcessRead (in1);
* CSProcess parRead01 = new Parallel (new CSProcess[] {in0, in1});
*
* The above is best done once, before any looping over the
* parallel read commences. A parallel read can now be performed
* at any time (and any number of times) by executing:
* * parRead01.run (); ** This terminates when, and only when, both reads have completed -- * the events may occur in any order. The values read may then * be found in read0.value and read1.value, where they * may be safely accessed up until the time that parRead01 is run again. * * @see org.jcsp.lang.Parallel * @see org.jcsp.plugNplay.ProcessWrite * @see org.jcsp.plugNplay.ints.ProcessReadInt * @see org.jcsp.plugNplay.ints.ProcessWriteInt * * @author P.H. Welch and P.D. Austin */ public class ProcessRead implements CSProcess { /** The Object read from the channel */ public Object value; /** The channel from which to read */ private ChannelInput in; /** * Construct a new ProcessRead. * * @param in the channel from which to read */ public ProcessRead(ChannelInput in) { this.in = in; } /** * The main body of this process. */ public void run() { value = in.read(); } } jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/Plex2.java 0000644 0000000 0000000 00000013236 11105701167 016756 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.plugNplay; import org.jcsp.lang.*; /** * Fair multiplexes two Object streams into one. *
Process Diagram
* ** in0 _______ * -->--| | out * in1 | Plex2 |-->-- * -->--|_______| **
Description
* Plex2 is a process whose output stream is a fair multiplexing * of its input streams. It makes no assumptions about the traffic patterns occuring * on the input streams and ensures that no input stream will be starved by busy siblings. * It guarantees that if an input stream has data pending, no other stream will be * serviced twice before that data is serviced. *Channel Protocols
*| Input Channels | *||
|---|---|---|
| in0, in1 | *java.lang.Object | ** The input streams. * | *
| Output Channels | *||
| out | *java.lang.Object | ** The multiplexed output stream. * | *
Example
* The following example shows how to use Plex2 in a small program. * The program also uses some of the other plugNplay processes. * *
* import org.jcsp.lang.*;
* import org.jcsp.plugNplay.*;
*
* public class Plex2Example {
*
* public static void main (String[] argv) {
*
* final One2OneChannel[] a = Channel.one2oneArray (2);
* final One2OneChannel[] b = Channel.one2oneArray (2);
* final One2OneChannel c = Channel.one2one ();
*
* new Parallel (
* new CSProcess[] {
* new Fibonacci (a[0].out ()),
* new Squares (a[1].out ()),
* new Sign ("Fibonacci ", a[0].in (), b[0].out ()),
* new Sign (" Squares ", a[1].in (), b[1].out ()),
* new Plex2 (b[0].in (), b[1].in (), c.out ()),
* new Printer (c.in (), "", "\n")
* }
* ).run ();
*
* }
*
* }
*
* *
Implemntation Note
* For information, here is the run method for this process: * *
* public void run () {
* AltingChannelInput[] input = {in0, in1}; // in0 and in1 are the input channels
* Alternative alt = new Alternative (input);
* while (true) {
* out.write (input[alt.fairSelect ()].read ()); // out is the output channel
* }
* }
*
*
* @see org.jcsp.plugNplay.Plex
* @see org.jcsp.plugNplay.Multiplex
*
* @author P.H. Welch
*/
public final class Plex2 implements CSProcess
{
/** The first input Channel */
private final AltingChannelInput in0;
/** The second input Channel */
private final AltingChannelInput in1;
/** The output Channel */
private final ChannelOutput out;
/**
* Construct a new Plex2 process with the input channels
* in0 and in1 and the output channel out.
* The ordering of the input channels makes no difference
* to the behaviour of this process.
*
* @param in0 an input channel
* @param in1 an input channel
* @param out the output channel
*/
public Plex2(AltingChannelInput in0, AltingChannelInput in1, ChannelOutput out)
{
this.in0 = in0;
this.in1 = in1;
this.out = out;
}
/**
* The main body of this process.
*/
public void run()
{
AltingChannelInput[] input = {in0, in1};
Alternative alt = new Alternative(input);
while (true)
out.write(input[alt.fairSelect()].read());
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/Successor.java 0000644 0000000 0000000 00000010566 11105701167 017740 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.plugNplay;
import org.jcsp.lang.*;
/**
* Adds one to each Integer in the stream flowing through.
* Process Diagram
*
Description
* Successor increments each Integer that flows through it. **
Channel Protocols
*| Input Channels | *||
|---|---|---|
| in | *java.lang.Number | ** The Channel can accept data from any subclass of Number. All values * will be converted to ints. * | *
| Output Channels | *||
| out | *java.lang.Integer | ** The output will always be of type Integer. * | *
*
Example
* The following example shows how to use the Successor process in a small program. * The program also uses some of the other building block processes. The * program generates a sequence of numbers and adds one to them and prints * this on the screen. * *
* import org.jcsp.lang.*;
* import org.jcsp.plugNplay.*;
*
* public class SuccessorExample {
*
* public static void main (String[] argv) {
*
* final One2OneChannel a = Channel.one2one ();
* final One2OneChannel b = Channel.one2one ();
*
* new Parallel (
* new CSProcess[] {
* new Numbers (a.out ()),
* new Successor (a.in (), b.out ()),
* new Printer (b.in (), "--> ", "\n")
* }
* ).run ();
*
* }
*
* }
*
*
* @author P.H. Welch and P.D. Austin
*/
public final class Successor implements CSProcess
{
/** The input Channel */
private final ChannelInput in;
/** The output Channel */
private final ChannelOutput out;
/**
* Construct a new Successor process with the input Channel in and the
* output Channel out.
*
* @param in the input Channel.
* @param out the output Channel.
*/
public Successor(final ChannelInput in, final ChannelOutput out)
{
this.in = in;
this.out = out;
}
/**
* The main body of this process.
*/
public void run()
{
while (true)
{
final int i = ((Integer) in.read()).intValue();
out.write(new Integer(i + 1));
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/Plus.java 0000644 0000000 0000000 00000012411 11105701167 016701 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.plugNplay;
import org.jcsp.lang.*;
/**
* Sums two Integer streams to one stream.
*
* Process Diagram
* ** in0 ______ * -->--| | out * in1 | Plus |-->-- * -->--|______| **
Description
* This is a process with an infinite loop that waits for * a Object of type Number to be sent down each of its input channels. * The loop body adds them together and writes the result as a new Integer * to its output channel. **
Channel Protocols
*| Input Channels | *||
|---|---|---|
| in1,in2 | *java.lang.Number | ** Both Channels can accept data from any subclass of Number. It is * possible to send Floats down one channel and Integers down the * other. However all values will be converted to ints. * | *
| Output Channels | *||
| out | *java.lang.Integer | ** The output will always be of type Integer. * | *
*
Example
* The following example shows how the use of this process in a small program. * The program also uses some of the other building block processes. * It generates two sequences of numbers, adds them together and * prints them to the screen. * *
* import org.jcsp.lang.*;
* import org.jcsp.plugNplay.*;
*
* public class PlusExample {
*
* public static void main (String[] argv) {
*
* final One2OneChannel a = Channel.one2one ();
* final One2OneChannel b = Channel.one2one ();
* final One2OneChannel c = Channel.one2one ();
*
* new Parallel (
* new CSProcess[] {
* new Numbers (a.out ()),
* new Numbers (b.out ()),
* new Plus (a.in (), b.in (), c.out ()),
* new Printer (c.in (), "--> ", "\n")
* }
* ).run ();
*
* }
*
* }
*
*
* @author P.H. Welch and P.D. Austin
*/
public final class Plus implements CSProcess
{
/** The first input Channel */
private ChannelInput in1;
/** The second input Channel */
private ChannelInput in2;
/** The output Channel */
private ChannelOutput out;
/**
* Construct a new Plus process with the input Channels in1 and in2 and the
* output Channel out. The ordering of the Channels in1 and in2 make
* no difference to the functionality of this process.
*
* @param in1 The first input Channel
* @param in2 The second input Channel
* @param out The output Channel
*/
public Plus(ChannelInput in1, ChannelInput in2, ChannelOutput out)
{
this.in1 = in1;
this.in2 = in2;
this.out = out;
}
/**
* The main body of this process.
*/
public void run()
{
ProcessRead[] parRead = {new ProcessRead(in1), new ProcessRead(in2)};
Parallel par = new Parallel(parRead);
while (true)
{
par.run();
int i1 = ((Number) parRead[0].value).intValue();
int i2 = ((Number) parRead[1].value).intValue();
out.write(new Integer(i1 + i2));
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/Multiplex.java 0000644 0000000 0000000 00000013352 11105701167 017746 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.plugNplay;
import org.jcsp.lang.*;
/**
* Fair multiplexes its input Object stream array into one output stream
* (carrying source channel and data pairs).
* Process Diagram
*
Description
* Multiplex is a process to convert multiple streams of * objects to a single stream in such a way that it can be * {@link Demultiplex de-multiplexed} later. * The protocol on the outgoing multiplexed stream consists of * an Integer, that represents the channel identity of the * multiplexed data, followed by the multiplexed data. ** The ordering of the channels in the in array makes * no difference to the functionality of this process -- the multiplexing * services all channels fairly. *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| in[] | *java.lang.Object | ** The input streams. * | *
| Output Channels | *||
| out | *java.lang.Integer, java.lang.Object | ** The channel index followed by the multiplexed data. * | *
*
Example
* The following example shows how to use MultiplexInt in a small program. *
* import org.jcsp.lang.*;
* import org.jcsp.plugNplay.*;
*
* public class MultiplexExample {
*
* public static void main (String[] argv) {
*
* final One2OneChannel[] a = Channel.one2oneArray (3);
* final One2OneChannel b = Channel.one2one ();
*
* new Parallel (
* new CSProcess[] {
* new Numbers (a[0].out ()),
* new Fibonacci (a[1].out ()),
* new Squares (a[2].out ()),
* new Multiplex (Channel.getInputArray (a), b.out ()),
* new CSProcess () {
* public void run () {
* String[] key = {"Numbers ",
* " Fibonacci ",
* " Squares "};
* while (true) {
* int channel = ((Integer) b.in ().read ()).intValue ();
* System.out.print (key[channel]); // print channel source
* int n = ((Integer) b.in ().read ()).intValue ();
* System.out.println (n); // print multiplexed data
* }
* }
* }
* }
* ).run ();
*
* }
*
* }
*
*
* @see org.jcsp.plugNplay.Demultiplex
* @see org.jcsp.plugNplay.Paraplex
* @see org.jcsp.plugNplay.Deparaplex
* @see org.jcsp.plugNplay.Plex
*
* @author P.H. Welch and P.D. Austin and P.H. Welch
*/
public final class Multiplex implements CSProcess
{
/** The input channels */
private final AltingChannelInput[] in;
/** The output channel */
private final ChannelOutput out;
/**
* Construct a new Multiplex process with the input Channel in and the output
* Channels out. The ordering of the Channels in the in array make
* no difference to the functionality of this process -- the multiplexing
* services all channels fairly.
*
* @param in the input channels
* @param out the output channel
*/
public Multiplex(final AltingChannelInput[] in, final ChannelOutput out)
{
this.in = in;
this.out = out;
}
/**
* The main body of this process.
*/
public void run()
{
final Alternative alt = new Alternative(in);
while (true)
{
int index = alt.fairSelect();
out.write(new Integer(index));
out.write(in[index].read());
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/package.html 0000644 0000000 0000000 00000002575 10522104430 017376 0 ustar
This provides an assortment of plug-and-play CSP components to wire together
(with Object-carrying wires) and reuse.
Primarilly they are for education and demonstration purposes, but some
have value for general applications (e.g. {@link org.jcsp.plugNplay.Delta},
{@link org.jcsp.plugNplay.DynamicDelta}, {@link org.jcsp.plugNplay.Plex}, {@link org.jcsp.plugNplay.Multiplex}, {@link org.jcsp.plugNplay.Demultiplex},
{@link org.jcsp.plugNplay.ProcessRead}, {@link org.jcsp.plugNplay.ProcessWrite}, ...).
The educational purpose is to demonstrate how simple it is to build layered networks of communicating processes. Each component works to a clean channel interface. Component instances can just be wired together. A network of such components is itself another (CSP) component. Network design and analysis takes place independently at each level - we do not have to think about the whole network hierarchy to reason about each level. This enables us to construct components with arbitrarilly rich behaviour without running into combinatorial explosions of complexity.
Examples are given of networks with 20-30 processes (threads). Because of the component layering, we never need to consider more than about 5 at a time and it is easy to see what they do and that they are without deadlock, livelock, starvation or race-hazard problems. jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/Nand.java 0000644 0000000 0000000 00000012750 11105701167 016644 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.plugNplay; import org.jcsp.lang.*; /** * Bitwise nands two Integer streams to one stream. * *
Process Diagram
* ** in0 ______ * -->--| | out * in1 | Nand |-->-- * -->--|______| **
Description
* This is a process with an infinite loop that waits for * a Object of type Number to be sent down each of its input channels. * The loop body then calculates the bitwise NAND on the values of the * two Numbers and writes the result as a new Integer to its output channel. **
Channel Protocols
*| Input Channels | *||
|---|---|---|
| in1,in2 | *java.lang.Number | ** Both Channels can accept data from any subclass of Number. It is * possible to send Floats down one channel Nand Integers down the * other. However all values will be converted to ints. * | *
| Output Channels | *||
| out | *java.lang.Integer | ** The output will always be of type Integer. * | *
*
Example
* The following example shows how the use of this process in a small program. * The program also uses some of the other building block processes. * It generates a sequence of numbers, rounds each odd number down to * the nearest even number, negates them and prints them to the screen. * *
* import org.jcsp.lang.*;
* import org.jcsp.plugNplay.*;
*
* public class NandExample {
*
* public static void main (String[] argv) {
*
* final One2OneChannel a = Channel.one2one ();
* final One2OneChannel b = Channel.one2one ();
* final One2OneChannel c = Channel.one2one ();
* final One2OneChannel d = Channel.one2one ();
*
* new Parallel (
* new CSProcess[] {
* new Numbers (a.out ()),
* new Generate (b.out (), Integer.MAX_VALUE - 1),
* new Nand (a.in (), b.in (), c.out ()),
* new Successor (c.in (), d.out ()),
* new Printer (d.in (), "--> ", "\n")
* }
* ).run ();
*
* }
*
* }
*
*
* @author P.H. Welch and P.D. Austin
*/
public final class Nand implements CSProcess
{
/** The first input Channel */
private ChannelInput in1;
/** The second input Channel */
private ChannelInput in2;
/** The output Channel */
private ChannelOutput out;
/**
* Construct a new Nand process with the input Channels in1 and in2 and the
* output Channel out. The ordering of the Channels in1 and in2 make
* no difference to the functionality of this process.
*
* @param in1 the first input Channel
* @param in2 the second input Channel
* @param out the output Channel
*/
public Nand(ChannelInput in1, ChannelInput in2, ChannelOutput out)
{
this.in1 = in1;
this.in2 = in2;
this.out = out;
}
/**
* The main body of this process.
*/
public void run()
{
ProcessRead[] procs = {new ProcessRead(in1), new ProcessRead(in2)};
Parallel par = new Parallel(procs);
while (true)
{
par.run();
int i1 = ((Number)procs[0].value).intValue();
int i2 = ((Number)procs[1].value).intValue();
out.write(new Integer(~ (i1 & i2)));
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/Tail.java 0000644 0000000 0000000 00000007647 11105701167 016666 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.plugNplay;
import org.jcsp.lang.*;
/**
* The output stream is the tail of its input stream.
* Process Diagram
*
Description
* The first Object (i.e. head) of its input stream is not forwarded. * The rest (i.e. tail) is copied through unchanged. ** Two inputs are needed before any output * is produced but, thereafter, one output is produced for each input. *
*
Channel Protocols
*| Input Channels | *||
|---|---|---|
| in | *java.lang.Object | ** The in Channel can accept data of any Class. * | *
| Output Channels | *||
| out | *java.lang.Object | ** The out Channel will send data of the same type * as that sent down the in Channel. * | *
*
Implementation Note
* The implementation uses an {@link Identity} process for the copy loop: *
* public void run () {
* in.read (); // accept, but discard, the first item
* new Identity (in, out).run (); // copy the rest of the stream
* }
*
*
* @author P.H. Welch and P.D. Austin
*/
public final class Tail implements CSProcess
{
/** The input Channel */
private ChannelInput in;
/** The output Channel */
private ChannelOutput out;
/**
* Construct a new Tail process with the input Channel in and the
* output Channel out.
*
* @param in the input Channel
* @param out the output Channel
*/
public Tail(ChannelInput in, ChannelOutput out)
{
this.in = in;
this.out = out;
}
/**
* The main body of this process.
*/
public void run()
{
in.read();
new Identity(in, out).run();
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/Identity.java 0000644 0000000 0000000 00000007320 11105701167 017552 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.plugNplay;
import org.jcsp.lang.*;
/**
* This copies its input stream to its output stream unchanged.
* Process Diagram
*
Description
* This is a process that simply copies its input stream * to its output stream. The difference between a channel and a channel * into which an Identity process has been spliced is that the * latter has a buffering capacity of one more than the channel * (which is zero, unless explicitly constructed with a buffer). **
Channel Protocols
*| Input Channels | *||
|---|---|---|
| in | *java.lang.Object | ** The in Channel can accept data of any class. * | *
| Output Channels | *||
| out | *java.lang.Object | ** The out Channel sends the the same type of data (in * fact, the same data) as is input. * | *
Process Diagram
*
Description
* FixedDelayInt is a process that delays passing on input to its output * by a constant delay. *Channel Protocols
*| Input Channels | *||
|---|---|---|
| in | *int | ** All channels in this package carry integers. * | *
| Output Channels | *||
| out | *int | ** All channels in this package carry integers. * | *
Process Diagram
* ** in0 __________ * -->--| | out * in1 | Plex2Int |-->-- * -->--|__________| **
Description
* Plex2Int is a process whose output stream is a fair multiplexing * of its input streams. It makes no assumptions about the traffic patterns occuring * on the input streams and ensures that no input stream will be starved by busy siblings. * It guarantees that if an input stream has data pending, no other stream will be * serviced twice before that data is serviced. *Channel Protocols
*| Input Channels | *||
|---|---|---|
| in0, in1 | *int | ** The input streams. * | *
| Output Channels | *||
| out | *int | ** The multiplexed output stream. * | *
Example
* The following example shows how to use Plex2Int in a small program. * The program also uses some of the other plugNplay processes. * *
* import org.jcsp.lang.*;
* import org.jcsp.plugNplay.ints.*;
*
* public class Plex2IntExample {
*
* public static void main (String[] argv) {
*
* final One2OneChannelInt a = Channel.one2oneInt ();
* final One2OneChannelInt b = Channel.one2oneInt ();
* final One2OneChannelInt c = Channel.one2oneInt ();
*
* new Parallel (
* new CSProcess[] {
* new FibonacciInt (a.out ()),
* new SquaresInt (b.out ()),
* new Plex2Int (a.in (), b.in (), c.out ()),
* new PrinterInt (c.in (), "--> ", "\n")
* }
* ).run ();
*
* }
*
* }
*
* Note: this example does not produce easily understandable output, since
* the multiplexed stream contains only numbers -- there is no indication
* of the streams from which they were sourced. To get that indication,
* we can either use {@link MultiplexInt} or sign each int
* stream to be multiplexed with {@link SignInt} and multiplex with
* {@link org.jcsp.plugNplay.Plex2}.
* *
Implemntation Note
* For information, here is the run method for this process: * *
* public void run () {
* AltingChannelInputInt[] input = {in0, in1}; // in0 and in1 are the input channels
* Alternative alt = new Alternative (input);
* while (true) {
* out.write (input[alt.fairSelect ()].read ()); // out is the output channel
* }
* }
*
*
* @see org.jcsp.plugNplay.ints.PlexInt
* @see org.jcsp.plugNplay.ints.MultiplexInt
*
* @author P.H. Welch
*/
public final class Plex2Int implements CSProcess
{
/** The first input Channel */
private final AltingChannelInputInt in0;
/** The second input Channel */
private final AltingChannelInputInt in1;
/** The output Channel */
private final ChannelOutputInt out;
/**
* Construct a new Plex2Int process with the input channels
* in0 and in1 and the output channel out.
* The ordering of the input channels makes no difference
* to the behaviour of this process.
*
* @param in0 an input channel
* @param in1 an input channel
* @param out the output channel
*/
public Plex2Int(AltingChannelInputInt in0, AltingChannelInputInt in1, ChannelOutputInt out)
{
this.in0 = in0;
this.in1 = in1;
this.out = out;
}
/**
* The main body of this process.
*/
public void run()
{
AltingChannelInputInt[] input = {in0, in1};
Alternative alt = new Alternative(input);
while (true)
out.write(input[alt.fairSelect()].read());
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/ints/ProcessReadInt.java 0000644 0000000 0000000 00000011401 11105701167 021616 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.plugNplay.ints;
import org.jcsp.lang.*;
/**
* Reads one int from its input channel.
* Process Diagram
*
Description
* ProcessReadInt is a process that performs a single read * from its in channel and then terminates. It stores * the read int in the public value field of * this process (which is safe to examine after the process * has terminated and before it is next run). ** ProcessReadInt declaration, construction and use should normally * be localised within a single method -- so we feel no embarassment about * its public field. Its only (envisaged) purpose is as described in * the example below. *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| in | *int | ** All channels in this package carry integers. * | *
Example
* ProcessReadInt is designed to simplify reading in parallel * from channels. Make as many instances as there * are channels, binding each instance to a different channel, * together with a {@link org.jcsp.lang.Parallel} object in which to run them: *
* ChannelInputInt in0, in1;
* .
* .
* .
* ProcessReadInt read0 = new ProcessReadInt (in0);
* ProcessReadInt read1 = new ProcessReadInt (in1);
* CSProcess parRead01 = new Parallel (new CSProcess[] {in0, in1});
*
* The above is best done once, before any looping over the
* parallel read commences. A parallel read can now be performed
* at any time (and any number of times) by executing:
* * parRead01.run (); ** This terminates when, and only when, both reads have completed -- * the events may occur in any order. The values read may then * be found in read0.value and read1.value, where they * may be safely accessed up until the time that parRead01 is run again. * * @see org.jcsp.lang.Parallel * @see org.jcsp.plugNplay.ProcessRead * @see org.jcsp.plugNplay.ProcessWrite * @see org.jcsp.plugNplay.ints.ProcessWriteInt * * @author P.H. Welch and P.D. Austin */ public class ProcessReadInt implements CSProcess { /** The int read from the channel */ public int value; /** The channel from which to read */ private ChannelInputInt in; /** * Construct a new ProcessReadInt. * * @param in the channel from which to read */ public ProcessReadInt(ChannelInputInt in) { this.in = in; } /** * The main body of this process. */ public void run() { value = in.read(); } } jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/ints/DeparaplexInt.java 0000644 0000000 0000000 00000014225 11105701167 021500 0 ustar ////////////////////////////////////////////////////////////////////// // // // JCSP ("CSP for Java") Libraries // // Copyright (C) 1996-2008 Peter Welch and Paul Austin. // // 2001-2004 Quickstone Technologies Limited. // // // // This library is free software; you can redistribute it and/or // // modify it under the terms of the GNU Lesser General Public // // License as published by the Free Software Foundation; either // // version 2.1 of the License, or (at your option) any later // // version. // // // // This library is distributed in the hope that it will be // // useful, but WITHOUT ANY WARRANTY; without even the implied // // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // // PURPOSE. See the GNU Lesser General Public License for more // // details. // // // // You should have received a copy of the GNU Lesser General // // Public License along with this library; if not, write to the // // Free Software Foundation, Inc., 59 Temple Place, Suite 330, // // Boston, MA 02111-1307, USA. // // // // Author contact: P.H.Welch@kent.ac.uk // // // // // ////////////////////////////////////////////////////////////////////// package org.jcsp.plugNplay.ints; import org.jcsp.lang.*; /** * This demultiplexes data from its input channel to its output channel array. * *
Process Diagram
*
Description
* DeparaplexInt is a process to convert the single stream of * int[] packets sent from a {@link ParaplexInt} process on the other * end of its in channel back to separate streams (its out * channels). It assumes that {@link ParaplexInt} operates on the same * size array of channels as its out array. It conforms to * contract required by {@link ParaplexInt} for a process receiving its packets. ** In each cycle, it inputs one packet and outputs its contents in parallel * to each of its output channels. * The parallel output means that the process will wait until each item is accepted * by every channel -- in whatever order is demanded by its environment. * The ordering of the channels in the out array, therefore, makes * no difference to the functionality of this process. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| in | *int[] | ** A packet carrying the paraplexed data. * |
| Output Channels | *||
| out[] | *int | ** Most channels in this package carry integers. * | *
Example
*
* import org.jcsp.lang.*;
* import org.jcsp.plugNplay.ints.*;
*
* public class DeparaplexIntExample {
*
* public static void main (String[] args) {
*
* final One2OneChannelInt[] a = Channel.one2oneIntArray (3);
* final One2OneChannel b = Channel.one2one ();
* final One2OneChannelInt[] c = Channel.one2oneIntArray (3);
* final One2OneChannel d = Channel.one2one ();
*
* new Parallel (
* new CSProcess[] {
* new NumbersInt (a[0].out ()),
* new SquaresInt (a[1].out ()),
* new FibonacciInt (a[2].out ()),
* new ParaplexInt (Channel.getInputArray (a), b.out ()),
* new DeparaplexInt (b.in (), Channel.getOutputArray (c)),
* new ParaplexInt (Channel.getInputArray (c), d.out ()),
* new CSProcess () {
* public void run () {
* System.out.println ("\n\t\tNumbers\t\tSquares\t\tFibonacci\n");
* while (true) {
* int[] data = (int[]) d.in ().read ();
* for (int i = 0; i < data.length; i++) {
* System.out.print ("\t\t" + data[i]);
* }
* System.out.println ();
* }
* }
* }
* }
* ).run ();
* }
*
* }
*
*
* @see org.jcsp.plugNplay.ints.ParaplexInt
* @see org.jcsp.plugNplay.ints.MultiplexInt
* @see org.jcsp.plugNplay.ints.DemultiplexInt
*
* @author P.H. Welch
*/
public final class DeparaplexInt implements CSProcess
{
/** The input Channel */
private final ChannelInput in;
/** The output Channels */
private final ChannelOutputInt[] out;
/**
* Construct a new DeparaplexInt process with the input Channel in and the output
* Channels out. The ordering of the Channels in the out array make
* no difference to the functionality of this process.
*
* @param in the input channel
* @param out the output Channels
*/
public DeparaplexInt(final ChannelInput in, final ChannelOutputInt[] out)
{
this.in = in;
this.out = out;
}
/**
* The main body of this process.
*/
public void run()
{
final ProcessWriteInt[] outputProcess = new ProcessWriteInt[out.length];
for (int i = 0; i < out.length; i++)
outputProcess[i] = new ProcessWriteInt(out[i]);
Parallel parOutput = new Parallel(outputProcess);
while (true)
{
int[] data = (int[]) in.read();
for (int i = 0; i < data.length; i++)
outputProcess[i].value = data[i];
parOutput.run();
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/ints/FibonacciInt.java 0000644 0000000 0000000 00000011325 11105701167 021266 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.plugNplay.ints;
import org.jcsp.lang.*;
/**
* This generates the Fibonacci sequence on its output channel.
*
* CSProcess Diagram
*External View
* ** ______________ * | | out * | FibonacciInt |------> * |______________| **
Internal View
* *
* _______________________________________
* | |
* | _______________ ___________ |
* | | | | | | out
* | | {@link PrefixInt PrefixInt (0)} |-->--| {@link Delta2Int Delta2Int} |------>--
* | |_______________| |___________| |
* | | | |
* | ^ v |
* | ______|________ _____|____ |
* | | | | | |
* | | {@link PrefixInt PrefixInt (1)} |--<--| {@link PairsInt PairsInt} | |
* | |_______________| |__________| |
* | |
* | FibonacciInt |
* |_______________________________________|
*
* *
Description
* FibonacciInt generates the sequence of Fibonacci * numbers on its output channel. *Channel Protocols
*| Output Channels | *||
|---|---|---|
| out | *int | ** All channels in this package carry integers. * | *
Process Diagram
** ________________ * | | out * | RegularInt (n) |-->-- * |________________| **
Description
* This process generates a constant stream of Integers at a regular rate * – at least, it does its best! * If the consumption of data is less than the set rate, that rate cannot be sustained. * If the consumption failure is only temporary, the set rate will be restored * when consumption resumes. ** The interval (in msecs) defining the output flow rate is given by a constructor argument. *
Channel Protocols
*| Output Channels | *||
|---|---|---|
| out | *int | ** A constant value is sent down this channel at a regular rate. * | *
Process Diagram
*
Description
* DemultiplexInt is a process to convert the single stream of * ints sent from a {@link MultiplexInt} process on the other * end of its in channel back to separate streams (its out * channels). It assumes that {@link MultiplexInt} operates on the same * size array of channels as its out array. ** The protocol on the incoming multiplexed stream consists of * an int, that represents the channel identity of the * multiplexed data, followed by the multiplexed data. *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| in | *int, int | ** An in message is an index followed by the multiplexed data. * | *
| Output Channels | *||
| out[] | *java.lang.Object | ** All channels in this package carry integers. * | *
Process Diagram
*
Description
* PlexInt is a process whose output stream is a fair multiplexing * of its input streams. It makes no assumptions about the traffic patterns occuring * on the input streams and ensures that no input stream will be starved by busy siblings. * It guarantees that if an input stream has data pending, no other stream will be * serviced twice before that data is serviced. *Channel Protocols
*| Input Channels | *||
|---|---|---|
| in[] | *int | ** The input streams. * | *
| Output Channels | *||
| out | *int | ** The multiplexed output stream. * | *
Example
* The following example shows how to use PlexInt in a small program. *
* import org.jcsp.lang.*;
* import org.jcsp.plugNplay.ints.*;
*
* public class PlexIntExample {
*
* public static void main (String[] argv) {
*
* final One2OneChannelInt[] a = Channel.one2oneIntArray (3);
* final One2OneChannelInt b = Channel.one2oneInt ();
*
* new Parallel (
* new CSProcess[] {
* new NumbersInt (a[0].out ()),
* new FibonacciInt (a[1].out ()),
* new SquaresInt (a[2].out ()),
* new PlexInt (Channel.getInputArray (a), b.out ()),
* new PrinterInt (b.in (), "--> ", "\n")
* }
* ).run ();
*
* }
*
* }
*
* Note: this example does not produce easily understandable output, since
* the multiplexed stream contains only numbers -- there is no indication
* of the streams from which they were sourced. To get that indication,
* we can either use {@link MultiplexInt} or sign each int
* stream to be multiplexed with {@link SignInt} and multiplex with
* {@link org.jcsp.plugNplay.Plex}.
* *
Implemntation Note
* For information, here is the run method for this process: * *
* public void run () {
* Alternative alt = new Alternative (in); // in is the input channel array
* while (true) {
* out.write (in[alt.fairSelect ()].read ()); // out is the output channel
* }
* }
*
*
* @see org.jcsp.plugNplay.ints.Plex2Int
* @see org.jcsp.plugNplay.ints.MultiplexInt
*
* @author P.H. Welch
*/
public final class PlexInt implements CSProcess
{
/** The first input Channel */
private final AltingChannelInputInt[] in;
/** The output Channel */
private final ChannelOutputInt out;
/**
* Construct a new PlexInt process with input channels
* in and output channel out.
* The ordering of the input channels makes no difference
* to the behaviour of this process.
*
* @param in the input channels
* @param out the output channel
*/
public PlexInt(AltingChannelInputInt[] in, ChannelOutputInt out)
{
this.in = in;
this.out = out;
}
/**
* The main body of this process.
*/
public void run()
{
Alternative alt = new Alternative(in);
while (true)
out.write(in[alt.fairSelect()].read());
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/ints/IdentityInt.java 0000644 0000000 0000000 00000007264 11105701167 021211 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.plugNplay.ints;
import org.jcsp.lang.*;
/**
* This copies its input stream to its output stream unchanged.
* Process Diagram
*
Description
* This is a process that simply copies its input stream * to its output stream. The difference between a channel and a channel * into which an IdentityInt process has been spliced is that the * latter has a buffering capacity of one more than the channel * (which is zero, unless explicitly constructed with a buffer). **
Channel Protocols
*| Input Channels | *||
|---|---|---|
| in | *int | ** All channels in this package carry integers. * | *
| Output Channels | *||
| out | *int | ** All channels in this package carry integers. * | *
Process Diagram
*
Description
* MergeInt is a process whose output stream is the ordered merging * of the integers on its input streams. It assumes that each input stream is * strictly increasing (i.e. with no repeats) sequence of integers. * It generates a strictly increasing output stream containing all -- * and only -- the numbers from its input streams (eliminating any duplicates). ** Warning: this process assumes that its input channel array has at least * two elements. *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| in[] | *int | ** Assume: in.length >= 2. * | *
| Output Channels | *||
| out | *int | ** All channels in this package carry integers. * | *
*
Example
* The following example shows how to use MergeInt in a small program. * The program also uses some of the other plugNplay processes. The * program prints, in ascending order (up to Integer.MAX_VALUE), all integers * whose prime factors consist only of 2, 3, 5 and 7. Curious readers may like * to reason why the infinitely buffered channels are needed. * *
* import org.jcsp.lang.*;
* import org.jcsp.util.ints.*;
* import org.jcsp.plugNplay.ints.*;
*
* public class MergeIntExample {
*
* public static void main (String[] argv) {
*
* final One2OneChannelInt[] a = Channel.one2oneIntArray (5);
* final One2OneChannelInt[] b = Channel.one2oneIntArray (4, new InfiniteBufferInt ());
* final One2OneChannelInt c = Channel.one2oneInt ();
* final One2OneChannelInt d = Channel.one2oneInt ();
*
* new Parallel (
* new CSProcess[] {
* new MultInt (2, a[0].in (), b[0].out ()),
* new MultInt (3, a[1].in (), b[1].out ()),
* new MultInt (5, a[2].in (), b[2].out ()),
* new MultInt (7, a[3].in (), b[3].out ()),
* new MergeInt (Channel.getInputArray (b), c.out ()),
* new PrefixInt (1, c.in (), d.out ()),
* new DeltaInt (d.in (), Channel.getOutputArray (a)),
* new PrinterInt (a[4].in (), "--> ", "\n")
* }
* ).run ();
*
* }
*
* }
*
* *
Implementation Note
* The implementation sets up a balanced binary tree of parallel * Merge2Int processes to fan-in the merge from * its external input channels to its external output. It's a nice * example of recursion and parallelism -- here's the run * method: *
* public void run () {
* final int n = in.length; // deduce: n >= 2
* switch (n) {
* case 2:
* new Merge2Int (in[0], in[1], out).run ();
* break;
* case 3:
* final One2OneChannelInt c = Channel.one2oneInt ();
* new Parallel (
* new CSProcess[] {
* new Merge2Int (in[0], in[1], c.out ()),
* new Merge2Int (c.in (), in[2], out)
* }
* ).run ();
* break;
* default: // deduce: n >= 4
* final int n2 = n/2;
* ChannelInputInt[] bottom = new ChannelInputInt[n2];
* ChannelInputInt[] top = new ChannelInputInt[n - n2];
* for (int i = 0; i < n2; i++) {
* bottom[i] = in[i];
* }
* for (int i = n2; i < n; i++) {
* top[i - n2] = in[i];
* }
* final One2OneChannelInt[] d = Channel.one2oneIntArray (2);
* new Parallel (
* new CSProcess[] {
* new MergeInt (bottom, d[0].out ()),
* new MergeInt (top, d[1].out ()),
* new Merge2Int (d[0].in (), d[1].in (), out)
* }
* ).run ();
* break;
* }
* }
*
*
* @see org.jcsp.plugNplay.ints.Merge2Int
*
* @author P.H. Welch
*/
public final class MergeInt implements CSProcess
{
/** The input channels */
final private ChannelInputInt[] in; // assume: in.length >= 2
/** The output channel */
final private ChannelOutputInt out;
/**
* Construct a new Merge2Int process with the input channels
* inand the output channel out.
* The ordering of the input channels makes no difference
* to the behaviour of this process.
*
* @param in the input channels (there must be at least 2)
* @param out the output channel
*/
public MergeInt(ChannelInputInt[] in, ChannelOutputInt out)
{
if (in.length < 2) {
throw new IllegalArgumentException ("Merge must have at least 2 input channels");
}
this.in = in;
this.out = out;
}
/**
* The main body of this process.
*/
public void run()
{
final int n = in.length; // deduce: n >= 2
switch (n)
{
case 2:
new Merge2Int(in[0], in[1], out).run();
break;
case 3:
final One2OneChannelInt c = Channel.one2oneInt();
new Parallel(new CSProcess[]
{
new Merge2Int(in[0], in[1], c.out()),
new Merge2Int(c.in(), in[2], out)
}).run();
break;
default: // deduce: n >= 4
final int n2 = n/2;
ChannelInputInt[] bottom = new ChannelInputInt[n2];
ChannelInputInt[] top = new ChannelInputInt[n - n2];
for (int i = 0; i < n2; i++)
bottom[i] = in[i];
for (int i = n2; i < n; i++)
top[i - n2] = in[i];
final One2OneChannelInt[] d = Channel.one2oneIntArray(2);
new Parallel(new CSProcess[]
{
new MergeInt(bottom, d[0].out()),
new MergeInt(top, d[1].out()),
new Merge2Int(d[0].in(), d[1].in(), out)
}).run();
break;
}
}
}
jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/ints/PrinterInt.java 0000644 0000000 0000000 00000012240 11105701167 021031 0 ustar //////////////////////////////////////////////////////////////////////
// //
// JCSP ("CSP for Java") Libraries //
// Copyright (C) 1996-2008 Peter Welch and Paul Austin. //
// 2001-2004 Quickstone Technologies Limited. //
// //
// This library is free software; you can redistribute it and/or //
// modify it under the terms of the GNU Lesser General Public //
// License as published by the Free Software Foundation; either //
// version 2.1 of the License, or (at your option) any later //
// version. //
// //
// This library is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this library; if not, write to the //
// Free Software Foundation, Inc., 59 Temple Place, Suite 330, //
// Boston, MA 02111-1307, USA. //
// //
// Author contact: P.H.Welch@kent.ac.uk //
// //
// //
//////////////////////////////////////////////////////////////////////
package org.jcsp.plugNplay.ints;
import org.jcsp.lang.*;
import java.io.*;
/**
* Prints each int from its input channel to a PrintStream.
* Process Diagram
*
Description
* PrinterInt is a process for printing each int from its * in channel to a PrintStream object (by default, * System.out). ** For convenience, PrinterInt may be configured with prefix and postfix * strings with which to decorate its output. * *
Channel Protocols
*| Input Channels | *||
|---|---|---|
| in | *int | ** All channels in this package carry integers. * | *
Example
* See the example in {@link MergeInt}. * * @see org.jcsp.lang.Parallel * * @author P.H. Welch and P.D. Austin */ public class PrinterInt implements CSProcess { /** The channel from which to read */ private ChannelInputInt in; /** The stream to which to write */ private PrintStream printStream; /** The string to write in front of each integer */ private String prefix; /** The string to write after each integer */ private String postfix; /** * Construct a new PrinterInt with System.out as * its PrintStream and empty prefix and postfix strings. * * @param in the channel from which to read */ public PrinterInt(final ChannelInputInt in) { this(in, System.out, "", ""); } /** * Construct a new PrinterInt with System.out as * its PrintStream. * * @param in the channel from which to read * @param prefix the string to write in front of each integer * @param postfix the string to write after each integer */ public PrinterInt(final ChannelInputInt in, final String prefix, final String postfix) { this(in, System.out, prefix, postfix); } /** * Construct a new PrinterInt with empty prefix and postfix strings. * * @param in the channel from which to read * @param printStream the stream to which to write */ public PrinterInt(final ChannelInputInt in, final PrintStream printStream) { this(in, printStream, "", ""); } /** * Construct a new PrinterInt. * * @param in he channel from which to read * @param printStream the stream to which to write * @param prefix the string to write in front of each integer * @param postfix the string to write after each integer */ public PrinterInt(final ChannelInputInt in, final PrintStream printStream, final String prefix, final String postfix) { this.in = in; this.printStream = printStream; this.prefix = prefix; this.postfix = postfix; } /** * The main body of this process. */ public synchronized void run() { while (true) { printStream.print(prefix); printStream.print(in.read()); printStream.print(postfix); } } } jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/ints/doc-files/ 0000755 0000000 0000000 00000000000 11410045054 017731 5 ustar jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/ints/doc-files/MultiplexInt1.gif 0000644 0000000 0000000 00000004670 10520670125 023152 0 ustar GIF89a< ÷ $$$888<<<@@@HHHPPPYYYaaaiiiqqquuuyyy}}}………•••¡¡¡¥¥¥®®®²²²¶¶¶¾¾¾ÆÆÆÎÎÎÖÖÖÚÚÚÞÞÞæææîîîòòòöööÿÿÿ , < ÿ M H° Áƒ*\È°¡Ã‡#JœH±¢Å‹3jÜȱ£Ç CŠ I²¤É“(Sª\ɲ¥Ë—0cÊœI³¦Í›8sêÜɳ§O!&HJ´¨Ñ£H“*]Ê´©Ó§P£2µPâ§Õ’ Dʵ«×¯`Ã"mpàªÙ 2œ]ëPÁ¶p1·®Áìú40áàÐï$@ð6®«ö.:ŸÔÀìÔWo½õx§7M2±-Nx]" ¼”Ο3AcÂàk ¼“¶M<¤›‹Né °úúóË î–7ÝŽ#ØS×d6¨3ýikÐcœýž)A!msÓúÓFe¦³½m‚êc˜È€£´h€o |Œé
8²rdyš@—ìEÝYàw ¿ìCä°†Y"Hÿà‚,Í«dË’dÕCüpƒ+¡N" ¸
¦(ú[B¶ aÏ"yRÈŸŒ%7‚$ ^º‘bN `ÅÍh1!LÀpv‘è‹ ^L@¤%Wyctø§ A:‡2ärI E"‡‘rdq é I
‡’û±äo0‰ Mò†“õñdn@) QÚ†”ï1ålPÉ U†•éqek`i Yª†–ã±åip ]’†—Ýñeh€© az†˜×1æfI eb†™Ñqfe é iJ†šË±æc°‰ m2†›ÅñfbÀ) q†œ¿1gaÐÉu
†¹qç_àiyú…ž³±ç^ð Å}â…Ÿñç] ªòE€\ˆAçBÐÓ,.
%ÍCßÑÐLt0MhB.ª–Šz†£fñ¨]È"‘b¤e1iePª˜Œj´M$M‘J%ÃRªÌô15ýÉM“Sȸô¥ª¯~*Ôu§‰‰À©4ªÔ¢>$¸À¦JÕªZõªXͪV·ÊÕ®zõ«`
+W/@€:u! `€ÖÊÖ¶ºõp«\çJ׺Úõ®xÍ+]À³úõ¯€
¬`KØÂö°ˆN@ ; jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/ints/doc-files/PrinterInt1.gif 0000644 0000000 0000000 00000003664 10520670125 022614 0 ustar GIF89aò ÷ $$$(((000444888<<<@@@PPPYYYaaaqqquuuyyy}}}………•••¡¡¡¥¥¥¶¶¶¾¾¾ÆÆÆÎÎÎÖÖÖÚÚÚæææòòòöööÿÿÿ , ò ÿ E H° Áƒ*\È°¡Ã‡#JœH±¢Å‹3jÜȱ£Ç CŠ I²¤É“(Sª\ɲ¥Ë—0cÊœI³¦Mš$èÜɳ§ÏŸ@ƒ
J´¨Ñ£H‡Zqsd
’JJµªÕ«? øÐ4$…]Ê|@A¬G̪åhÁÁÚhßʵØv.Ƹvó>¬«—"Þ¾€ò
ñ/áÃ"#fhx1`ÅŽ6Žœ2eƒ“/˵¬y`æÎj9ƒþ Z¬èΤKw=9µê›¬/»~]36åÙ´gÚŽŒ;wÌÝŽ{û~ |±ðá-‹#>Ž|¥òÃÌ›§|N8ºô“Ô[¿^2;àíÜGzÿï >|ÈñzË›ÿˆ>¯úõ ÛÛ}£ü¹ôëg¼/7¿þ‹ü½å߸րNd Z&Ñ‚f5èà^nù&á„
A(Ö….¤aX v˜Ð‡]…(âA$6e≥xÓŠ,äâI €ÐŒ1&V!aLpcZ9’4£I pÅAŠ4dI=ŠP€ÀÀA8Ƹ$IM À ÀfH& Ò•#eé#^‚)¦’;f¦h~YP•,’)Ò›qª¹æ˜mÆ@"ü)‚
x çž Ù '*ú£":ê¤ M0Á ZP€"d£Bœ&ô©L’–¤‘QŠP D 1ÿ0åA ø¨
T+M¥’”A *‚ªi)À B |é )¯ڑÏ>‹ë ÐJK-£ÂÔ+I ¬‘Ädì°ÉFY@Û* e”0Ðê¥ó^ ‚¼RÆ;oõÞ«[Ÿ‘% ÀÁç¦[P”òà–”ù Â=¢éc°N¬¼ € 1ÅXÌ+ÁipðÉ(§¬òÊ,·ìòË.€@˜/Ei©¾NÚo®9[ìA« ÈK(Ï; T1 ¶’Jòb L@[4»´î@Mî›ë¶=#í$¬ÑZ ñÕ< ôoK#6ÀÁO ¤0AS3Øn;ù.”‹uÑ9ËÝ)Ùuÿ @ÚžEÝÒ{ 4…ª‡‹PAãwº¸âBÞ¸ÒYõÚÿ«çúyžèõ‰Žéð™~êë©nëæ¹^ìáÉNíÜÙ>î×é.ïÒù ðÍ ñÈÿòÃ)–àˆbä|GÌû6=GÕçv=\ÐGOWÙuï=EÛk”=mågtþkéß%þøµÑúªÉoý¥Ù_þ éï×ûðƒˆÿ&¿ÌO6 C(‘j†qàe X˜*!|ˆ)“A‡l02 üÑ¥wÀÛXp„#*!oNˆB©08,la‹^hœÊPF4\Ž
o¨£á|Ð1!<™ã—Cèìð†A\È“D…,1M”ÌeE„<ñ0U¤Ò[˜ÅC
qE¬ÎQØÅ9q„eLÕ/˜ÆÀ}Q€a LÆöÆ…L Ãù 0 >úñ€ ¤ IÈBòˆL¤"iH @N¾Ù@@ÉJZò’˜Ì¤&7ÉÉNzò“ ¥(;Ù€
Ôñ”¨L¥*WÉÊVºò•r ; jcsp-1.1-rc4.orig/src/org/jcsp/plugNplay/ints/doc-files/TailInt1.gif 0000644 0000000 0000000 00000003770 10520670125 022060 0 ustar GIF89a= ÷ $$$000444888<<<@@@PPPYYY]]]aaaqqquuuyyy}}}………•••¡¡¡¥¥¥®®®²²²¶¶¶¾¾¾ÆÆÆÎÎÎÖÖÖÚÚÚÞÞÞæææòòòöööÿÿÿ , = ÿ I H° Áƒ*\È°¡Ã‡#JœH±¢Å‹3jÜȱ£Ç CŠ I²¤É“(Sª\ɲ¥Ë—0cÊœI³¦Í›8sêÜɳ§O‘$ J´¨Ñ£H“*]Ê´©Ó§P—^øIõä ¢jÝʵ«×¯GQµlÈ
̪uè ÂÚ·ÛÂkP(Ý»åâ¥kw¯_…zÿ®í+¸ðÀÀ†«N,1cŸ‹ ïu,ygäÊt)cÆyyó[Ížkvm4i™£OS5úeêÖ=YÃfùz¶NÙ¶SÖÎ}7o“»Óô-|dðâ1‰#y|¹KåÎ;6¾:uÓ¯£´®ýböî%¹ƒÿ§ø}¼Hñæ#–Oÿ={‡ëßst/aüúqÝâ—.a?KúþÕÕ_€)Hà@÷ (‘
&¨ D èàƒléG!y^xž…ª—a‡íq"| Ž8Ÿˆ&ÚWbŠù±H¢‹'ÂÈЄ2’!4Êxc€9¸£=ºøã~A²8$~Eâ×
Y_’õ0A“(ÖHÐzLù`!PieBåu €–
JIBPÀ9)_g¨™@$,Àæ™, €™eNY@!@ ¹ùÞe Ai’@Ii¢Lö‰' bJ¡ì]6Aeúh¤ˆIæfš™©Aœ¦ç)¨$$ÿÚÁ¨xšJaªS®Zh•_’pYhf0êdàÀ˜À.°Áƒ PP§³ $ð«¼~ÙÙ.Ðe´ PÐlÝ~ÙªyPŽ8îxå‚x.Ed鮳Q଼$ЋP¥:¥à]îªÓ§ì¹¦Av:
)ŸÊÙŠ
The educational purpose is to demonstrate how simple it is to build layered
networks of communicating processes. Each component works to a clean channel
interface. Component instances can just be wired together. A network of
such components is itself another (CSP) component. Network design
and analysis takes place independently at each level - we do not have to think
about the whole network hierarchy to reason about each level. This enables us
to construct components with arbitrarilly rich behaviour without running into
combinatorial explosions of complexity.
Examples are given of networks with 20-30 processes (threads). Because of
the component layering, we never need to consider more than about 5 at a time
and it is easy to see what they do and that they are without deadlock, livelock,
starvation or race-hazard problems.
