genericsyncexpression.java

一个工作流设计及定义的系统,可以直接与数据库结合进行系统工作流程的定义及应用.

         * this overriden method takes care of adding the the thatFei 
         * if thisFei is missing
         */

        log.debug("replaceChild() \n   "+thisFei+" --> "+thatFei);

        //log.debug("replaceChild() before :\n"+dumpChildren());

        boolean result = Utils.replace(getChildren(), thisFei, thatFei);

        log.debug("replaceChild() found in children ? "+result);

        if ( ! result)
        {
            getChildren().add(thatFei);
        }

        if (this.childrenAltitudes != null)
        {
            if (result)
            {
                result = 
                    Utils.replace(this.childrenAltitudes, thisFei, thatFei);
            }
            else
            {
                this.childrenAltitudes.add(thatFei);
            }
        }

        return result;
    }

    public synchronized void reply 
        (final SynchableExpression se, final InFlowWorkItem wi)
    throws 
        ReplyException
    {
        log.debug("reply() from "+wi.getLastExpressionId());

        //log.debug("reply() before :\n"+dumpChildren());

        //synchronized (this)
        //{

        //
        // is sync over ?

        boolean syncIsOver = false;

        getIncomingWorkitems().add(wi);
        getChildren().remove(wi.getLastExpressionId());

        syncIsOver = syncIsOver ||
            getChildren().size() < 1;
        syncIsOver = syncIsOver ||
            (getCount() > 0 && getIncomingWorkitems().size() >= this.count);

        //log.debug("reply() after :\n"+dumpChildren());

        log.debug("reply() is sync over ? "+syncIsOver);

        if (syncIsOver)
        {
            //
            // should we cancel or forget (stub) remaining children ?

            try
            {
                treatRemainingChildren(se);
            }
            catch (final ApplyException ae)
            {
                /*
                log.warn
                    ("Failed to '"+getRemaining()+
                     "' remaining children", ae);
                */
                throw new ReplyException
                    ("Failed to '"+getRemaining()+
                     "' remaining children", ae);
            }

            //
            // determine resulting workitem

            InFlowWorkItem resultingWorkitem = null;

            if (getMergeType().equals(MT_MIX))
            {
                if (getMerge().equals(MG_FIRST))
                {
                    resultingWorkitem = 
                        (InFlowWorkItem)getIncomingWorkitems()
                            .get(getIncomingWorkitems().size()-1);

                    for (int i=getIncomingWorkitems().size()-2; i>-1; i--)
                    {
                        MergeUtils.merge
                            (resultingWorkitem, 
                             (InFlowWorkItem)getIncomingWorkitems().get(i));
                    }
                }
                else if (getMerge().equals(MG_LAST))
                {
                    resultingWorkitem = 
                        (InFlowWorkItem)getIncomingWorkitems().get(0);

                    for (int i=1; i<getIncomingWorkitems().size(); i++)
                    {
                        MergeUtils.merge
                            (resultingWorkitem, 
                             (InFlowWorkItem)getIncomingWorkitems().get(i));
                    }
                }
                else
                {
                    java.util.List altitudes = getChildrenAltitudes();

                    if (getMerge().equals(MG_HIGHEST))
                        altitudes = reversedAltitudes();

                    final java.util.Map answerMap = determineAnswerMap();

                    final java.util.Iterator it = altitudes.iterator();
                    while (it.hasNext())
                    {
                        final FlowExpressionId fei = 
                            (FlowExpressionId)it.next();

                        final InFlowWorkItem workitem = 
                            (InFlowWorkItem)answerMap.get(fei);

                        if (workitem == null) continue;

                        MergeUtils.merge(resultingWorkitem, workitem);
                    }
                }
            }
            else // mergeType == MT_OVERRIDE
            {
                if (getMerge().equals(MG_FIRST))
                {
                    resultingWorkitem = 
                        (InFlowWorkItem)getIncomingWorkitems().get(0);
                }
                else if (getMerge().equals(MG_LAST))
                {
                    resultingWorkitem = 
                        (InFlowWorkItem)getIncomingWorkitems()
                            .get(getIncomingWorkitems().size()-1);
                }
                else
                {
                    java.util.List altitudes = getChildrenAltitudes();

                    if (getMerge().equals(MG_LOWEST))
                        altitudes = reversedAltitudes();

                    final java.util.Map answerMap = determineAnswerMap();

                    final java.util.Iterator it = altitudes.iterator();
                    while (it.hasNext())
                    {
                        final FlowExpressionId fei = 
                            (FlowExpressionId)it.next();

                        resultingWorkitem = 
                            (InFlowWorkItem)answerMap.get(fei);

                        if (resultingWorkitem != null) break;
                    }
                }
            }

            //
            // this log output should be disabled after a certain
            // test period.
            //
            if (resultingWorkitem == null)
                log.warn("reply() resultingWorkitem is null");

            //
            // reply to parent expression

            se.replyToParent(resultingWorkitem);
        }
        else
            //
            // sync is not over, let's save the synchable expression
        {
            se.storeItself();
        }
        //}
    }

    private java.util.List reversedAltitudes ()
    {
        final java.util.List result = 
            new java.util.ArrayList(getChildrenAltitudes().size());

        final java.util.Iterator it = result.iterator();
        while (it.hasNext()) result.add(0, it.next());

        return result;
    }

    /*
     * Returns a mapping fei: wi
     */
    private java.util.Map determineAnswerMap ()
    {
        final java.util.Map result = 
            new java.util.HashMap(getIncomingWorkitems().size());

        final java.util.Iterator it = getIncomingWorkitems().iterator();
        while (it.hasNext())
        {
            final InFlowWorkItem wi = (InFlowWorkItem)it.next();

            result.put(wi.getLastExpressionId(), wi);
        }

        return result;
    }

    private /*synchronized ?? */ void treatRemainingChildren 
        (final SynchableExpression se)
    throws 
        ApplyException
    {
        /*
        log.debug
            ("treatRemainingChildren() - "+getChildren().size()+
             " children in total");
        */

        final java.util.List alreadyReplied = 
            new java.util.ArrayList(getIncomingWorkitems().size());
        java.util.Iterator it = getIncomingWorkitems().iterator();
        while (it.hasNext())
        {
            final InFlowWorkItem wi = (InFlowWorkItem)it.next();
            alreadyReplied.add(wi.getLastExpressionId());
        }

        it = getChildren().iterator();
        while (it.hasNext())
        {
            final FlowExpressionId fei = (FlowExpressionId)it.next();

            if (alreadyReplied.contains(fei)) continue;

            log.debug("treatRemainingChildren() '"+getRemaining()+"' on "+fei);

            if (REM_CANCEL.equals(getRemaining()))
            {
                //se.getExpressionPool().cancel(fei);
                se.getExpressionPool().childCancel(fei);
            }
            else
            {
                se.getExpressionPool().forget(fei);
            }
        }
    }

    //
    // METHODS

    /*
    private String dumpChildren ()
    {
        final StringBuffer sb = new StringBuffer();

        sb.append("---children---\n");

        final java.util.Iterator it = getChildren().iterator();
        while (it.hasNext())
        {
            sb
                .append("   * ")
                .append(it.next().toString())
                .append("\n");
        }

        sb.append("---c---");

        return sb.toString();
    }
    */

}