/**
* 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;
}
}
/**
* 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) :
base(input)
//throws JCSPNetworkException
{
// Set the wrapper's alting channel input so the channel can be used as a guard
// 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;
}
/**
* 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
*/
internal 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));
}
/**
* 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 ArgumentException
* If a channel of the given index already exists.
*/
/*synchronized*/ internal void create(int idx, ChannelData cd)
//throws ArgumentException
{
// First check that a channel of the given index does not exist. If it does, throw an exception
int objIndex = idx;
if (this.channels[objIndex] != null)
throw new ArgumentException ("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.Add(objIndex, cd);
// Update the index if necessary
if (idx == ChannelManager.index)
ChannelManager.index++;
}
/**
* Allocates a new number to the channel, and stores it in the table.
*
* @param cd
* The ChannelData for the channel
*/
/*synchronized*/ internal void create(ChannelData cd)
{
// First allocate a new number for the channel
int objIndex = index;
while (this.channels[objIndex] != null)
{
//objIndex = new Integer(++index);
++index;
}
// Set the index of the ChannelData
cd.vcn = index;
// Now put the channel in the channel Hashtable
this.channels.Add(objIndex, cd);
// Finally increment the index for the next channel to be created
index++;
}
/**
* 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
*/
public 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));
}
/**
* Removes a channel from the table.
*
* @param data
* ChannelData for channel to remove
*/
internal void removeChannel(ChannelData data)
{
int objIndex = data.vcn;
this.channels.Remove(objIndex);
}
