uk.ac.man.cs.rainbow.rapa
Class GreenDefinitions

java.lang.Object
  |
  +--uk.ac.man.cs.rainbow.rapa.GreenDefinitions

public class GreenDefinitions

extends Object

Process definitions for basic Green components. Includes definitions for:

• Constant source (Constant)
• Sink (Sink)
• Initially-empty buffer (EBuf)
• Initially-full buffer (Buf)
• Unary function (Unary - pass one of the OP constants from the Unary subclasses to select which)
• Binary function (Binary - pass one of the OP constants from the Binary subclasses to select which)
• k-ary Duplicate (Duplicate_k)
• k-ary Arbitrate (Arbitrate_k)
• k-ary Split (Split_k)
• k-ary Merge (Merge_k)
• k-ary Tuple (Tuple_k)
• k-ary Untuple (Untuple_k)
• k-ary Synchronise (Synchronise_k)

Inner Class Summary

static class

GreenDefinitions.ConstructorFailure

Field Summary

static NamingContext

defs Naming context that can create all basic Visual Green components.

Method Summary

static ProcessTerm	Abs(Type type, Channel input, Channel output) Create a Green Absolute-value-Function component.
static ProcessTerm	Add(Type type, Channel input1, Channel input2, Channel output) Create a Green Add-Function component.
static ProcessTerm	And(Type type, Channel input1, Channel input2, Channel output) Create a Green And-Function component.
static ProcessTerm	Arb(Type type, Channel[] input, Channel output) Create a Green Arbitrate component.
static ProcessTerm	Buffer(Type type, Channel input, Channel output) Create an uninitialised Green Buffer component.
static ProcessTerm	Buffer(Value initialValue, Type type, Channel input, Channel output) Create an initialised Green Buffer component.
static ProcessTerm	Constant(Value constant, Type type, Channel output) Create a Green Constant component.
static ProcessTerm	Div(Type type, Channel input1, Channel input2, Channel output) Create a Green Divide-Function component.
static ProcessTerm	Dup(Type type, Channel input, Channel[] output) Create a Green Duplicate component.
static ProcessTerm	Equal(Type type, Channel input1, Channel input2, Channel output) Create a Green Equal-Function component.
static ProcessTerm	GT(Type type, Channel input1, Channel input2, Channel output) Create a Green Greater-than-Function component.
static ProcessTerm	If(Type ctype, Type itype, Type otype, Channel control, Channel inmain, Channel inT, Channel inF, Channel outT, Channel outF, Channel outmain) Create a Green If component.
static ProcessTerm	LT(Type type, Channel input1, Channel input2, Channel output) Create a Green Less-than-Function component.
static ProcessTerm	Merge(Type ctype, Type itype, Value[] labels, Channel control, Channel[] input, Channel output) Create a Green Merge component.
static ProcessTerm	Mul(Type type, Channel input1, Channel input2, Channel output) Create a Green Multiply-Function component.
static ProcessTerm	Neg(Type type, Channel input, Channel output) Create a Green Negation-Function component.
static ProcessTerm	Not(Type type, Channel input, Channel output) Create a Green Not-Function component.
static ProcessTerm	Or(Type type, Channel input1, Channel input2, Channel output) Create a Green Or-Function component.
static ProcessTerm	Sink(Type type, Channel input) Create a Green Sink component.
static ProcessTerm	Split(Type ctype, Type itype, Value[] labels, Channel control, Channel input, Channel[] output) Create a Green Split component.
static ProcessTerm	Sub(Type type, Channel input1, Channel input2, Channel output) Create a Green Subtract-Function component.
static ProcessTerm	Synch(Type[] type, Channel[] input, Channel[] output) Create a Green Synchronise component.
static ProcessTerm	Tuple(Type[] type, Channel[] input, Channel output) Create a Green Tuple component.
static ProcessTerm	Untuple(Type[] type, Channel input, Channel[] output) Create a Green Untuple component.

Methods inherited from class java.lang.Object

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

Field Detail

defs

public static final NamingContext defs

Naming context that can create all basic Visual Green components. Note that k-parameterised components should be retrieved by naming the component with a _k suffix, so a two-way duplicate would be called Duplicate_2.

Method Detail

Sink

public static ProcessTerm Sink(Type type,
                               Channel input)

Create a Green Sink component.

Constant

public static ProcessTerm Constant(Value constant,
                                   Type type,
                                   Channel output)

Create a Green Constant component.

Buffer

public static ProcessTerm Buffer(Value initialValue,
                                 Type type,
                                 Channel input,
                                 Channel output)

Create an initialised Green Buffer component.

Buffer

public static ProcessTerm Buffer(Type type,
                                 Channel input,
                                 Channel output)

Create an uninitialised Green Buffer component.

Equal

public static ProcessTerm Equal(Type type,
                                Channel input1,
                                Channel input2,
                                Channel output)

Create a Green Equal-Function component.

Add

public static ProcessTerm Add(Type type,
                              Channel input1,
                              Channel input2,
                              Channel output)

Create a Green Add-Function component.

Sub

public static ProcessTerm Sub(Type type,
                              Channel input1,
                              Channel input2,
                              Channel output)

Create a Green Subtract-Function component.

Mul

public static ProcessTerm Mul(Type type,
                              Channel input1,
                              Channel input2,
                              Channel output)

Create a Green Multiply-Function component.

Div

public static ProcessTerm Div(Type type,
                              Channel input1,
                              Channel input2,
                              Channel output)

Create a Green Divide-Function component.

GT

public static ProcessTerm GT(Type type,
                             Channel input1,
                             Channel input2,
                             Channel output)

Create a Green Greater-than-Function component.

LT

public static ProcessTerm LT(Type type,
                             Channel input1,
                             Channel input2,
                             Channel output)

Create a Green Less-than-Function component.

And

public static ProcessTerm And(Type type,
                              Channel input1,
                              Channel input2,
                              Channel output)

Create a Green And-Function component.

Or

public static ProcessTerm Or(Type type,
                             Channel input1,
                             Channel input2,
                             Channel output)

Create a Green Or-Function component.

Neg

public static ProcessTerm Neg(Type type,
                              Channel input,
                              Channel output)

Create a Green Negation-Function component.

Not

public static ProcessTerm Not(Type type,
                              Channel input,
                              Channel output)

Create a Green Not-Function component.

Abs

public static ProcessTerm Abs(Type type,
                              Channel input,
                              Channel output)

Create a Green Absolute-value-Function component.

Dup

public static ProcessTerm Dup(Type type,
                              Channel input,
                              Channel[] output)

Create a Green Duplicate component.

Arb

public static ProcessTerm Arb(Type type,
                              Channel[] input,
                              Channel output)

Create a Green Arbitrate component.

Split

public static ProcessTerm Split(Type ctype,
                                Type itype,
                                Value[] labels,
                                Channel control,
                                Channel input,
                                Channel[] output)

Create a Green Split component.

Merge

public static ProcessTerm Merge(Type ctype,
                                Type itype,
                                Value[] labels,
                                Channel control,
                                Channel[] input,
                                Channel output)

Create a Green Merge component.

Tuple

public static ProcessTerm Tuple(Type[] type,
                                Channel[] input,
                                Channel output)

Create a Green Tuple component.

Untuple

public static ProcessTerm Untuple(Type[] type,
                                  Channel input,
                                  Channel[] output)

Create a Green Untuple component.

Synch

public static ProcessTerm Synch(Type[] type,
                                Channel[] input,
                                Channel[] output)

Create a Green Synchronise component.

If

public static ProcessTerm If(Type ctype,
                             Type itype,
                             Type otype,
                             Channel control,
                             Channel inmain,
                             Channel inT,
                             Channel inF,
                             Channel outT,
                             Channel outF,
                             Channel outmain)

Create a Green If component.