Updated documentation.

5 files changed, 11 insertions, 12 deletions

diff --git a/documentation/chapters/adapter/adapter.tex b/documentation/chapters/adapter/adapter.tex
index 395c283..68b6696 100644
--- a/documentation/chapters/adapter/adapter.tex
+++ b/documentation/chapters/adapter/adapter.tex
@@ -19,23 +19,22 @@ Six functions are required in your Python wrapper, they are:
 def get_name():
   return 'tokenisation'
 \end{verbatim}
-\item \texttt{get\_inputs()}: Returns the inputs of the component. For components with one input port a list of input names must be returned. Otherwise, a 2-tuple must be returned whose elements are lists of input names for a two port input. E.g.,
+\item \texttt{get\_inputs()}: Returns the inputs of the component. Components should only be defined with one input port, which is defined by returning a single list of input port signal names. E.g.,
 \begin{verbatim}
 def get_inputs():
-  return (['port.one.a', 'port.one.b'],
-          ['port.two.a', 'port.two.b', 'port.two.c'])
+  return ['port.in.a', 'port.in.b']
 \end{verbatim}
-\item \texttt{get\_outputs()} - Returns the outputs of the component. For components with one output port a list of output names must be returned. Otherwise, a 2-tuple must be returned whose elements are lists of output names for a two port output. E.g.,
+\item \texttt{get\_outputs()} - Returns the outputs of the component. Components should only be defined with one output port, which is defined by returning a single list of output port signal names. E.g.,
 \begin{verbatim}
 def get_outputs():
-  return ['port.a', 'port.b', 'port.c']
+  return ['port.out.a', 'port.out.b', 'port.out.c']
 \end{verbatim}
 \item \texttt{get\_configuration()}: Returns a list of names that represent the static data that shall be used to construct the component. E.g.,
 \begin{verbatim}
 def get_configuration():
   return ['buffer.file', 'buffer.size']
 \end{verbatim}
-\item \texttt{configure(args)}: This function is the component designer's chance to preprocess configuration injected at runtime. The args parameter is a dictionary that contains all the configuration provided to the pipeline. This function is to filter out, and optionally preprocess, the configuration used by this component. This function shall return a dictionary of configuration necessary to construct this component. E.g.,
+\item \texttt{configure(args)}: This function is the component designer's chance to preprocess configuration injected at runtime. The \texttt{args} parameter is a dictionary that contains all the configuration provided to the entire pipeline. This function is to filter out, and optionally preprocess, the configuration used by this component. This function shall return an object containing configuration necessary to construct this component. E.g. this example returns a dictionary of configuration,
 \begin{verbatim}
 import os
 def configure(args):
@@ -44,7 +43,7 @@ def configure(args):
           'buffer.file' : os.path.basename(buffer_file),
           'buffer.size' : args['buffer.size']}
 \end{verbatim}
-\item \texttt{initialise(config)}: This function is where the component designer defines the component's computation. The function receives the dictionary returned from the \texttt{configure()} function and must return a function that takes two parameters, an input object, and a state object. The input object is a dictionary that is received from the previous component in the pipeline, and the state object is the configuration for the component. The returned function should be used to define the component's computation. E.g.,
+\item \texttt{initialise(config)}: This function is where the component designer defines the component's computation. The function receives the object returned from the \texttt{configure()} function and must return a function that takes two parameters, an input object, and a state object. The input object, \texttt{a} in the example below, is a dictionary that is received from the previous component in the pipeline. The keys of this dictionary are the signal names from the previous component's output port. The state object, \texttt{s} in the example below, is a dictionary containing the configuration for the component. The keys of the configuration dictionary are defined by the \texttt{get\_configuration()} function. The returned function should be used to define the component's computation. E.g.,
 \begin{verbatim}
 import subprocess
 def initialise(config):
@@ -94,4 +93,4 @@ def initialise(config):
 This wrapper if used in the \texttt{parallel\_sleep} example PCL which can be found in \texttt{examples/parallel\_sleep} directory of your Git clone.
 
 \section{Future Work}
-It is envisaged that the PCL syntax will be extended in order that these ``bottom level'' PCL components can be defined in PCL. This will no longer require that these components be defined in Python wrappers. However, this is for v2!
\ No newline at end of file
+It is envisaged that the PCL syntax will be extended in order that these ``bottom level'' PCL components can be defined in PCL. This will no longer require that these components be defined in Python wrappers. However, this is for v2!
diff --git a/documentation/chapters/compiler/compiler.tex b/documentation/chapters/compiler/compiler.tex
index 93d9d4b..3de4329 100644
--- a/documentation/chapters/compiler/compiler.tex
+++ b/documentation/chapters/compiler/compiler.tex
@@ -330,7 +330,7 @@ If the condition expression is evaluated to a truthy value the \emph{then} compo
   \caption{\texttt{condition\_expression} : If component's condition expression.}
   \label{fig:pcl-cond-expr}
 \end{figure}
-In Figure \ref{fig:pcl-cond-expr} the recursive syntax for the condition expression is shown. A condition expression is built up using the logical operators (\texttt{or}, \texttt{and}, and \texttt{xor})\footnote{Hopefully these operators require no explanation.}, and the relational operators (\texttt{==}, \texttt{!=}, \texttt{>}, \texttt{<}, \texttt{>=}, \texttt{<=})\footnote{And these! ;)}. The \texttt{identifier} and \texttt{qualified\_identifier} refer to the signals in the input ports of the \emph{then} and \emph{else} components. Also, configuration identifiers may be used in a condition expression, the grammar of which is shown in Figure \ref{fig:pcl-config-id}.
+In Figure \ref{fig:pcl-cond-expr} the recursive syntax for the condition expression is shown. A condition expression is built up using the logical operators (\texttt{or}, \texttt{and}, and \texttt{xor})\footnote{Hopefully these operators require no explanation.}, and the relational operators (\texttt{==}, \texttt{!=}, \texttt{>}, \texttt{<}, \texttt{>=}, and \texttt{<=})\footnote{And these! ;)}. The \texttt{identifier} and \texttt{qualified\_identifier} refer to the signals in the input ports of the \emph{then} and \emph{else} components. Also, configuration identifiers may be used in a condition expression, the grammar of which is shown in Figure \ref{fig:pcl-config-id}.
 \begin{figure}[h!]
   \centering
     \includegraphics[scale=\DiagramScale]{chapters/compiler/diagrams/configuration_identifier}
diff --git a/documentation/chapters/introduction/introduction.tex b/documentation/chapters/introduction/introduction.tex
index 7946446..6a74b55 100644
--- a/documentation/chapters/introduction/introduction.tex
+++ b/documentation/chapters/introduction/introduction.tex
@@ -1,10 +1,10 @@
 \chapter{Introduction}
-Pipeline Creation Language (PCL) is a general purpose language for creating non-recurrent software pipelines. PCL is a small grammar for combining computation using re-usable components which can be shared or distributed. A number of combinator operators are defined which execute components sequentially or in parallel. Also, a number of pre-defined components can be used to ``glue'' component together, merge parallel outputs, or conditional execute components.
+Pipeline Creation Language (PCL) is a general purpose language for creating non-recurrent software pipelines. PCL is a small grammar for combining computation using re-usable components which can be shared or distributed. A number of combinator operators are defined which execute components sequentially or in parallel. Also, a number of pre-defined components can be used to ``glue'' components together, merge parallel outputs, or conditional execute components.
 
 PCL was developed as part of the MosesCore project sponsored by the European Commission's Seventh Framework Programme (Grant Number 288487) \url{http://www.statmt.org/mosescore/}. For more information on the Seventh Framework Programme please see \url{http://cordis.europa.eu/fp7/home_en.html}.
 
 \section{License and Availability}
 PCL compiler and runtime has been released under a LGPL v3.0\footnote{See the GNU Lesser General Public License at \url{http://www.gnu.org/copyleft/lesser.html}} license. It is available from GitHub using the following command:
 \begin{verbatim}
-git clone git@github.com:ianj-als/pcl.git
+git clone https://github.com/ianj-als/pcl.git
 \end{verbatim}
diff --git a/documentation/pcl-manual.1.0.1-beta.pdf b/documentation/pcl-manual.1.0.2-beta.pdf
index 5133d4b..4ab664b 100644
--- a/documentation/pcl-manual.1.0.1-beta.pdf
+++ b/documentation/pcl-manual.1.0.2-beta.pdf
diff --git a/documentation/pcl-manual.tex b/documentation/pcl-manual.tex
index 6ed0b68..4009e24 100644
--- a/documentation/pcl-manual.tex
+++ b/documentation/pcl-manual.tex
@@ -51,7 +51,7 @@
 
 
 %%% Macro definitions for Commonly used symbols
-\newcommand{\ReleaseVersion}{1.0.1-beta}
+\newcommand{\ReleaseVersion}{1.0.2-beta}
 
 \begin{document}
 \title{\huge{Pipeline Creation Language (PCL)}\\