Skip to Content.
Sympa Menu

notify-dpml - svn commit: r2006 - in development/laboratory/planet/components/processing: . api/src/main/net/dpml/processing controller/src/main/net/dpml/processing/controller docs docs/src docs/src/art docs/src/docs docs/src/resources docs/src/resources/images

notify-dpml AT lists.ibiblio.org

Subject: DPML Notify

List archive

svn commit: r2006 - in development/laboratory/planet/components/processing: . api/src/main/net/dpml/processing controller/src/main/net/dpml/processing/controller docs docs/src docs/src/art docs/src/docs docs/src/resources docs/src/resources/images

Chronological Thread  
    < Chronological >       < Thread >
  • From: niclas AT hedhman.org
  • To: notify-dpml AT lists.ibiblio.org
  • Subject: svn commit: r2006 - in development/laboratory/planet/components/processing: . api/src/main/net/dpml/processing controller/src/main/net/dpml/processing/controller docs docs/src docs/src/art docs/src/docs docs/src/resources docs/src/resources/images
  • Date: Thu, 10 Mar 2005 15:17:46 -0500
Author: niclas AT hedhman.org
Date: Thu Mar 10 15:17:46 2005
New Revision: 2006

Added:
development/laboratory/planet/components/processing/docs/
development/laboratory/planet/components/processing/docs/build.xml
(contents, props changed)
development/laboratory/planet/components/processing/docs/src/
development/laboratory/planet/components/processing/docs/src/art/

development/laboratory/planet/components/processing/docs/src/art/sample1.dia
(contents, props changed)
development/laboratory/planet/components/processing/docs/src/docs/

development/laboratory/planet/components/processing/docs/src/docs/guide.xml
(contents, props changed)

development/laboratory/planet/components/processing/docs/src/docs/index.xml
(contents, props changed)

development/laboratory/planet/components/processing/docs/src/docs/navigation.xml
(contents, props changed)
development/laboratory/planet/components/processing/docs/src/resources/

development/laboratory/planet/components/processing/docs/src/resources/images/

development/laboratory/planet/components/processing/docs/src/resources/images/sample1.png
(contents, props changed)
Modified:

development/laboratory/planet/components/processing/api/src/main/net/dpml/processing/ProcessActivity.java

development/laboratory/planet/components/processing/controller/src/main/net/dpml/processing/controller/ExitPoint.java

development/laboratory/planet/components/processing/controller/src/main/net/dpml/processing/controller/NestedController.java
development/laboratory/planet/components/processing/index.xml
Log:
ExitPoint handling changes, and basic documentation written.

Modified:
development/laboratory/planet/components/processing/api/src/main/net/dpml/processing/ProcessActivity.java
==============================================================================
---
development/laboratory/planet/components/processing/api/src/main/net/dpml/processing/ProcessActivity.java
(original)
+++
development/laboratory/planet/components/processing/api/src/main/net/dpml/processing/ProcessActivity.java
Thu Mar 10 15:17:46 2005
@@ -42,7 +42,7 @@
* m_unpaidBill = (ProcessActivity) man.lookup( "error-unpaid" );
* }
*
- * public Process process()
+ * public ProcessActivity process()
* throws Exception
* {
* doStuff();

Modified:
development/laboratory/planet/components/processing/controller/src/main/net/dpml/processing/controller/ExitPoint.java
==============================================================================
---
development/laboratory/planet/components/processing/controller/src/main/net/dpml/processing/controller/ExitPoint.java
(original)
+++
development/laboratory/planet/components/processing/controller/src/main/net/dpml/processing/controller/ExitPoint.java
Thu Mar 10 15:17:46 2005
@@ -21,25 +21,31 @@
import java.util.Locale;
import java.util.ResourceBundle;

+import net.dpml.context.Context;
+import net.dpml.context.ContextException;
+
import net.dpml.processing.ProcessActivity;

/** A marker class for exiting a nested controller.
* <p>
* The ExitPoint is included into the block, and wired to the outcome
* of the nested activities that triggers the exit from the controller.
+ * The name of the ExitPoint component in the block will also be used
+ * to tie the ExitPoint to a continuation process in the parent container
+ * of the container that contains this
<code>ProcessActivity/ExitPoint</code>.
*
* <code><pre>
- * &lt;x:component name="exit"
class="net.dpml.processing.controller.ExitPoint" /&gt;
+ * &lt;x:component name="printingDone"
class="net.dpml.processing.controller.ExitPoint" /&gt;
*
* &lt;x:component name="select"
class="my.company.print.SelectionActivity" &gt;
* &lt;x:dependencies&gt;
* &lt;x:dependency key="outcome-print" source="printing" /&gt;
- * &lt;x:dependency key="outcome-cancel" source="exit" /&gt;
+ * &lt;x:dependency key="outcome-cancel" source="printingDone" /&gt;
* &lt;/x:dependencies&gt;
* &lt;/x:component&gt;
* &lt;x:component name="printing"
class="my.company.print.PrintingActivity" &gt;
* &lt;x:dependencies&gt;
- * &lt;x:dependency key="outcome-done" source="exit" /&gt;
+ * &lt;x:dependency key="outcome-done" source="printingDone" /&gt;
* &lt;/x:dependencies&gt;
* &lt;/x:component&gt;
* </pre></code>
@@ -50,6 +56,18 @@
public final class ExitPoint
implements ProcessActivity
{
+ private String m_name;
+
+ /**
+ * @metro.entry key="urn:metro:name"
+ * type="java.lang.String"
+ */
+ public ExitPoint( Context ctx )
+ throws ContextException
+ {
+ m_name = (String) ctx.get( "urn:metro:name" );
+ }
+
/** Process the activity.
* <p>
* The ProcessActivity should executed its operations and determine the
@@ -87,7 +105,7 @@
*/
public String getName()
{
- return "Exit";
+ return m_name;
}

/** Returns the Description.

Modified:
development/laboratory/planet/components/processing/controller/src/main/net/dpml/processing/controller/NestedController.java
==============================================================================
---
development/laboratory/planet/components/processing/controller/src/main/net/dpml/processing/controller/NestedController.java
(original)
+++
development/laboratory/planet/components/processing/controller/src/main/net/dpml/processing/controller/NestedController.java
Thu Mar 10 15:17:46 2005
@@ -21,6 +21,14 @@
import java.util.Locale;
import java.util.ResourceBundle;

+import net.dpml.composition.model.ComponentModel;
+import net.dpml.composition.model.ContainmentModel;
+import net.dpml.composition.model.DeploymentModel;
+import net.dpml.composition.model.ModelException;
+
+import net.dpml.context.Context;
+import net.dpml.context.ContextException;
+
import net.dpml.parameters.Parameters;

import net.dpml.processing.ProcessActivity;
@@ -47,14 +55,6 @@
* <td>The activity that the controller starts the sequence with.</td>
* </tr>
* <tr>
- * <td>continue-activity</td>
- * <td>yes</td>
- * <td>
- * The activity that the outer controller should continue with when
this
- * controller/activity exits.
- * </td>
- * </tr>
- * <tr>
* <td>exception-path</td>
* <td>no</td>
* <td>
@@ -90,9 +90,10 @@
* <h2>Exit</h2>
* Whenever an outcome is defined to continue with the
* <code>net.dpml.processing.controller.ExitPoint</code> activity, this
- * controller will exit. The controller will return to its parent controller
- * with the exit <code>ProcessActivity</code> defined in the
- * <code>continue-activity</code> dependency resolution.
+ * controller will exit. The <code>ProcessActivity</code> that this
+ * controller exit with is found by calling <code>getName</code> in the
+ * ExitPoint and locate a component in the parent container with the same
+ * name.
*
* <h2>Exception Processing</h2>
* <p>
@@ -112,7 +113,6 @@
* &lt;x:component name="controller"
class="net.dpml.processing.controller.NestedController" &gt;
* &lt;x:dependencies&gt;
* &lt;x:dependency key="initial-activity" source="select" /&gt;
- * &lt;x:dependency key="continue-activity" source="../nested-done"
/&gt;
* &lt;x:dependency key="exception-path" source="check-paper-jam" /&gt;
* &lt;x:dependency key="recover-point" source="select" /&gt;
* &lt;/x:dependencies&gt;
@@ -157,27 +157,55 @@
private ProcessActivity m_initialActivity;
private ProcessActivity m_exceptionPath;
private ProcessActivity m_recoverPoint;
- private ProcessActivity m_continueActivity;
+ private ContainmentModel m_grandparentContainer;
private String m_name;

/**
+ * @metro.entry key="urn:composition:containment.model"
+ * type="net.dpml.composition.model.ContainmentModel"
+ * @metro.entry key="urn:metro:name"
+ * type="java.lang.String"
+ * @metro.entry key="urn:metro:partition"
+ * type="java.lang.String"
+ *
* @metro.dependency type="net.dpml.processing.ProcessActivity"
key="initial-activity"
- * @metro.dependency type="net.dpml.processing.ProcessActivity"
key="continue-activity"
* @metro.dependency type="net.dpml.processing.ProcessActivity"
* key="exception-path" optional="true"
* @metro.dependency type="net.dpml.processing.ProcessActivity"
* key="recover-point" optional="true"
+ *
+ * @exception ModelException if this component is not contained
+ * within a container that has a parent container.
+ * @exception ServiceException when the service dependencies has not been
+ * properly fulfilled.
+ * @exception ContextException is declared but can only happen if the
container
+ * is malfunctioning, or the xinfo of the component has been
corrupted.
*/
- public NestedController( ServiceManager man, Parameters params )
- throws ServiceException
+ public NestedController( ServiceManager man, Parameters params, Context
ctx )
+ throws ServiceException, ModelException, ContextException
{
+ m_name = (String) ctx.get( "urn:metro:name" );
+ String path = (String) ctx.get( "urn:metro:partition" );
+ int lastSlash = path.lastIndexOf( "/" );
+ lastSlash = path.lastIndexOf( "/", lastSlash );
+
+ try
+ {
+ path = path.substring( lastSlash );
+ } catch( IndexOutOfBoundsException e )
+ {
+ throw new ModelException( "This component must be located in a
container of a container." );
+ }
+
+ ContainmentModel model = (ContainmentModel) ctx.get(
"urn:composition:containment.model" );
+ m_grandparentContainer = (ContainmentModel) model.getModel( path );
+
m_name = params.getParameter( "name", "Nested Controller" );
if( man.hasService( "exception-path" ) )
{
m_exceptionPath = (ProcessActivity) man.lookup( "exception-path"
);
m_recoverPoint = (ProcessActivity) man.lookup( "recover-point" );
}
- m_recoverPoint = (ProcessActivity) man.lookup( "continue-activity" );
m_initialActivity = (ProcessActivity) man.lookup( "initial-activity"
);
}

@@ -208,7 +236,17 @@
{
next = next.process();
if( next instanceof ExitPoint )
- return m_continueActivity;
+ {
+ ExitPoint p = (ExitPoint) next;
+ String name = p.getName();
+
+ DeploymentModel dp = m_grandparentContainer.getModel(
name );
+ if( dp == null )
+ return null;
+
+ ProcessActivity activity = (ProcessActivity)
dp.resolve();
+ return activity;
+ }

} catch( Exception e )
{

Added: development/laboratory/planet/components/processing/docs/build.xml
==============================================================================
--- (empty file)
+++ development/laboratory/planet/components/processing/docs/build.xml Thu
Mar 10 15:17:46 2005
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!--
+ Copyright 2005 Niclas Hedhman
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+<project name="dpml-processing-docs" default="docs" basedir="."
+ xmlns:transit="antlib:net.dpml.transit"
+ xmlns:x="plugin:dpml/magic/dpml-magic-core"
+>
+
+ <transit:import uri="artifact:template:dpml/magic/standard"/>
+
+ <target name="docs" depends="prepare">
+ <transit:plugin uri="artifact:plugin:dpml/magic/dpml-magic-doc#SNAPSHOT">
+ <task class="net.dpml.magic.doc.DocTask" name="docs"/>
+ </transit:plugin>
+ <docs/>
+ </target>
+
+</project>

Added:
development/laboratory/planet/components/processing/docs/src/art/sample1.dia
==============================================================================
Binary file. No diff available.

Added:
development/laboratory/planet/components/processing/docs/src/docs/guide.xml
==============================================================================
--- (empty file)
+++
development/laboratory/planet/components/processing/docs/src/docs/guide.xml
Thu Mar 10 15:17:46 2005
@@ -0,0 +1,246 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+
+<document>
+ <properties>
+ <author email="niclas AT hedhman.org">Niclas Hedhman</author>
+ <title>DPML Processing Component</title>
+ </properties>
+
+ <body>
+ <section name="Guide">
+ <subsection name="Abstracting the processing" >
+ <p>
+ It is very important that the processing is properly abstracted
+ to meaningful levels, prior to trying to implementing things.
+ Abstractions with too much details should be simplified into
+ fewer, nested processing systems. Draw each processing system
+ on a different piece of paper (or electronically). If the
+ system has one or more exit points, you are dealing with nested
+ systems and the exit points are so called
<strong>outcomes</strong>.
+ </p>
+ <p>
+ Each arrow out of a processing block, leading to a new one is an
+ <strong>outcome</strong>. Outcomes are resolved through the Metro
+ dependency resolution system, and in effect the outcome becomes a
+ Metro dependency in the ProcessActivity implementation.
+ </p>
+ </subsection>
+ <subsection name="Implementing the ProcessActivity API" >
+ <p>
+ Implementing the <i>boxes</i> is relatievly easy. The
+ <code>ProcessActivity.process()</code> method will be called when
+ it is time to do something, and upon finish, the implementation
+ returns the next <code>ProcessActivity</code> that the controller
+ should process next. But the <code>ProcessActivity</code>
+ implementation should <strong>not</strong> know about the other
+ activities around. So how is that achieved? The answer is; Through
+ Metro's dependency resolution.
+ </p>
+ <p>
+ For each outcome a dependency is declared. Which will later be
wired
+ by the container assembler. Example;
+ </p>
+<source><![CDATA[
+/**
+ * @metro.dependency type="net.dpml.processing.ProcessActivity" key="success"
+ * @metro.dependency type="net.dpml.processing.ProcessActivity"
key="error-energy"
+ * @metro.dependency type="net.dpml.processing.ProcessActivity"
key="error-unpaid"
+ */
+public void service( ServiceManager man )
+ throws ServiceException
+{
+ // look up the success activity to follow upon success.
+ m_success = (ProcessActivity) man.lookup( "success" );
+ m_outOfEnergy = (ProcessActivity) man.lookup( "error-energy" );
+ m_unpaidBill = (ProcessActivity) man.lookup( "error-unpaid" );
+}
+
+public ProcessActivity process()
+ throws Exception
+{
+ doStuff();
+ if( m_noMoreEnergy )
+ return m_outOfEnergy;
+ if( m_billUnpaid )
+ return m_unpaidBill;
+ return m_success;
+}
+]]>
+</source>
+ <p>
+ In the above example, the three outcomes "success", "error-energy"
+ and "error-unpaid" are looked up, and is resolved at the container
+ level. It is not the concern of the <code>ProcessActivity</code>
+ to know how it is wired, but it needs to support the pattern, to
+ make the overall design of the Processing system simpler.
+ </p>
+ </subsection>
+ <subsection name="Creating a controller" >
+ <p>
+ Controllers are basically very simple and not difficult to create
+ from scratch. If only a simple sequencing is required, a <code>
+ while</code> loop could serve quite well, such as;
+ </p>
+<source><![CDATA[
+// Get hold of the initial activity somehow.
+ProcessActivity next = getInitialActivity();
+
+while( true )
+{
+ try
+ {
+ next = next.process();
+ } catch( Exception e )
+ {
+ // Report the exception
+ // Figure out how to recover.
+ next = getRecoverPoint();
+ }
+}
+]]>
+</source>
+ <p>
+ Of course it is possibly to expand on this in all kinds of
directions,
+ but since the simple cases are easy to create, the default
+ implementation leaves these controllers out, and only provides a
more
+ sophisticated one, the
+ <code>net.dpml.processing.controller.NestedController</code>.
+ </p>
+ </subsection>
+ <subsection name="Creating a container" >
+ <p>
+ The container/block could be composited something like this;
+ </p>
+<source><![CDATA[
+<x:block>
+ <x:component name="controller" class="org.hedhman.niclas.MyController" >
+ <x:dependencies>
+ <x:dependency key="initial-activity" source="process-stuff" />
+ </x:dependencies>
+ </x:component>
+
+ <x:component name="process-stuff" class="org.hedhman.niclas.StuffActivity"
>
+ <x:dependencies>
+ <x:dependency key="success" source="done-stuffing" />
+ <x:dependency key="error-energy" source="inform-no-energy" />
+ <x:dependency key="error-unpaid" source="pay-bill" />
+ </x:dependencies>
+ </x:component>
+
+ <x:component name="pay-bill"
class="org.hedhman.niclas.PaymentImplementation" >
+ <x:dependencies>
+ <x:dependency key="success" source="done-stuffing" />
+ </x:dependencies>
+ </x:component>
+
+ <x:component name="inform-no-energy"
class="org.hedhman.niclas.PaymentImplementation" >
+ <x:dependencies>
+ <x:dependency key="success" source="done-stuffing" />
+ </x:dependencies>
+ </x:component>
+
+ <x:component name="done-stuffing"
class="net.dpml.processing.controller.ExitPoint" />
+</x:block>
+]]>
+</source>
+ <p>
+ <i>All the configuration, parameterization and other things needed
has
+ been left out for the sake of brievity.</i>
+ </p>
+ <p>
+ The <code>ExitPoint</code> is a pre-defined
<code>ProcessActivity</code>
+ implementation that signals to controllers that it should exit the
+ processing sequence.
+ The <code>MyController</code> is a simple controller that sequence
the
+ processing. It does not support nesting nor error processing paths,
+ like the
<code>net.dpml.processing.controller.NestedController</code>
+ does.
+ </p>
+ </subsection>
+ <subsection name="Nested Processing" >
+ <p>
+ Nested processing is made fairly simple with the
+ <code>net.dpml.processing.controller.NestedController</code>.
+ The <code>NestedController</code> also implements a
ProcessActivity,
+ which means that an assembled container with a
<code>NestedController</code>
+ can be included into a higher level container as a
+ <code>ProcessActivity</code>. But there <strong>are</strong> some
concerns
+ one must observe.
+ </p>
+ <p>
+ The <code>NestedController</code> will upon reaching an
+ <code>ExitPoint</code> get the name of the <code>ExitPoint</code>
+ component node, i.e. the name attribute in the component element,
and
+ locate another <code>ProcessActivity</code> in the container above
+ the container containing the <code>NestedController</code>
component
+ with the same name. That was heavy, let's look at the simplest
+ possible example with all the noise stripped out.
+ </p>
+<source><![CDATA[
+<container>
+
+ <component name="outer-controller" class="org.hedhman.niclas.MyController">
+ <!-- wiring -- needed -->
+ </component>
+
+ <component name="abc" class="someActivity" >
+ <!-- wiring -- needed -->
+ </component>
+
+ <container> <!-- typically included into the outer container -->
+ <services>
+ <service type="net.dpml.processing.ProcessActivity"
source="controller" />
+ </services>
+ <component
+ name="controller"
+ class="net.dpml.processing.controller.NestedController"
+ >
+ <!-- wiring -- needed -->
+ </component>
+ <component name="abc" class="net.dpml.processing.controller.ExitPoint" />
+
+ <!-- other activties -->
+ </container>
+</container>
+]]>
+</source>
+ <p>
+ When the <code>ExitPoint</code> named "abc" is reached, the
+ <code>NestedController</code> will go up one container level from
+ itself, and finds "someActivity" named "abc", which will be the
+ continuation of the processing when the
<code>NestedController</code>
+ finishes.
+ </p>
+ </subsection>
+ <subsection name="Exception Processing Paths" >
+ <p>
+ The <code>NestedController</code> supports the notion of a
separated
+ processing system, if any of the
<code>ProcessActivity.process()</code>
+ method throws an <code>Exception</code>.
+ It is possible to configure a <code>ProcessActivity</code> that the
+ <code>NestedController</code> should jump to if an
+ <code>Exception</code> is thrown, and when such processing path
+ reaches an <code>ExitPoint</code> the processing will return to a
+ pre-defined recover <code>ProcessActivity</code>. If no exception
+ processing path has been defined, the <code>NestedController</code>
+ will throw the <code>Exception</code> upwards in its <code>
+ process()</code> method.
+ </p>
+ <p>
+ Exception processing path is optional, and normal error conditions
+ should be done through proper <strong><i>outcomes</i></strong>.
+ </p>
+<source><![CDATA[
+<component name="controller"
class="net.dpml.processing.controller.NestedController" >
+ <dependencies>
+ <dependency key="exception-path" source="exception-handling" />
+ <dependency key="recover-point" source="idle-activity" />
+ <dependency key="initial-activity" source="starting-point" />
+ </dependencies>
+</component>
+]]>
+</source>
+ </subsection>
+ </section>
+ </body>
+</document>

Added:
development/laboratory/planet/components/processing/docs/src/docs/index.xml
==============================================================================
--- (empty file)
+++
development/laboratory/planet/components/processing/docs/src/docs/index.xml
Thu Mar 10 15:17:46 2005
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+
+<document>
+ <properties>
+ <author email="niclas AT hedhman.org">Niclas Hedhman</author>
+ <title>DPML Processing Component</title>
+ </properties>
+
+ <body>
+ <section name="Introduction">
+ <p>
+ The Processing component system is all about simplified block
+ processing abstraction. It is common to view the problem space
+ as a number of <i>boxes</i>, each doing something and depending
+ on the outcome of that, continue to another processing stage.
+ </p>
+ <p>
+ <img src="/images/sample1.png" />
+ <br/>
+ Example 1. Simple selection processing.
+ </p>
+ <p>
+ In the above example we have some type of processing that makes
+ a selection, and the outcome of that brings us to either a
+ "Send File" or a "Print File" processing stage. Each of those
+ may fail or be successful. And in case of failure, inform the user
+ then log the message before finishing off in "Done".
+ </p>
+ <p>
+ In the component oriented nature of Metro, we want to be able to
+ create each of the boxes in the above as separate components and
+ then have some type of controller that moves us around the
+ diagram. That is what this package is about. The <strong>api</strong>
+ defines an interface for the processing blocks to implement, and the
+ <strong>controller/</strong> contains an implementation of a
controller
+ which is also a <i>processing block</i>, which enables nested setups.
+ </p>
+ <p>
+ More information is available in the <a href="guide.html">Guide</a>.
+ </p>
+ </section>
+ </body>
+</document>

Added:
development/laboratory/planet/components/processing/docs/src/docs/navigation.xml
==============================================================================
--- (empty file)
+++
development/laboratory/planet/components/processing/docs/src/docs/navigation.xml
Thu Mar 10 15:17:46 2005
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--
+ Copyright 2005 Niclas Hedhman
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.dpml.net/central/about/legal/
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+<project>
+
+ <title>DPML Processing Component</title>
+
+ <body>
+ <links>
+ <!--<item name="Services" href="services/index.html"/>-->
+ <!--<item name="Planet" href="planet/index.html"/>-->
+ <item name="Metro" href="http://www.dpml.net/metro/latest/index.html"/>
+ <item name="Magic" href="http://www.dpml.net/magic/latest/index.html"/>
+ <item name="Transit"
href="http://www.dpml.net/transit/latest/index.html"/>
+ </links>
+ <menu>
+ <item name="Introduction" href="index.html"/>
+ <item name="Guide" href="guide.html"/>
+ <item name="Javadocs" href="/@JAVADOC-PATH@/index.html"/>
+ </menu>
+ </body>
+</project>

Added:
development/laboratory/planet/components/processing/docs/src/resources/images/sample1.png
==============================================================================
Binary file. No diff available.

Modified: development/laboratory/planet/components/processing/index.xml
==============================================================================
--- development/laboratory/planet/components/processing/index.xml
(original)
+++ development/laboratory/planet/components/processing/index.xml Thu
Mar 10 15:17:46 2005
@@ -54,6 +54,8 @@
<version>1.0.0</version>
</info>
<dependencies>
+ <include key="dpml-composition-api"/>
+ <include key="dpml-context-api"/>
<include key="dpml-processing-api"/>
<include key="dpml-parameters-api" />
<include key="dpml-service-api" />
@@ -62,4 +64,13 @@
<include key="dpml-meta-tools" />
</plugins>
</project>
+
+ <project basedir="docs" >
+ <info>
+ <name>dpml-processing-docs</name>
+ <group>dpml/processing/docs</group>
+ <version>1.0</version>
+ </info>
+ </project>
+
</index>


  • svn commit: r2006 - in development/laboratory/planet/components/processing: . api/src/main/net/dpml/processing controller/src/main/net/dpml/processing/controller docs docs/src docs/src/art docs/src/docs docs/src/resources docs/src/resources/images, niclas, 03/10/2005

Archive powered by MHonArc 2.6.24.

Top of Page