From: <an...@us...> - 2008-07-20 19:41:25
|
Revision: 6841 http://smartfrog.svn.sourceforge.net/smartfrog/?rev=6841&view=rev Author: anfarr Date: 2008-07-20 19:41:22 +0000 (Sun, 20 Jul 2008) Log Message: ----------- SFOS-922: Migration to constraint support Modified Paths: -------------- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/Context.java trunk/core/smartfrog/src/org/smartfrog/sfcore/common/ContextImpl.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/DefaultParser.jj trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/sfcomponentdescription/SFComponentDescription.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/sfcomponentdescription/SFComponentDescriptionImpl.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/sfreference/SFApplyReference.java Added Paths: ----------- trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/ trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/CDBrowser.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/ConstraintResolutionState.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/CoreSolver.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/EclipseCDBrowser.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/EclipseSolver.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/FreeVar.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/Aggregator.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/Array.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/Constraint.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/ForAllExists.java Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/common/Context.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/Context.java 2008-07-20 19:36:59 UTC (rev 6840) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/common/Context.java 2008-07-20 19:41:22 UTC (rev 6841) @@ -24,7 +24,9 @@ import java.util.Enumeration; import java.util.Iterator; +import org.smartfrog.sfcore.componentdescription.ComponentDescription; + /** * Defines the context interface used by Components. Context implementations * need to respect the ordering and copying requirements imposed by Components. @@ -61,8 +63,7 @@ * @see Enumeration */ public Enumeration elements(); - - + /** * Returns object stored under given key, null if not found. * @@ -273,5 +274,33 @@ public Object sfResolveAttribute(Object name) throws SmartFrogContextException; + /** + * Sets originating description for context. Used in constraint solving. + * @param originatingDescription + */ + public void setOriginatingDescr(ComponentDescription originatingDescription); + + /** + * Gets the originating description for context. Used in constraint solving. + * @return ComponentDescription originating description + */ + public ComponentDescription getOriginatingDescr(); + + /** + * Verifies that comp is a sub-type of this context, based on context being a prefix of comp in terms of keys + * @return Whether sub-type + */ + public boolean ofType(ComponentDescription comp); + + /** + * Returns the key at index idx in context + * @return key for given index, or null if index not valid + */ + public Object getKey(int idx); + /** + * Returns the value at index idx in context + * @return value for given key index, or null if index not valid + */ + public Object getVal(int idx); } Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/common/ContextImpl.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/ContextImpl.java 2008-07-20 19:36:59 UTC (rev 6840) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/common/ContextImpl.java 2008-07-20 19:41:22 UTC (rev 6841) @@ -34,7 +34,10 @@ import java.util.Set; import java.util.Vector; +import org.smartfrog.sfcore.componentdescription.ComponentDescription; +import org.smartfrog.sfcore.languages.sf.constraints.CoreSolver; + /** * Implements the context interface. This implementation relies on the * OrderedHashtable class in the Utilities, but another class can be used. The @@ -64,7 +67,7 @@ public ContextImpl(int cap, float load) { super(cap, load); } - + /** * Returns the first key for which the value is the given one (==). * @param value value to look up @@ -728,6 +731,8 @@ Object r = super.remove(key); attributeTags.remove(key); attributeTagsWrappers.remove(key); + + CoreSolver.getInstance().addUndo(this, key, r); return r; } @@ -790,6 +795,7 @@ public Object clone() { Object ret = super.clone(); + Map m = new HashMap(); Map w = new HashMap(); for (Iterator i = attributeTags.keySet().iterator(); i.hasNext(); ) { @@ -863,4 +869,76 @@ return result; } + /** + * Add an object to the hashtable. + * + * @param key key for association + * @param value value for hashtable + * + * @return previous value for key or null if none + */ + public Object put(Object key, Object value) { + Object oldValue = super.put(key, value); + + CoreSolver.getInstance().addUndo(this, key, oldValue); + return oldValue; + } + + + /** + * Sets originating description for context. Used in constraint solving. + * @param originatingDescr originating ComponentDescription for context + */ + public void setOriginatingDescr(ComponentDescription originatingDescr) { + this.originatingDescr=originatingDescr; + ((ContextImpl)originatingDescr.sfContext()).originatingDescr=originatingDescr; + } + + /** + * Gets the originating description for context. Used in constraint solving. + * @return ComponentDescription originating description + */ + public ComponentDescription getOriginatingDescr() { return originatingDescr; } + + /** The originating component description of this context. */ + private ComponentDescription originatingDescr; + + /** + * Verifies that comp is a sub-type of this context, based on context being a prefix of comp in terms of keys + * @return Whether sub-type + */ + public boolean ofType(ComponentDescription comp){ + ContextImpl comp_cxt = (ContextImpl) comp.sfContext(); + + Iterator comp_iter = comp_cxt.orderedAttributes(); + Iterator my_iter = orderedAttributes(); + + while(my_iter.hasNext()){ + if (!comp_iter.hasNext()) return false; + String akey = (String) my_iter.next(); + String ckey = (String) comp_iter.next(); + if (!akey.equals(ckey)) return false; + } + return true; + } + + /** + * Returns the key at index idx in context + * @return key for given index, or null if index not valid + */ + public Object getKey(int idx){ + return orderedKeys.get(idx); + } + + /** + * Returns the value at index idx in context + * @return value for given key index, or null if index not valid + */ + public Object getVal(int idx){ + Object key = getKey(idx); + if (key!=null) return get(key); + else return null; + } + + } Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/DefaultParser.jj =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/DefaultParser.jj 2008-07-20 19:36:59 UTC (rev 6840) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/DefaultParser.jj 2008-07-20 19:41:22 UTC (rev 6841) @@ -14,7 +14,7 @@ import org.smartfrog.sfcore.languages.sf.sfreference.SFReference; import org.smartfrog.sfcore.languages.sf.sfreference.SFAssertReference; import org.smartfrog.sfcore.languages.sf.sfreference.SFTBDReference; - +import org.smartfrog.sfcore.languages.sf.constraints.FreeVar; import org.smartfrog.sfcore.languages.sf.IncludeHandler; import org.smartfrog.sfcore.reference.ReferencePart; @@ -43,7 +43,7 @@ public class DefaultParser { protected IncludeHandler includeHandler; - static int nextId = 0; + public static int nextId = 0; static final String appendOp = "org.smartfrog.sfcore.languages.sf.functions.Append"; static final String concatOp = "org.smartfrog.sfcore.languages.sf.functions.Concatenate"; @@ -276,7 +276,7 @@ | <FI: "FI"> | <SWITCH: "SWITCH"> | <ENDSWITCH: "ENDSWITCH"> - + | <VAR: "VAR"> } TOKEN : @@ -563,9 +563,24 @@ } +Object Var() : +{ + Object ran = null; + Object val = null; +} +{ + <VAR> + ( + ( + (ran = ReferenceNoEOF() | ran = String()) + | + (<LBRACE> (ran = ReferenceNoEOF() | ran = String()) <COMMA> (val = String() | val = Number()) <RBRACE>) + ) {return new FreeVar(ran, val);} + | + {return new FreeVar();} + ) +} - - Object SimpleValue() : { Object res=null; @@ -762,7 +777,8 @@ void BaseComponent(SFComponentDescription comp) : { } -{ ( +{ + ( (<NULL> [BaseComponentRest(comp)]) | (BaseComponentLinkType(comp) [BaseComponentRest(comp)]) | (BaseComponentAttributesType(comp) [BaseComponentRest(comp)]) @@ -776,7 +792,6 @@ SFComponentDescription cdType = (SFComponentDescription) type; Context cxt = cdType.sfContext(); comp.setContext(cxt); - // re-parent any descriptions in super sfContext for (Enumeration e = cxt.keys(); e.hasMoreElements(); ) { Object key = e.nextElement(); @@ -932,6 +947,7 @@ <VECTOREND>) | <DATA> res = BaseReference() {((SFReference)res).setData(true);} | <TBD> {res = new SFTBDReference();} + | res=Var() ) { return res; } } Added: trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/CDBrowser.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/CDBrowser.java (rev 0) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/CDBrowser.java 2008-07-20 19:41:22 UTC (rev 6841) @@ -0,0 +1,53 @@ +/** (C) Copyright 1998-2004 Hewlett-Packard Development Company, LP + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +For more information: www.smartfrog.org + +*/ +package org.smartfrog.sfcore.languages.sf.constraints; + +/** + * Interface for Component Description browsers used to display sfComfig hierarchy for the purpose of setting user variables + * @author anfarr + * + */ +public interface CDBrowser { + + /** + * Sets an unspecified object as pertaining to the state of the solving engine + * @param es + */ + void setES(Object es); + + /** + * Add attribute to the hierarchy to be displayed + * @param d -- my parent as unspecified object + * @param av -- my attribute name / value as unspecified object + * @param showme -- am I in the immediate component description to be displayed? + * @return tree node which will be used later on to add child attributes to + */ + Object attr(Object d, Object av, boolean showme); + + /** + * Redraw the browser + */ + void redraw(); + + /** + * Kill the browser... + */ + void kill(); +} Added: trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/ConstraintResolutionState.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/ConstraintResolutionState.java (rev 0) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/ConstraintResolutionState.java 2008-07-20 19:41:22 UTC (rev 6841) @@ -0,0 +1,302 @@ +package org.smartfrog.sfcore.languages.sf.constraints; + +import java.util.Vector; + +import org.smartfrog.sfcore.common.Context; +import org.smartfrog.sfcore.common.SmartFrogResolutionException; +import org.smartfrog.sfcore.componentdescription.ComponentDescription; +import org.smartfrog.sfcore.languages.sf.sfcomponentdescription.SFComponentDescriptionImpl; +import org.smartfrog.sfcore.languages.sf.sfcomponentdescription.SFComponentDescriptionImpl.LRSRecord; + +public class ConstraintResolutionState { + /** + * Records link resolution history. Concerned with maintaining undo information when constraints are used + */ + private Vector linkHistory = new Vector(); + + /** + * Maintains a history of Constraint goals that have been (successfully) evaluated + */ + private Vector constraintEvalHistory = new Vector(); + + /** + * Indicates current link history record being used. + */ + private LinkHistoryRecord currentLHRecord; + + /** + * Used to maintain whether backtracking -- as part of constraint solving -- has just occurred in processing current attribute. + */ + private Context backtrackedTo=null; + + /** + * Gets whether backtracking has occurred recently + * @return backtracking flag + */ + public Context hasBacktrackedTo() { return backtrackedTo; } + + /** + * Resets flag wrt backtracking + */ + public void resetDoneBacktracking() { backtrackedTo=null; } + + /** + * Indicates whether manipulations of context attributes should currently have undo records created for them + */ + private static boolean g_constraintsShouldUndo = false; + + /** + * Sets whether manipulations of context attributes should currently have undo records created for them + * @param shouldUndo + */ + public static void setConstraintsShouldUndo(boolean shouldUndo){ g_constraintsShouldUndo = shouldUndo; } + + /** + * Constructs ConstraintResolutionState, allocating a link history record + * + */ + ConstraintResolutionState(){ + currentLHRecord = new LinkHistoryRecord(); + linkHistory.add(currentLHRecord); + } + + /** + * Maintains a record pertaining to a single constraint evaluation + * @author anfarr + * + */ + private class ConstraintEvalHistoryRecord { + /** + * Indicates the current component description being processed + */ + LRSRecord lrsr; + /** + * Indicates the current attribute being processed, triggering constraint evaluation + */ + int idx; + /** + * The context of the component description + */ + Context cxt; + } + + /** + * Link history record + */ + private class LinkHistoryRecord { + /** + * The undo stack for this record + */ + Vector undo_stack = new Vector(); + /** + * Add a single undo record + * @param lrsu + */ + void addUndo(LRSUndoRecord lrsu){ undo_stack.add(lrsu); } + /** + * Undo all actions recorded herein + * + */ + void undoAll() { + for (int i=undo_stack.size()-1;i>=0;i--){ + ((LRSUndoRecord) undo_stack.remove(i)).undo(); + } + } + } + + /** + * Undo action: put, for putting values for attributes in contexts + */ + public static final int g_LRSUndo_PUT = 0x0; + + /** + * Undo action: put, for putting values for key into FreeVars + */ + public static final int g_LRSUndo_PUTFVINFO = 0x1; + + /** + * Undo action: put, for putting typing info into FreeVars + */ + public static final int g_LRSUndo_PUTFVTYPESTR = 0x2; + + + /** + * Maintains single undo actions + */ + private class LRSUndoRecord{ + /** + * Pertinent context for undo action + */ + Context ctxt; + /** + * Key for undo action + */ + Object key; + /** + * Value to eg put back in context for key + */ + Object value; + /** + * Type of action, eg put + */ + int type; + + FreeVar fv; + + /** + * Constructs single undo action to undo attribute setting in a Context + * @param ctxt context for undo action + * @param key key to undo put value + * @param value value to restore + */ + LRSUndoRecord(Context ctxt, Object key, Object value){ + this.type = g_LRSUndo_PUT; this.ctxt=ctxt; this.key=key; this.value=value; + } + + /** + * Constructs single undo action for undoing FreeVar manipulation + * @param fv FreeVar + * @param type What type of undoing should we do? Either undo type setting (g_LRSUndo_PUTFVTYPESTR) or cons eval info (g_LRSUndo_PUTFVINFO) + */ + LRSUndoRecord(FreeVar fv, int type){ + this.type = type; this.fv=fv; + } + + /** + * Does the undo! + * + */ + void undo(){ + switch (type){ + case g_LRSUndo_PUT: if (value!=null) ctxt.put(key, value); + else ctxt.remove(key); break; + case g_LRSUndo_PUTFVINFO: fv.resetConsEvalInfo(); break; + case g_LRSUndo_PUTFVTYPESTR: fv.clearTyping(); break; + } + } + } + + /** + * Adds single undo action to current lhr for undo attribute setting in a Context + * @param ctxt context for undo action + * @param key key to undo put value + * @param value value to restore + */ + public void addUndo(Context ctxt, Object key, Object value){ + currentLHRecord.addUndo(new LRSUndoRecord(ctxt, key, value)); + } + + /** + * Adds single undo action to current lhr for undoing FreeVar manipulation + * @param fv FreeVar + * @param type What type of undoing should we do? Either undo type setting (g_LRSUndo_PUTFVTYPESTR) or cons eval info (g_LRSUndo_PUTFVINFO) + */ + public void addUndo(FreeVar fv, int type){ + currentLHRecord.addUndo(new LRSUndoRecord(fv, type)); + } + + public void setTyping(String attr, Vector types){ + int last_cidx = constraintEvalHistory.size()-1; + ConstraintEvalHistoryRecord cehr = (ConstraintEvalHistoryRecord) constraintEvalHistory.get(last_cidx); + Object val = cehr.cxt.get(attr); + if (val instanceof FreeVar){ + FreeVar fv = (FreeVar) val; + fv.setTyping(types); + //need to add an undo record for the typing... + addUndo(fv, g_LRSUndo_PUTFVTYPESTR); + } + } + + public Object adjustSetValue(Object key){ + int last_cidx = constraintEvalHistory.size()-1; + ConstraintEvalHistoryRecord cehr = (ConstraintEvalHistoryRecord) constraintEvalHistory.get(last_cidx); + Object val = cehr.cxt.get(key); + if (val!=null && val instanceof ComponentDescription) return val; + else return key; + } + + /** + * Add an assingment of an attribute within a description + * @param idx The appropriate link history record + * @param key Attribute to set + * @param val Value to set + * @param cidx The appropriate constraint eval record + */ + + public boolean addConstraintAss(ComponentDescription solve_comp, int idx, String key, Object val, int cidx) throws SmartFrogResolutionException { + ConstraintEvalHistoryRecord cehr = (ConstraintEvalHistoryRecord) constraintEvalHistory.get(cidx); + + //Get typing information... + Object cur_val = cehr.cxt.get(key); + Vector types=null; + if (cur_val instanceof FreeVar) types = ((FreeVar) cur_val).getTyping(); + + if (types!=null && (!(val instanceof ComponentDescription) || + !ofTypes(solve_comp, (ComponentDescription)val, types))) return false; + + //set the value prescribed + g_constraintsShouldUndo=true; + cehr.cxt.put(key, val); + //System.out.println("Setting "+key+":"+cehr.cxt.get(key)+" in "+cidx); + g_constraintsShouldUndo=false; + + return true; + } + + public boolean ofTypes(ComponentDescription solve_comp, ComponentDescription comp, Vector types) throws SmartFrogResolutionException { + Context type_cxt = null; + try { + type_cxt = SFComponentDescriptionImpl.composeTypes(solve_comp, types).sfContext(); + } catch (SmartFrogResolutionException smfre){ + throw new SmartFrogResolutionException("Unable to compose types in sub-type evaluation."); + } + return type_cxt.ofType(comp); + } + + public void backtrackConstraintAss(int idx, int cidx){ + ConstraintEvalHistoryRecord cehr = (ConstraintEvalHistoryRecord) constraintEvalHistory.get(cidx); + + //need to backtrack cidx... + int constraintEvalHistoryLastIdx = constraintEvalHistory.size()-1; + + if (backtrackedTo==null && cidx<constraintEvalHistoryLastIdx) backtrackedTo = cehr.cxt; + + for (int i=constraintEvalHistoryLastIdx; i>cidx; i--) constraintEvalHistory.remove(i); + CoreSolver.getInstance().getRootDescription().setLRSIdx(cehr.idx); + CoreSolver.getInstance().getRootDescription().setLRSRecord(cehr.lrsr); + + //need to backtrack histroy as approp... + for (int i=linkHistory.size()-1; i>idx; i--){ + LinkHistoryRecord lhr = (LinkHistoryRecord) linkHistory.remove(i); + lhr.undoAll(); + } + + //create new history... + currentLHRecord = new LinkHistoryRecord(); + linkHistory.add(currentLHRecord); + } + + /** + * Add a record to cons eval history + * @param cxt Given context + * @return Latest record index + */ + public int addConstraintEval(Context cxt){ + int idx = constraintEvalHistory.size(); + ConstraintEvalHistoryRecord cehr = new ConstraintEvalHistoryRecord(); + cehr.lrsr = CoreSolver.getInstance().getRootDescription().getLRSRecord(); + cehr.idx = CoreSolver.getInstance().getRootDescription().getLRSIdx(); + cehr.cxt = cxt; + constraintEvalHistory.add(cehr); + return idx; + } + + /** + * Gets the latest record index of the cons eval history + * @return latest index + */ + public int getConsEvalIdx(){ + return constraintEvalHistory.size()-1; + } + +} Added: trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/CoreSolver.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/CoreSolver.java (rev 0) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/CoreSolver.java 2008-07-20 19:41:22 UTC (rev 6841) @@ -0,0 +1,192 @@ +package org.smartfrog.sfcore.languages.sf.constraints; + +import java.util.Enumeration; +import java.util.Iterator; +import java.util.Vector; + +import org.smartfrog.sfcore.common.Context; +import org.smartfrog.sfcore.common.SmartFrogResolutionException; +import org.smartfrog.sfcore.componentdescription.CDVisitor; +import org.smartfrog.sfcore.componentdescription.ComponentDescription; +import org.smartfrog.sfcore.languages.sf.sfcomponentdescription.SFComponentDescription; +import org.smartfrog.sfcore.security.SFClassLoader; + +public class CoreSolver { + private static Class solverClass = null; + private static CoreSolver solver; + protected SFComponentDescription top; + protected SFComponentDescription orig; + + /** + * Attempt to obtain an instance of the solver for the constraints. + * + * @return An instance of the solver class + * @throws org.smartfrog.sfcore.common.SmartFrogResolutionException + * + */ + public static CoreSolver getInstance(){ + try { + try { + if (solver==null){ + String classname=null; + + try {classname = System.getProperty("org.smartfrog.sfcore.languages.sf.constraints.SolverClassName"); + }catch (Exception e){/*Do nothing*/} + + try {if (classname==null) classname = System.getenv("SOLVERCLASS"); + }catch (Exception e){/*Do nothing*/} + + if (classname != null){ + solverClass = SFClassLoader.forName(classname); + solver = (CoreSolver) solverClass.newInstance(); + } + } + } finally { + if (solver==null) solver = new CoreSolver(); + solver.prepareSolver(); + } + } catch (Exception e) {/*Do nothing*/} + return solver; + } + + /** + * + */ + public void resetDescriptionMarkers(){ + top = null; + orig = null; + } + + /** + * + */ + public void setDescriptionMarkers(SFComponentDescription mark){ + if (orig==null) orig=mark; + top = mark; + } + + /** + * Gets the component description pertaining to sfConfig + * @return sfConfig component description + */ + public SFComponentDescription getRootDescription(){ return top; } + + /** + * + */ + public SFComponentDescription getOriginalDescription(){ return orig; } + + /** + * Solve constraint strings pertaining to a Constraint type... + * @param comp Pertaining Component Description + * @param attrs Attributes thereof + * @param values Values thereof + * @param goal Constraint goal to be solved + * @param autos Automatic variable attributes + * @param isuservars Whether there are user variables + * @throws Exception + */ + public void solve(ComponentDescription comp, Vector attrs, Vector values, Vector goal, Vector autos, boolean isuservars) throws Exception {} + + /** + * Indicates no more solving to be done for current sfConfig description + * @throws Exception + */ + public void stopSolving() throws Exception{} + + protected void prepareSolver() throws SmartFrogResolutionException {} + + public void setShouldUndo(boolean undo){} + + /** + * Add undo action to current lhr + * @param ctxt + * @param key + * @param value + */ + public void addUndo(Context ctxt, Object key, Object value){} + + /** + * Add undo action to current lhr + * @param fv + * @param type + */ + public void addUndo(FreeVar fv, int type){} + + public Context hasBacktrackedTo(){ return null; } + + public void resetDoneBacktracking(){} + + public boolean getConstraintsPossible(){ return false; } + + public boolean ignoreComponentDescription(SFComponentDescription sfcd){ + return sfcd.sfContext().get("sfIsGenerator")!=null; + } + + public void tidyConstraintBasedDescription(SFComponentDescription mark) throws SmartFrogResolutionException{ + try { + if (mark==getOriginalDescription()){ + tidyConstraintBasedDescriptionWkr(); + } + } catch (Exception e){ + throw new SmartFrogResolutionException(e); + } + } + + private void tidyConstraintBasedDescriptionWkr() throws Exception { + //Do a visit to every cd removing constraint annotations... + try { + this.getOriginalDescription().visit(new CDVisitor(){ + public void actOn(ComponentDescription node, java.util.Stack path){ + //Start by removing any child generator types + //CHOOSE NOT TO DO THIS FOR NOW. + /*Enumeration keys = node.sfContext().keys(); + while (keys.hasMoreElements()){ + Object key = keys.nextElement(); + Object val = node.sfContext().get(key); + if (val instanceof ComponentDescription){ + ComponentDescription val_cd = (ComponentDescription) val; + Object is_gen = val_cd.sfContext().get("sfIsGenerator"); + if (is_gen!=null) node.sfContext().remove(key); + } + }*/ + + //What about done function status etc? + Object functionClassStatus=node.sfContext().get("sfFunctionClassStatus"); + try { + if (functionClassStatus!=null && functionClassStatus.equals("done")){ + node.sfContext().remove("sfFunctionClassStatus"); + + //FIX for agg constraint... + node.sfContext().remove("sfConstraintAggregated"); + Object functionClass=node.sfContext().get("sfFunctionClass"); + node.sfContext().remove("sfFunctionClass"); + + //FIX -- Can it be any other type if in here...? + if (functionClass.equals("org.smartfrog.sfcore.languages.sf.functions.Constraint")){ + Enumeration attr_enum = node.sfContext().keys(); + Vector attr_keys = new Vector(); + while (attr_enum.hasMoreElements()){ + Object _key = attr_enum.nextElement(); + //Check not FreeVar as this should have been completed... + Object _val = node.sfContext().get(_key); + if (_val instanceof FreeVar) throw new SmartFrogResolutionException("VAR(s) are left in: "+node); + if (node.sfContext().sfContainsTag(_key, "sfConstraint")) { + attr_keys.add(_key); + } + } + Iterator attr_iter = attr_keys.iterator(); + while (attr_iter.hasNext()) node.sfContext().remove(attr_iter.next()); + } + } + } catch (Exception sfre){ throw new RuntimeException(sfre);} + } + }, true); + + } finally { + resetDescriptionMarkers(); + stopSolving(); + } + } + +} Added: trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/EclipseCDBrowser.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/EclipseCDBrowser.java (rev 0) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/EclipseCDBrowser.java 2008-07-20 19:41:22 UTC (rev 6841) @@ -0,0 +1,283 @@ +/** (C) Copyright 1998-2004 Hewlett-Packard Development Company, LP + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +For more information: www.smartfrog.org + +*/ +package org.smartfrog.sfcore.languages.sf.constraints; + +import java.awt.BorderLayout; +import java.awt.GridLayout; +import java.awt.Image; +import java.awt.Toolkit; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.KeyAdapter; +import java.awt.event.KeyEvent; +import java.net.URL; + +import javax.swing.Box; +import javax.swing.JButton; +import javax.swing.JFrame; +import javax.swing.JLabel; +import javax.swing.JPanel; +import javax.swing.JScrollPane; +import javax.swing.JTextField; +import javax.swing.JTree; +import javax.swing.event.TreeSelectionEvent; +import javax.swing.event.TreeSelectionListener; +import javax.swing.tree.DefaultMutableTreeNode; +import javax.swing.tree.DefaultTreeModel; +import javax.swing.tree.TreePath; +import javax.swing.tree.TreeSelectionModel; + + +/** + * Browser for displaying sfComfig hierarchy for the purpose of setting user variables + * @author anfarr + * + */ +public class EclipseCDBrowser extends JFrame implements CDBrowser { + private JScrollPane m_scpane; + private JLabel m_label; + private JLabel m_undo_label; + private JTextField m_entry; + private JButton m_set; + private JButton m_undo; + private JButton m_done; + private EclipseSolver.EclipseStatus m_est; + private EclipseSolver.EclipseCDAttr m_ecda; + private DefaultMutableTreeNode m_visnode; + + /** + * Kill the browser... + */ + public void kill(){ + setVisible(false); + } + + /** + * Sets an unspecified object as pertaining to the state of the solving engine + * @param est + */ + public void setES(Object est){ + m_est=(EclipseSolver.EclipseStatus) est; + } + + /** + * Add attribute to the hierarchy to be displayed + * @param d -- my parent as unspecified object + * @param av -- my attribute name / value as unspecified object + * @param showme -- am I in the immediate component description to be displayed? + * @return tree node which will be used later on to add child attributes to + */ + public Object attr(Object d, Object av, boolean showme){ + DefaultMutableTreeNode node = new DefaultMutableTreeNode(av); + + if (showme && m_visnode==null) m_visnode=node; + + if (root==null){ + root = node;; + } else { + ((DefaultMutableTreeNode) d).add(node); + } + return node; + } + + /** + * Redraws browser... + */ + public void redraw(){ + if (!isVisible()){ + init(); + } else { + + if (m_est.isBack()){ + m_est.setBack(false); + String label = "Attribute setting undone. "+m_label.getText(); + m_label.setText(label); + m_set.setEnabled(false); + } + int undo = m_est.getUndo(); + if (undo>0){ + m_undo_label.setText(m_est.getUndoLabel()); + m_undo.setText("Undo ("+undo+")"); + m_undo.setEnabled(true); + } else { + m_undo_label.setText(""); + m_undo.setText("Undo"); + m_undo.setEnabled(false); + } + m_done.setEnabled(m_est.isDone()); + + repaint(); + } + } + + /** + * Reset browser to initial look... + * + */ + void reset_display(){ + m_label.setText("Click on an attribute with range to set its value"); + m_entry.setText(""); + m_set.setEnabled(false); + m_entry.setEnabled(false); + } + + /** + * Initialise browser... + */ + void init(){ + setTitle("sfConfig Browser"); + setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT); + + // the root of the class tree is Object + model = new DefaultTreeModel(root); + tree = new JTree(model); + + // set up selection mode + tree.addTreeSelectionListener(new + TreeSelectionListener() + { + public void valueChanged(TreeSelectionEvent event) + { + // the user selected a different node--update description + TreePath path = tree.getSelectionPath(); + if (path == null) return; + DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) path.getLastPathComponent(); + Object uobj = selectedNode.getUserObject(); + if (uobj instanceof EclipseSolver.EclipseCDAttr){ + m_ecda = (EclipseSolver.EclipseCDAttr) uobj; + if (m_ecda.isSet()) reset_display(); + else { + m_set.setEnabled(false); + m_label.setText(m_ecda.toString()); + m_entry.setEnabled(true); + } + } else reset_display(); + } + }); + + int mode = TreeSelectionModel.SINGLE_TREE_SELECTION; + tree.getSelectionModel().setSelectionMode(mode); + + Box vbox = Box.createVerticalBox(); + add(vbox, BorderLayout.CENTER); + m_scpane = new JScrollPane(tree); + vbox.add(m_scpane); + + m_label = new JLabel(); + Box labelbox = Box.createHorizontalBox(); + labelbox.add(Box.createHorizontalGlue()); + labelbox.add(m_label); + labelbox.add(Box.createHorizontalGlue()); + vbox.add(labelbox); + + vbox.add(Box.createVerticalStrut(10)); + m_entry = new JTextField(); + vbox.add(Box.createVerticalGlue()); + vbox.add(m_entry); + vbox.add(Box.createVerticalStrut(10)); + + //set up selection mode + m_entry.addKeyListener(new KeyAdapter(){ + public void keyTyped(KeyEvent event){ + m_set.setEnabled(true); + repaint(); + } + }); + + JPanel hbox = new JPanel(); + hbox.setLayout(new GridLayout(2,3)); + vbox.add(hbox); + + m_set = new JButton("Set"); + Box setbox = Box.createHorizontalBox(); + setbox.add(m_set); + setbox.add(Box.createHorizontalGlue()); + hbox.add(setbox); + + m_undo = new JButton("Undo"); + m_undo.setEnabled(false); + Box undobox = Box.createHorizontalBox(); + undobox.add(Box.createHorizontalGlue()); + undobox.add(m_undo); + undobox.add(Box.createHorizontalGlue()); + hbox.add(undobox); + + m_done = new JButton("Done"); + m_done.setEnabled(false); + Box donebox = Box.createHorizontalBox(); + donebox.add(Box.createHorizontalGlue()); + donebox.add(m_done); + hbox.add(donebox); + + m_undo_label = new JLabel(""); + hbox.add(new JPanel()); + hbox.add(m_undo_label); + + reset_display(); + + m_set.addActionListener(new ActionListener(){ + public void actionPerformed(ActionEvent event){ + boolean succ = m_ecda.process_sel(m_entry.getText()); + if (succ) { + m_label.setText("Attribute set successfully"); + m_set.setEnabled(false); + m_entry.setEnabled(false); + } else { + m_label.setText("Value selected not in range:"+m_ecda.getRangeAsString()+". Please try again"); + } + m_entry.setText(""); + } + }); + + m_undo.addActionListener(new ActionListener(){ + public void actionPerformed(ActionEvent event){ + m_est.undo(); + } + }); + + m_done.addActionListener(new ActionListener(){ + public void actionPerformed(ActionEvent event){ + m_est.done(); + } + }); + + tree.makeVisible(new TreePath(model.getPathToRoot(m_visnode))); + + URL url = getClass().getResource("HP_ICON.PNG"); + if (url!=null){ + Image image=Toolkit.getDefaultToolkit().getImage(url); + if (image!=null){ + setIconImage(image); + } + } + + + setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + setVisible(true); + + } + + private DefaultMutableTreeNode root; + private DefaultTreeModel model; + private JTree tree; + private static final int DEFAULT_WIDTH = 600; + private static final int DEFAULT_HEIGHT = 400; + } + Added: trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/EclipseSolver.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/EclipseSolver.java (rev 0) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/constraints/EclipseSolver.java 2008-07-20 19:41:22 UTC (rev 6841) @@ -0,0 +1,849 @@ +/** (C) Copyright 1998-2007 Hewlett-Packard Development Company, LP + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +For more information: www.smartfrog.org + +*/ +package org.smartfrog.sfcore.languages.sf.constraints; + + +import java.io.File; +import java.io.IOException; +import java.util.Collection; +import java.util.Collections; +import java.util.Enumeration; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Vector; +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.ReentrantLock; + +import org.smartfrog.SFParse; +import org.smartfrog.SFSystem; +import org.smartfrog.sfcore.common.Context; +import org.smartfrog.sfcore.common.SFNull; +import org.smartfrog.sfcore.common.SmartFrogResolutionException; +import org.smartfrog.sfcore.componentdescription.CDVisitor; +import org.smartfrog.sfcore.componentdescription.ComponentDescription; +import org.smartfrog.sfcore.languages.sf.sfreference.SFApplyReference; +import org.smartfrog.sfcore.languages.sf.sfreference.SFReference; +import org.smartfrog.sfcore.reference.AttribReferencePart; +import org.smartfrog.sfcore.reference.Reference; +import org.smartfrog.sfcore.reference.ReferencePart; +import org.smartfrog.sfcore.security.SFClassLoader; + +import com.parctechnologies.eclipse.Atom; +import com.parctechnologies.eclipse.CompoundTerm; +import com.parctechnologies.eclipse.CompoundTermImpl; +import com.parctechnologies.eclipse.EXDRInputStream; +import com.parctechnologies.eclipse.EXDROutputStream; +import com.parctechnologies.eclipse.EclipseEngine; +import com.parctechnologies.eclipse.EclipseEngineOptions; +import com.parctechnologies.eclipse.EmbeddedEclipse; +import com.parctechnologies.eclipse.FromEclipseQueue; +import com.parctechnologies.eclipse.QueueListener; +import com.parctechnologies.eclipse.ToEclipseQueue; + +/** + * Implementation of solver for Eclipse + */ +public class EclipseSolver extends CoreSolver implements Runnable, QueueListener { + + /** + * Default Eclipse options + */ + private EclipseEngineOptions m_eclipseEngineOptions; + + /** + * Eclipse engine + */ + private EclipseEngine m_eclipse; + + /** + * Record object to send to eclipse side + */ + Object m_get_val; + + /** + * Thread for main eclipse goal + */ + Thread m_ecr; + + /** + * sfConfig browser for purpose of setting user variables + */ + CDBrowser m_cdbm; + + /** + * Are there user variables? + */ + boolean m_isuservars; + + /** + * Component description pertaining to Constraint type being solved + */ + ComponentDescription m_solve_comp; + + /** + * Queue for coms TO eclipse + */ + ToEclipseQueue m_java_to_eclipse; + + /** + * Queue for coms FROM eclipse + */ + FromEclipseQueue m_eclipse_to_java; + /** + * Lock for object, so that solve method waits until constraint goal done before exiting + */ + ReentrantLock m_solverLock = new ReentrantLock(); + /** + * Condition for lock, so that solve method waits until constraint goal done before exiting + */ + Condition m_solverFinished = m_solverLock.newCondition(); + /** + * Indicates whether the eclipse secondary thread (for main eclipse goal) has sought and lock yet + */ + boolean m_ecr_sought_lock = false; + /** + * Latest constraint goal has finished? + */ + boolean m_cons_finished = false; + + /** + * Stores any exception thrown from Eclipse thread + */ + Exception m_general_error = null; + + /** + * Relative path to constraint theory files + */ + private static final String pathswitch = "/../constraints/"; + + /** + * Name of core theory file + */ + private static final String coreFileSuffix = "core.ecl"; + /** + * Name of additional theory file + */ + private static final String theoryFileSuffix = "base.ecl"; + + /** + * Property indicating where to find additional user-specified theory files + */ + private final String theoryFilePath = "opt.smartfrog.sfcore.languages.sf.constraints.theoryFilePath"; + + + private ConstraintResolutionState m_cresState; + + /** + * Eclipse main goal to run in secondary thread + */ + public void run(){ + try { + m_eclipse.rpc("sfsolve"); + } catch (Exception e){ + m_general_error=e; + yieldLockFromECRThread(); + } + } + + private static String sfHOME = SFSystem.getEnv("SFHOME"); + private static String corefile = sfHOME+pathswitch+coreFileSuffix; + private static String thfile = sfHOME+pathswitch+theoryFileSuffix; + + static { + if (sfHOME!=null){ + corefile = sfHOME+pathswitch+coreFileSuffix; + thfile = sfHOME+pathswitch+theoryFileSuffix; + } + } + + public boolean getConstraintsPossible(){ return true; } + + + /** + * Prepare the solver + */ + protected void prepareSolver() throws SmartFrogResolutionException { + + if (sfHOME==null){ + throw new SmartFrogResolutionException("Environment variable SFHOME must be set. Context: constraint processing"); + } + + // create the theory + try { + prepareTheory(corefile,thfile); + } catch (Exception e) { + throw new SmartFrogResolutionException("Unable to parse base theory for constraint resolution. ", e); + } + + //Add the path root + String thpath = System.getProperty(theoryFilePath); + + if (thpath!=null){ + try { + runGoal("add_path(\""+thpath+"\")"); + } catch (Exception e) { + throw new SmartFrogResolutionException("Unable to add root theory file path. ", e); + } + } + } + + public void resetDoneBacktracking(){ + if (m_cresState!=null) m_cresState.resetDoneBacktracking(); + } + + public Context hasBacktrackedTo(){ + if (m_cresState!=null) return m_cresState.hasBacktrackedTo(); + else return null; + } + + public void setShouldUndo(boolean undo){ + if (m_cresState!=null) m_cresState.setConstraintsShouldUndo(undo); + } + + /** + * Add undo action to current lhr + * @param ctxt + * @param key + * @param value + */ + public void addUndo(Context ctxt, Object key, Object value){ + if (m_cresState!=null) m_cresState.addUndo(ctxt, key, value); + } + + /** + * Add undo action to current lhr + * @param fv + * @param type + */ + public void addUndo(FreeVar fv, int type){ + if (m_cresState!=null) m_cresState.addUndo(fv, type); + } + + + + /** + * Prepare the engine with two theories + */ + public void prepareTheory(String coreFile, String coreFile2) throws Exception { + // Get Eclipse Installation Directory... + String eclipseDirectory = System.getenv("ECLIPSEDIRECTORY"); + + if (eclipseDirectory==null) throw new Exception(); //handle properly... + + //Set up eclipse... + m_eclipseEngineOptions = new EclipseEngineOptions(new File(eclipseDirectory)); + + // Connect the Eclipse's standard streams to the JVMs + m_eclipseEngineOptions.setUseQueues(false); + + // Initialise Eclipse + m_eclipse = EmbeddedEclipse.getInstance(m_eclipseEngineOptions); + + //Consult core theory file + m_eclipse.compile(new File(coreFile)); + + //Consult core theory file + m_eclipse.compile(new File(coreFile2)); + + // Set up the java representation of two queue streams + m_java_to_eclipse = m_eclipse.getToEclipseQueue("java_to_eclipse"); + m_eclipse_to_java = m_eclipse.getFromEclipseQueue("eclipse_to_java"); + + m_eclipse_to_java.setListener(this); + } + + /** + * Run eclipse goal... + */ + public void runGoal(String goal){/*Do nothing for now*/}; + + /** + * Stop solving altogether + */ + public void stopSolving() throws Exception { + m_get_val = "sfstop"; + try{ + m_java_to_eclipse.setListener(this); + //((EmbeddedEclipse) m_eclipse).destroy(); Do not destroy. Remove this. Need to do a "clean" of existing... + }catch(Exception e){} + m_ecr=null; + m_cresState = null; + } + + /** + * Solve a Constraint goal + */ + public void solve(ComponentDescription comp, Vector attrs, Vector values, Vector goal, Vector autos, boolean isuservars) throws Exception { + + //New Constraint Evaluation History, if appropriate... + if (m_cresState==null) m_cresState = new ConstraintResolutionState(); + + //Set comp as current solving comp descr + m_solve_comp = comp; + + //Set is user vars? + m_isuservars = isuservars; + + //Construct goal + String _attrs = mapValueJE(attrs); + String _values = mapValueJE(values); + String _goal = mapValueJE(goal); + String _autos = mapValueJE(autos); + String verbose = (SFParse.isVerboseOptSet() ? "true":"false"); + + m_get_val = "sfsolve("+_attrs+", "+_values+", "+ + m_cresState.addConstraintEval(comp.sfContext())+", "+_goal+", "+_autos+", "+verbose+")"; + + //System.out.println(m_get_val); + + //Allocate new thread for goal and start it + m_cons_finished = m_ecr_sought_lock = false; + + if (m_ecr==null) { + m_ecr = new Thread(this); + m_ecr.start(); + } + + //Let rip... + try{ m_java_to_eclipse.setListener(this); } catch(Exception e){} + + //Lock me to make sure I don't complete before constraint eval does... + m_solverLock.lock(); + if (!m_cons_finished) m_solverFinished.await(); + m_solverLock.unlock(); + + if (m_general_error!=null) throw m_general_error; + } + + /** + * Maps Java object to String for transfer to Eclipse + * @param v object to be transformed + * @return eclipse string + */ + private String mapValueJE(Object v) throws SmartFrogResolutionException { + return mapValueJE(v, false); + } + + /** + * Maps Java object to String for transfer to Eclipse + * @param v object to be transformed + * @param quoted indicates whether Strings should be double quoted + * @return eclipse string + */ + private String mapValueJE(Object v, boolean quoted) throws SmartFrogResolutionException { + if (v instanceof FreeVar) { + FreeVar fv = (FreeVar) v; + if (fv.getConsEvalKey()!=null){ + if (fv.getConsEvalIdx()==-1){ + fv.setConsEvalIdx(m_cresState.getConsEvalIdx()+1); //+1 as yet to add entry + + String range_s = "null"; + Object range = fv.getRange(); + if (range!=null){ + if (range instanceof String) range_s = (String) range; + else if (range instanceof Vector) range_s = mapValueJE(range); + else throw new SmartFrogResolutionException("Invalid range specifier for FreeVar: "+v); + } + + Object defVal = fv.getDefVal(); + String defVal_s = (defVal!=null? defVal_s=", "+defVal.toString() : ""); + return "sfvar("+range_s+defVal_s+")"; + + } else return "sfref("+fv.getConsEvalIdx()+", "+fv.getConsEvalKey()+")"; + } else { + return v.toString(); + } + } + else if (v instanceof Number) return v.toString(); + else if (v instanceof Vector) { + String val = "["; + boolean first=true; + Iterator it = ((Vector)v).iterator(); + while (it.hasNext()) { + if (first) first=false; + else val += ", "; + + val += mapValueJE(it.next(), quoted); + } + val += "]"; + return val; + } else if (v instanceof String) { + if (quoted) return "\""+v+"\""; + else return (String)v; + } else if (v instanceof SFNull){ + return "sfnull"; + } else if (v instanceof SFReference) { + ReferencePart rp = ((SFReference)v).firstElement(); + if (rp instanceof AttribReferencePart) { + String ret_s = ((AttribReferencePart)rp).getValue().toString(); + if (quoted) ret_s = "\""+ret_s+"\""; + return ret_s; + } + else return null; + } + else if (v instanceof ComponentDescription) return "sfcd"; + else if (v instanceof Boolean) return (((Boolean)v).booleanValue() ? "true" : "false"); + else return null; + } + + + /** + * Maps Eclipse object to Java object after transfer from Eclipse + * @param v object to be transformed + * @return transformed object + */ + private Object mapValueEJ(Object v) { + return mapValueEJ(v, false); + } + + /** + * Maps Eclipse object to Java object after transfer from Eclipse + * @param v object to be transformed + * @param ref_create indicates whether references should be created for atoms -- used for subtyping directives + * @return transformed object + */ + private Object mapValueEJ(Object v, boolean ref_create) { + if (v==null) return new FreeVar(); + else if (v.equals(Collections.EMPTY_LIST)) return new Vector(); + else if (v instanceof Number) return v; + else if (v instanceof Collection) { + Vector result = new Vector(); + Iterator it = ((Collection)v).iterator(); + while (it.hasNext()) result.add(mapValueEJ(it.next(), ref_create)); + return result; + } else if (v instanceof String) return v; + else if (v instanceof Atom){ + Atom va = (Atom) v; + if (va.functor().equals("sfnull")) return SFNull.get(); + else { + String va_s = va.functor(); + try { + if (ref_create) return Reference.fromString(va_s); + return va_s; + } catch (SmartFrogResolutionException sfre){ + throw new SmartFrogEclipseRuntimeException("mapValueEJ: Trouble in creating reference from attribute string for subtyping. "); + } + } + } else throw new SmartFrogEclipseRuntimeException("mapValueEJ: unknown data *from* solver " + v); + } + + /** + * Unchecked Eclipse Exception, for throwing from Listeners dataAvailable, dataRequest + * @author anfarr + * + */ + static public class SmartFrogEclipseRuntimeException extends RuntimeException { + SmartFrogEclipseRuntimeException(Throwable cause){ + super(null, cause); + } + SmartFrogEclipseRuntimeException(String msg, Throwable cause){ + super(msg, cause); + } + SmartFrogEclipseRuntimeException(String msg){ + super(msg, null); + } + } + + EclipseStatus m_est; + Vector m_rangeAttrs = new Vector(); + EclipseCDAttr m_ecda; + + public class EclipseStatus{ + private boolean done; + private int undo; + private boolean back; + private String ref; + private String val; + + public void undo(){ + m_get_val = new Atom("back"); + try{ + m_java_to_eclipse.setListener(EclipseSolver.this); + } catch (Exception e){ + throw new SmartFrogEclipseRuntimeException("Unanable to set JtoE listener"); + } + } + + public void done(){ + + m_cdbm.kill(); + Iterator atiter = m_rangeAttrs.iterator(); + m_get_val=new Atom("done"); + + try{ + m_java_to_eclipse.setListener(EclipseSolver.this); + } catch (Exception e){ + throw new SmartFrogEclipseRuntimeException("Unable to set JtoE listener"); + } + + } + + public boolean isDone(){ + return done; + } + + public void setBack(boolean back){ + this.back=back; + } + + public boolean isBack(){ + return back; + } + + public int getUndo(){ + return undo; + } + + public String getUndoLabel(){ + if (ref!=null) return ref+" currently set to "+val; + else return ""; + } + } + + + public class EclipseCDAttr { + private String name; + private Object val; + private Object range; + private boolean set; + private ComponentDescription cd; + private Class vclass; + + public boolean isSet(){ + return set; + } + + public boolean process_sel(String entry){ + m_ecda = this; + Collection c = (Collection) range; + Iterator iter = c.iterator(); + while (iter.hasNext()){ + String el = iter.next().toString(); + if (el.equals(entry)){ + m_get_val = new CompoundTermImpl("set", new Atom(name), new Atom(entry)); + try{ + m_java_to_eclipse.setListener(EclipseSolver.this); + } catch (Exception e){ + throw new SmartFrogEclipseRuntimeException("Unanable to reset JtoE listener"); + } + + return true; + } + } + return false; + } + + public String getRangeAsString(){ + return range.toString(); + } + + public String getAttrName(){ + return name; + } + + public String toString(){ + if (set){ + return name+" has value: "+val; + } else { + return name+" ranges over: "+range; + } + } + } + + void populateBrowser(){ + Object root = m_cdbm.attr(null, "sfConfig", false); + populateBrowser(orig, root, false); + } + + void populateBrowser(ComponentDescription cd, Object root, boolean showme){ + + Iterator attriter = cd.sfAttributes(); + Context cxt = cd.sfContext(); + //String cxts = create_ref_str(cd); + while (attriter.hasNext()){ + Object attr = attriter.next(); + + Object val = null; + + try { + val = cxt.sfResolveAttribute(attr); + } catch (Exception e){ + throw new SmartFrogEclipseRuntimeException("Can not resolve attribute when populating browser", e); + } + + if (val instanceof SFApplyReference){ + SFApplyReference val_ar = (SFApplyReference) val; + val = val_ar.getComponentDescription(); + } + + if (val instanceof ComponentDescription){ + boolean showkids = (!showme && m_solve_comp==val); + Object chroot = m_cdbm.attr(root, attr.toString(), showme); + populateBrowser((ComponentDescription)val, chroot, showkids); + } else { + EclipseCDAttr ecda = new EclipseCDAttr(); + ecda.cd = cd; + ecda.name = attr.toString(); + ecda.val = val; + m_cdbm.attr(root, ecda, showme); + try { + if (cd==m_solve_comp && cxt.sfContainsTag(attr, "sfConstraintUserVar") && val instanceof FreeVar) { + m_rangeAttrs.add(ecda); + ecda.set=false; + } else { + ecda.set=true; + } + } catch (Exception e){ + throw new SmartFrogEclipseRuntimeException("Can not check attribute for tag", e); + } + + } + + } + + } + + void sfuser(){ + + String classname = System.getProperty("org.smartfrog.sfcore.languages.sf.constraints.CDBrowser"); + if (classname==null || !m_isuservars){ + m_get_val = new Atom("done"); + try{ + m_java_to_eclipse.setListener(EclipseSolver.this); + } catch (Exception e){ + throw new SmartFrogEclipseRuntimeException("Unable to set JtoE listener"); + } + return; + } + + try { + m_cdbm = (CDBrowser) SFClassLoader.forNa... [truncated message content] |
From: <ju...@us...> - 2008-08-29 18:13:27
|
Revision: 7005 http://smartfrog.svn.sourceforge.net/smartfrog/?rev=7005&view=rev Author: julgui Date: 2008-08-29 18:13:23 +0000 (Fri, 29 Aug 2008) Log Message: ----------- Added simple diag for Loggers Modified Paths: -------------- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/Diagnostics.java trunk/core/smartfrog/src/org/smartfrog/sfcore/logging/LogFactory.java Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/common/Diagnostics.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/Diagnostics.java 2008-08-29 18:13:15 UTC (rev 7004) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/common/Diagnostics.java 2008-08-29 18:13:23 UTC (rev 7005) @@ -49,6 +49,7 @@ import org.smartfrog.sfcore.processcompound.SFProcess; import org.smartfrog.sfcore.security.SFClassLoader; import org.smartfrog.sfcore.security.SFSecurity; +import org.smartfrog.sfcore.logging.LogFactory; import java.io.File; import java.io.FileOutputStream; @@ -187,6 +188,8 @@ header(out, "Locale information"); doReportLocale(out); + + doReportLoggers (out); } @@ -868,4 +871,15 @@ } + /** + * Report list of Logger registered in LogFactory + * @param out StringBuffer + */ + public static void doReportLoggers(StringBuffer out) { + header(out, "Loggers registered in process compound"); + LogFactory.doReportLoggers(out); + out.append(out); + out.append("\n"); + } + } Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/logging/LogFactory.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/logging/LogFactory.java 2008-08-29 18:13:15 UTC (rev 7004) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/logging/LogFactory.java 2008-08-29 18:13:23 UTC (rev 7005) @@ -11,6 +11,7 @@ import java.rmi.RemoteException; import java.util.Hashtable; +import java.util.Enumeration; /** * Log Factory @@ -293,5 +294,21 @@ return getOwnerLog(owner, owner); } + /** + * Report list of Logger registered in LogFactory + * @param out StringBuffer + */ + public static void doReportLoggers(StringBuffer out) { + for (Enumeration e = loggers.keys(); e.hasMoreElements(); ) { + out.append ((String) e.nextElement()); + out.append ("\n"); + } + } + public String toString () { + StringBuffer out = new StringBuffer(); + doReportLoggers(out); + return out.toString(); + } + } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2008-11-27 11:06:27
|
Revision: 7190 http://smartfrog.svn.sourceforge.net/smartfrog/?rev=7190&view=rev Author: steve_l Date: 2008-11-27 11:06:23 +0000 (Thu, 27 Nov 2008) Log Message: ----------- get rid of some Javadoc warnings about @TODO tags Modified Paths: -------------- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/DumperCDImpl.java trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/ProcessCompoundImpl.java Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/common/DumperCDImpl.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/DumperCDImpl.java 2008-11-26 17:20:19 UTC (rev 7189) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/common/DumperCDImpl.java 2008-11-27 11:06:23 UTC (rev 7190) @@ -139,7 +139,7 @@ String name = ((HereReferencePart)(relativeRef.lastElement())).getValue().toString(); - //relativeRef.removeElement(relativeRef.size()-1); // @todo OLD way, comment to be removed when removeLastElement is properly tested. + //relativeRef.removeElement(relativeRef.size()-1); // todo OLD way, comment to be removed when removeLastElement is properly tested. relativeRef.removeLastElement(); //Place stateCopy in the right spot inside cd. Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/ProcessCompoundImpl.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/ProcessCompoundImpl.java 2008-11-26 17:20:19 UTC (rev 7189) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/ProcessCompoundImpl.java 2008-11-27 11:06:23 UTC (rev 7190) @@ -751,7 +751,7 @@ * @return reference of attribute names to this component * * @throws RemoteException In case of network/rmi error - * @TODO: clean cache when re-parenting + * TODO: clean cache when re-parenting */ public Reference sfCompleteName() throws RemoteException { This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <an...@us...> - 2009-01-21 15:37:39
|
Revision: 7277 http://smartfrog.svn.sourceforge.net/smartfrog/?rev=7277&view=rev Author: anfarr Date: 2009-01-21 15:37:35 +0000 (Wed, 21 Jan 2009) Log Message: ----------- SFOS-1025: Constraint enhancements Modified Paths: -------------- trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/Aggregator.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/Array.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/BaseFunction.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/Constraint.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/sfcomponentdescription/SFComponentDescriptionImpl.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/sfreference/SFApplyReference.java trunk/core/smartfrog/src/org/smartfrog/sfcore/reference/ApplyReference.java trunk/core/smartfrog/src/org/smartfrog/sfcore/reference/Function.java Added Paths: ----------- trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/DynamicPolicyEvaluation.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/PrettyPrint.java Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/Aggregator.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/Aggregator.java 2009-01-20 16:46:51 UTC (rev 7276) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/Aggregator.java 2009-01-21 15:37:35 UTC (rev 7277) @@ -21,21 +21,23 @@ package org.smartfrog.sfcore.languages.sf.functions; import java.util.Enumeration; +import java.util.HashMap; import java.util.Vector; import org.smartfrog.sfcore.common.Context; import org.smartfrog.sfcore.common.MessageKeys; import org.smartfrog.sfcore.common.SmartFrogFunctionResolutionException; -import org.smartfrog.sfcore.common.SmartFrogResolutionException; import org.smartfrog.sfcore.componentdescription.ComponentDescription; import org.smartfrog.sfcore.languages.sf.DefaultParser; +import org.smartfrog.sfcore.languages.sf.constraints.ConstraintConstants; import org.smartfrog.sfcore.languages.sf.constraints.CoreSolver; import org.smartfrog.sfcore.languages.sf.constraints.FreeVar; +import org.smartfrog.sfcore.languages.sf.functions.Constraint.CompositeSource; import org.smartfrog.sfcore.languages.sf.sfreference.SFApplyReference; import org.smartfrog.sfcore.reference.Reference; /** - * Defines the Constraint function. + * Does aggregation, pasting aggregated output into contained apply references */ public class Aggregator extends BaseFunction implements MessageKeys { @@ -45,109 +47,47 @@ * @return an Object representing the answer * @throws SmartFrogFunctionResolutionException if any of the parameters are not there or of the wrong type * */ - protected Object doFunction() throws SmartFrogFunctionResolutionException { - ComponentDescription comp = context.getOriginatingDescr(); - Context orgContext = comp.sfContext(); - ComponentDescription source_cd; - Object source_obj; - Reference src_ref; - String path_s; - - //Hybrid attribute? - Object arraypath = orgContext.get("sfAggregatorPath"); - if (arraypath!=null){ - //then it should be valid - if (!(arraypath instanceof String)) throw new SmartFrogFunctionResolutionException("AggregatorPath in Aggregator: "+comp+" should be a String"); - String arraypath_s = (String) arraypath; - int src_idx = arraypath_s.indexOf(":"); - if (src_idx<0) throw new SmartFrogFunctionResolutionException("AggregatorPath in Aggregator: "+comp+" is incorrectly formatted"); - String src_s = arraypath_s.substring(0, src_idx); - try { - src_ref = Reference.fromString(src_s); - } catch (SmartFrogResolutionException e){ throw new SmartFrogFunctionResolutionException("Cannot construct reference for source array from AggregatorPath in Aggregator: "+comp); } - path_s = arraypath_s.substring(src_idx); - - //System.out.println("Source:"+src_s+", Path:"+path_s); - } else { - //otherwise we look for split version... - //Source - Object arraysource = orgContext.get("sfAggregatorArraySource"); - if (arraysource==null || !(arraysource instanceof Reference)) throw new SmartFrogFunctionResolutionException("ArraySource in Aggregator: "+comp+" should be a REFERENCE to a ComponentDescription"); - src_ref = (Reference) arraysource; - - //Attr Path - Object attrpath = orgContext.get("sfAggregatorAttributePath"); - if (attrpath==null || !(attrpath instanceof String)) throw new SmartFrogFunctionResolutionException("AttributePath in Aggregator: "+comp+" should be a String"); - path_s = ":"+attrpath; - } + protected Object doFunction() throws SmartFrogFunctionResolutionException { + java.util.Vector<CompositeSource> css = new java.util.Vector<CompositeSource>(); + HashMap<Object, Object> others = new HashMap<Object, Object>(); + + //System.out.println("Getting sources..."); + + Constraint.getCompositeSources(comp, css, null, true); + + //System.out.println("Got sources..."); + + CoreSolver.getInstance().setShouldUndo(true); - try { - source_obj = comp.sfResolve(src_ref); - } catch (Exception e){ throw new SmartFrogFunctionResolutionException(e); } - if (source_obj==null || !(source_obj instanceof ComponentDescription)) throw new SmartFrogFunctionResolutionException("ArraySource in Aggregator: "+comp+" should resolve to a COMPONENT DESCRIPTION"); - source_cd = (ComponentDescription) source_obj; - - - Vector arguments = new Vector(); - extractArgumentsFromSource(comp, source_cd, path_s, arguments); - - CoreSolver.getInstance().setShouldUndo(true); - - //Attach arguments to contained function types... - Enumeration el_enum = orgContext.keys(); - while (el_enum.hasMoreElements()){ - String key = (String) el_enum.nextElement(); - - if (key.indexOf("sf")==0) continue; //ignore sf attributes... - - Object val = orgContext.get(key); - if (val instanceof SFApplyReference){ - ComponentDescription val_comp = ((SFApplyReference) val).getComponentDescription(); - insertArguments(arguments, val_comp); - } - } + for (int i=0; i<css.size(); i++){ + CompositeSource cs = css.get(i); + + //System.out.println("****"+cs); + + Constraint.extractArgumentsFromSource(cs); + + //Attach arguments to contained function types... + Enumeration el_enum = orgContext.keys(); + while (el_enum.hasMoreElements()){ + String key = (String) el_enum.nextElement(); + + if (key.indexOf("sf")==0) continue; //ignore sf attributes... + + Object val = orgContext.get(key); + if (val instanceof SFApplyReference){ + ComponentDescription val_comp = ((SFApplyReference) val).getComponentDescription(); + insertArguments(cs.arguments.getArgs(), val_comp); + } + } - orgContext.put("sfFunctionClassStatus", "done"); + } + + orgContext.put(ConstraintConstants.FunctionClassStatus, ConstraintConstants.FCS_DONE); CoreSolver.getInstance().setShouldUndo(false); - return null; + return comp; } - static boolean extractArgumentsFromSource(ComponentDescription comp, ComponentDescription source_cd, String path_s, Vector arguments) throws SmartFrogFunctionResolutionException { - Object sourceClass = source_cd.sfContext().get("sfFunctionClass"); - if (!sourceClass.equals("org.smartfrog.sfcore.languages.sf.functions.Array")) throw new SmartFrogFunctionResolutionException("Source in Aggregator: "+comp+" must have orginated as an Array type"); - - //Extent - Object extent = source_cd.sfContext().get("sfArrayExtent"); - - //Prefix - String prefix_s = (String) source_cd.sfContext().get("sfArrayPrefix"); - - boolean freevar=false; - - if (extent instanceof Integer){ - int ext_int = ((Integer)extent).intValue(); - for (int i=0; i<ext_int; i++){ - String el = prefix_s+i; - Object arg = resolve(source_cd, el+path_s); - if (freevar==false && isFreeVar(arg)) freevar=true; - if (arg!=null) arguments.add(arg); - } - } else if (extent instanceof Vector){ - Vector ext_vec = (Vector)extent; - for (int i=0; i<ext_vec.size(); i++){ - Object suff = ext_vec.get(i); - if (!(suff instanceof String)) throw new SmartFrogFunctionResolutionException("Vector extent in Array: "+source_cd+" should be comprised of Strings"); - String el=prefix_s+suff; - Object arg = resolve(source_cd, el+path_s); - if (freevar==false && isFreeVar(arg)) freevar=true; - if (arg!=null) arguments.add(arg); - } - } - - return freevar; - } - static boolean isFreeVar(Object arg){ if (arg instanceof FreeVar) return true; else if (arg instanceof Vector){ Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/Array.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/Array.java 2009-01-20 16:46:51 UTC (rev 7276) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/Array.java 2009-01-21 15:37:35 UTC (rev 7277) @@ -25,17 +25,24 @@ import org.smartfrog.sfcore.common.Context; import org.smartfrog.sfcore.common.MessageKeys; +import org.smartfrog.sfcore.common.SFNull; +import org.smartfrog.sfcore.common.SmartFrogContextException; import org.smartfrog.sfcore.common.SmartFrogFunctionResolutionException; +import org.smartfrog.sfcore.common.SmartFrogResolutionException; import org.smartfrog.sfcore.componentdescription.ComponentDescription; +import org.smartfrog.sfcore.languages.sf.constraints.ConstraintConstants; import org.smartfrog.sfcore.languages.sf.constraints.CoreSolver; +import org.smartfrog.sfcore.languages.sf.functions.Constraint.ComponentResolution; import org.smartfrog.sfcore.languages.sf.sfreference.SFApplyReference; +import org.smartfrog.sfcore.prim.Prim; import org.smartfrog.sfcore.reference.Reference; /** * Defines the Constraint function. */ -public class Array extends BaseFunction implements MessageKeys { - +public class Array extends BaseFunction implements MessageKeys { + + private int idx=0; /** * The method to implement the functionality of the if-then-else function. * @@ -43,109 +50,260 @@ * @throws SmartFrogFunctionResolutionException if any of the parameters are not there or of the wrong type * */ protected Object doFunction() throws SmartFrogFunctionResolutionException { - ComponentDescription comp = context.getOriginatingDescr(); - Context orgContext = comp.sfContext(); - - int idx=0; - Vector vec_extent = new Vector(); + Object result=null; + try {result=doFunctionWkr();} catch (SmartFrogContextException e){/*Shouldn't happen*/} + return result; + } + + /** + * Internal worker method for doFunction + * @return result of applying function + * @throws SmartFrogFunctionResolutionException + * @throws SmartFrogContextException + */ + private Object doFunctionWkr() throws SmartFrogFunctionResolutionException, SmartFrogContextException { + Object dest = comp; CoreSolver.getInstance().setShouldUndo(true); - Object prefix = orgContext.get("sfArrayPrefix"); - if (prefix==null || !(prefix instanceof String)) throw new SmartFrogFunctionResolutionException("Prefix in Array: "+comp+" should be a String"); - String prefix_s = (String)prefix; - + //Now do the tagged versions... + Enumeration key_enum = orgContext.keys(); + Object key = key_enum.nextElement(); - Object generator = orgContext.get("sfArrayGenerator"); - Object extent = orgContext.get("sfArrayExtent"); + Object path=null; + Object prefix=null; + String prefix_s=null; - if (generator!=null || extent!=null){ + //Get the prefix... + prefix = orgContext.get(ConstraintConstants.PREFIX); - if (extent instanceof Vector) { - Vector extent_v = (Vector) extent; - for (int i=0;i<extent_v.size();i++) vec_extent.add(extent_v.get(i)); + if (prefix==null){ + while (true){ //Get first attribute of note + key = key_enum.nextElement(); + if (orgContext.sfContainsTag(key, ConstraintConstants.PREFIX_TAG)){ + prefix = orgContext.get(key); + + break; + } } - - //Do the standard generator and extent - idx = processExtentGenerator(idx, comp, prefix_s, generator, extent); - - generator = extent = null; + } + if (prefix==null) throw new SmartFrogFunctionResolutionException("Array: "+comp+" has no prefix"); + + if (prefix instanceof String) prefix_s= (String) prefix; + else throw new SmartFrogFunctionResolutionException("In Array: "+comp+", prefix must be a String..."); + + /* PATH's are not currently offered for Arrays for simplicity. Additional measures for link resolution would need to be taken otherwise which I feel complicate matters + path = orgContext.get(ConstraintConstants.PATH); + + + boolean spare_key=false; + if (path==null){ + //Is there a path? + if (key_enum.hasMoreElements()) { + key = key_enum.nextElement(); + if (orgContext.sfContainsTag(key, ConstraintConstants.PATH_TAG)) path = orgContext.get(key); + else spare_key=true; + } } - //Now do the tagged versions... - Enumeration attr_enum = orgContext.keys(); - while (attr_enum.hasMoreElements()){ - Object attr = attr_enum.nextElement(); - try { - if (orgContext.sfContainsTag(attr, "sfArrayExtentGenerator")){ - Object val = orgContext.get(attr); - if (!(val instanceof Vector)) throw new SmartFrogFunctionResolutionException("sfArrayExtentGenerator-tagged attributes in Array: "+comp+" must have Vector values."); - Vector val_vec = (Vector) val; - if (val_vec.size()!=2) throw new SmartFrogFunctionResolutionException("sfArrayExtentGenerator-tagged attributes in Array: "+comp+" must have Vector values with 2 members."); - extent = val_vec.get(0); - generator = val_vec.get(1); - if (!(generator instanceof String)) throw new SmartFrogFunctionResolutionException("sfArrayExtentGenerator-tagged attributes in Array: "+comp+" generator: "+ generator+" must be a String"); - Reference gen_ref = Reference.fromString((String)generator); - generator = comp.sfResolve(gen_ref); - - if (extent instanceof Vector) { - Vector extent_v = (Vector) extent; - for (int i=0;i<extent_v.size();i++) vec_extent.add(extent_v.get(i)); - } - idx = processExtentGenerator(idx, comp, prefix_s, generator, extent); - generator = extent = null; - } - } catch (Exception e){/*shouldn't happen*/} + //Resolve path... + if (path!=null && path instanceof Reference) { + try{dest = comp.sfResolve(((Reference)path).copyandRemoveLazy());}catch(SmartFrogResolutionException sfre){/*Shouldn't happen} + }*/ + + Object extent = orgContext.get(ConstraintConstants.EXTENT); + Object generator = orgContext.get(ConstraintConstants.GENERATOR); + + if (extent!=null){ + process_array_members(dest,prefix_s,extent,generator); + } else { + + boolean first=true; + + //Now for the extents and generators... + while (true){ + + if (key_enum.hasMoreElements()) { //even if spare_key, there must be a generator... + //if (spare_key) spare_key=false; + /*else*/ key = key_enum.nextElement(); + if (!orgContext.sfContainsTag(key, ConstraintConstants.EXTENT_TAG)) { + if (first) throw new SmartFrogFunctionResolutionException("In Array: "+comp+", extent must follow prefix..."); + else break; //from while... + } + extent = orgContext.get(key); + if (key_enum.hasMoreElements()) { + key = key_enum.nextElement(); + if (!orgContext.sfContainsTag(key, ConstraintConstants.GENERATOR_TAG)) throw new SmartFrogFunctionResolutionException("In Array: "+comp+", generator must follow extent..."); + generator = orgContext.get(key); + boolean md = process_array_members(dest,prefix_s,extent,generator); + if (md && !first) throw new SmartFrogFunctionResolutionException("In Array: "+comp+", multi-dimensional arrays can not define multiple extents..."); + first=false; + } else throw new SmartFrogFunctionResolutionException("In Array: "+comp+", generator must follow extent..."); + } else if (first) throw new SmartFrogFunctionResolutionException("Array: "+comp+" has no extent"); + else break; + } } - //Write aggregated extent - if (idx>0) orgContext.put("sfArrayExtent", new Integer(idx)); - else if (vec_extent.size()>0) orgContext.put("sfArrayExtent", vec_extent); - //Set sfFunctionClass to "done" orgContext.put("sfFunctionClassStatus", "done"); CoreSolver.getInstance().setShouldUndo(false); - - return null; + return comp; } - - int processExtentGenerator(int idx, ComponentDescription comp, String prefix_s, - Object generator, Object extent) throws SmartFrogFunctionResolutionException { - if (extent!=null){ - if (extent instanceof Integer){ - int ext_int = ((Integer)extent).intValue() + idx; - for (int i=idx; i<ext_int; i++) putArrayEntry(comp, prefix_s+i, generator, new Integer(i)); - idx=ext_int; - } else if (extent instanceof Vector){ - Vector ext_vec = (Vector)extent; - for (int i=0; i<ext_vec.size(); i++) { + + /** + * Adds individual array members + * @param dest destination for array members + * @param prefix_s prefix of array members + * @param extent size of array + * @param generator template for array members + * @return whether it is a multi-dimensional array + * @throws SmartFrogFunctionResolutionException + */ + private boolean process_array_members(Object dest, String prefix_s, Object extent, Object generator) throws SmartFrogFunctionResolutionException { + boolean md=false; + if (extent instanceof Integer){ + int ext_int = ((Integer)extent).intValue() + idx; + for (int i=idx; i<ext_int; i++) putArrayEntry(dest, prefix_s+i, generator, new Integer(i)); + idx=ext_int; + } else if (extent instanceof Vector){ + Vector ext_vec = (Vector)extent; + + //Is it a multi-dimensional array? + if (ext_vec.get(0) instanceof String){ + //no... + for (int i=0; i<ext_vec.size(); i++) { Object suff = ext_vec.get(i); if (!(suff instanceof String)) throw new SmartFrogFunctionResolutionException("Vector extent in Array: "+comp+" should be comprised of Strings"); - putArrayEntry(comp, prefix_s+suff, generator, (String) suff); + putArrayEntry(dest, prefix_s+suff, generator, (String) suff); } - } else throw new SmartFrogFunctionResolutionException("Extent in Array: "+comp+" should be an Integer or a Vector"); + } else { + md=true; + //yes... + //Compose initial index... + Vector el_idx = null; + while ((el_idx=next_el_idx(el_idx,ext_vec))!=null){ + putArrayEntry(dest, prefix_s, generator, el_idx); + } + } + } else throw new SmartFrogFunctionResolutionException("Extent in Array: "+dest+" should be an Integer or a Vector"); + return md; + } + + /** + * Gets first index of array, given extent vector + * @param ref_vec extent vector + * @return first index + * @throws SmartFrogFunctionResolutionException + */ + private Vector get_first_el_idx(Vector ref_vec) throws SmartFrogFunctionResolutionException{ + Vector el_idx = new Vector(); + for (int i=0; i<ref_vec.size(); i++){ + Object ref = ref_vec.get(i); + if (ref instanceof Integer){ + el_idx.add(new Integer(0)); + } else if (ref instanceof Vector){ + el_idx.add(((Vector)ref).get(0)); + } else throw new SmartFrogFunctionResolutionException("In Array: "+comp+" badly formed multi-dimensional extent"); } - return idx; + return el_idx; } - void putArrayEntry(ComponentDescription orgComp, String el, Object generator, Object el_idx) throws SmartFrogFunctionResolutionException{ + /** + * Gets next index of extent vector + * @param el_idx previous index + * @param ref_vec extent vector + * @return next index + * @throws SmartFrogFunctionResolutionException + */ + + private Vector next_el_idx(Vector el_idx, Vector ref_vec) throws SmartFrogFunctionResolutionException { + if (el_idx==null) return get_first_el_idx(ref_vec); - ComponentDescription generator_cd=null; + Vector next_idx = new Vector(); + boolean next=false; + + for (idx=0;idx<ref_vec.size();idx++){ + Object ref = ref_vec.get(idx); + Object el = el_idx.get(idx); + if (next){ //already found a next element, so suffix stays the same... + next_idx.add(el); + } else { + if (ref instanceof Integer){ + int ref_int = ((Integer)ref).intValue(); + int next_int = ((Integer)el_idx.get(idx)).intValue() + 1; + + if (ref_int>next_int) { + next=true; //found... + next_idx.add(new Integer(next_int)); + } else { + next_idx.add(new Integer(0)); + } + + + } else if (ref instanceof Vector){ + Vector ref_v = (Vector) ref; + int ref_size = ref_v.size(); + Object prev = el_idx.get(idx); + int next_entry = ref_v.indexOf(prev)+1; + + + if (next_entry!=ref_size){ + next=true; //found... + next_idx.add(ref_v.get(next_entry)); + } else { + next_idx.add(ref_v.get(0)); + } + + + } else throw new SmartFrogFunctionResolutionException("In Array: "+comp+" badly formed multi-dimensional extent"); + } + } + if (next) return next_idx; + else return null; + } + + /** + * Puts a member entry into array + * @param dest destination of member put + * @param el prefix of name of member attribute to put + * @param generator member template to put + * @param el_idx index of member in array + */ + private void putArrayEntry(Object dest, String el, Object generator, Object el_idx) { + ComponentDescription generator_cd=null; Object generator_copy=null; + if (generator instanceof ComponentDescription) { generator_copy = generator_cd = (ComponentDescription) ((ComponentDescription) generator).copy(); } else if (generator instanceof SFApplyReference) { generator_copy = ((SFApplyReference) generator).copy(); generator_cd = ((SFApplyReference)generator_copy).getComponentDescription(); - } + } - generator_cd.sfContext().put("sfArrayIndex", el_idx); - generator_cd.sfContext().put("sfArrayTag", el); - generator_cd.sfContext().remove("sfIsGenerator"); - orgComp.sfContext().put(el, generator_copy); + + if (el_idx instanceof Vector) { //Multi-dimensional... + Vector el_vec = (Vector) el_idx; + for (int i=0; i<el_vec.size(); i++) { + Object suff = el_vec.get(i); + el+="_"+suff; + generator_cd.sfContext().put(ConstraintConstants.INDEX+i, suff); + } + } else generator_cd.sfContext().put(ConstraintConstants.INDEX, el_idx); + + generator_cd.sfContext().put(ConstraintConstants.TAG, el); + generator_cd.sfContext().remove("sfIsArrayGenerator"); + + if (dest instanceof ComponentDescription){ + generator_cd.setParent((ComponentDescription) dest); + try{((ComponentDescription) dest).sfAddAttribute(el, generator_copy);} catch (Exception e){/*Shouldn't happen*/} + } /*COMMENTED OUT FOR NOW AS FOR TIME BEING ARRAYS ARE STRICTLY PARSE TIME CREATURES + else /*Assume Prim* { + generator_cd.setPrimParent((Prim) dest); + try {((Prim)dest).sfAddAttribute(el, generator_copy);} catch (Exception e){/*Shouldn't happen*} + } */ } - + } Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/BaseFunction.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/BaseFunction.java 2009-01-20 16:46:51 UTC (rev 7276) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/BaseFunction.java 2009-01-21 15:37:35 UTC (rev 7277) @@ -20,13 +20,14 @@ package org.smartfrog.sfcore.languages.sf.functions; +import org.smartfrog.sfcore.common.Context; +import org.smartfrog.sfcore.common.SmartFrogFunctionResolutionException; +import org.smartfrog.sfcore.componentdescription.ComponentDescription; +import org.smartfrog.sfcore.languages.sf.sfreference.SFApplyReference; import org.smartfrog.sfcore.reference.Function; +import org.smartfrog.sfcore.reference.Reference; import org.smartfrog.sfcore.reference.ReferenceResolver; import org.smartfrog.sfcore.reference.RemoteReferenceResolver; -import org.smartfrog.sfcore.reference.Reference; -import org.smartfrog.sfcore.common.SmartFrogFunctionResolutionException; -import org.smartfrog.sfcore.common.Context; -import org.smartfrog.sfcore.componentdescription.ComponentDescription; /** * Defines the base function for all the functions. @@ -43,9 +44,32 @@ protected Context context = null; protected ReferenceResolver rr = null; protected RemoteReferenceResolver rrr = null; - + protected ComponentDescription comp; + protected Context orgContext; protected Reference name = null; - + protected Reference ar= null; + protected Object arkey = null; + + private void extras(Reference ar, Object key){ + this.ar = ar; + this.arkey = key; + } + + private Object doit(Context ctx, Reference unused) throws SmartFrogFunctionResolutionException { + this.context = ctx; + if (this.context!=null) this.comp = context.getOriginatingDescr(); + if (this.comp!=null) this.orgContext = comp.sfContext(); + + Object result = doFunction(); + + if (result instanceof ComponentDescription) { + ((ComponentDescription)result).setParent(null); + ((ComponentDescription)result).setPrimParent(null); + } + return result; + } + + /** * base implementation of a function method. * Calls the (abstract) method doFunction. @@ -55,35 +79,48 @@ * @throws SmartFrogFunctionResolutionException if the doFunction method does. */ public Object doit(Context ctx, Reference unused, ReferenceResolver resolver) throws SmartFrogFunctionResolutionException { - this.context = ctx; this.rr = resolver; - - Object result = doFunction(); - if (result instanceof ComponentDescription) { - ((ComponentDescription)result).setParent(null); - ((ComponentDescription)result).setPrimParent(null); - } - - return result; + return doit(ctx, unused); } - + /** * base implementation of a function method. * Calls the (abstract) method doFunction. * Note that it makes sure that the result has no parent if it is a component description - this will * cause it to be patched into whereever it is returned. + * + * @throws SmartFrogFunctionResolutionException if the doFunction method does. + */ + public Object doit(Context ctx, Reference unused, ReferenceResolver resolver, Reference ar, Object key) throws SmartFrogFunctionResolutionException { + extras(ar,key); + return doit(ctx, unused, resolver); + } + + /** + * base implementation of a function method. + * Calls the (abstract) method doFunction. + * Note that it makes sure that the result has no parent if it is a component description - this will + * cause it to be patched into whereever it is returned. * * @throws SmartFrogFunctionResolutionException if the doFunction method does. */ public Object doit(Context ctx, Reference unused, RemoteReferenceResolver resolver) throws SmartFrogFunctionResolutionException { - this.context = ctx; - this.rrr = resolver; + this.rrr = resolver; + return doit(ctx, unused); + } + + /** + * base implementation of a function method. + * Calls the (abstract) method doFunction. + * Note that it makes sure that the result has no parent if it is a component description - this will + * cause it to be patched into whereever it is returned. + * + * @throws SmartFrogFunctionResolutionException if the doFunction method does. + */ + public Object doit(Context ctx, Reference unused, RemoteReferenceResolver resolver, Reference ar, Object key) throws SmartFrogFunctionResolutionException { + extras(ar,key); + return doit(ctx, unused, resolver); + } - Object result = doFunction(); - if (result instanceof ComponentDescription) { - ((ComponentDescription)result).setParent(null); - ((ComponentDescription)result).setPrimParent(null); - } - return result; - } + } Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/Constraint.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/Constraint.java 2009-01-20 16:46:51 UTC (rev 7276) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/functions/Constraint.java 2009-01-21 15:37:35 UTC (rev 7277) @@ -22,23 +22,115 @@ import java.util.Collections; import java.util.Enumeration; +import java.util.HashMap; import java.util.Iterator; import java.util.Vector; import org.smartfrog.sfcore.common.Context; import org.smartfrog.sfcore.common.MessageKeys; +import org.smartfrog.sfcore.common.SFNull; +import org.smartfrog.sfcore.common.SmartFrogCompilationException; +import org.smartfrog.sfcore.common.SmartFrogContextException; +import org.smartfrog.sfcore.common.SmartFrogException; import org.smartfrog.sfcore.common.SmartFrogFunctionResolutionException; import org.smartfrog.sfcore.common.SmartFrogResolutionException; import org.smartfrog.sfcore.componentdescription.ComponentDescription; +import org.smartfrog.sfcore.languages.sf.constraints.ConstraintConstants; import org.smartfrog.sfcore.languages.sf.constraints.CoreSolver; import org.smartfrog.sfcore.languages.sf.constraints.FreeVar; +import org.smartfrog.sfcore.languages.sf.constraints.ConstraintResolutionState.ConstraintContext; +import org.smartfrog.sfcore.languages.sf.constraints.propositions.Proposition; +import org.smartfrog.sfcore.languages.sf.sfreference.SFReference; +import org.smartfrog.sfcore.prim.Prim; +import org.smartfrog.sfcore.reference.HereReferencePart; import org.smartfrog.sfcore.reference.Reference; +import org.smartfrog.sfcore.reference.ReferencePart; /** * Defines the Constraint function. */ public class Constraint extends BaseFunction implements MessageKeys { + + static class Argument { + Object loc; + Object arg; + Argument(Object loc, Object arg){ + this.loc=loc; this.arg=arg; + } + } + + static class Arguments { + HashMap<String, Object> args = new HashMap<String, Object>(); + Vector<Argument> argsa = new Vector<Argument>(); + Vector<Object> argsv = new Vector<Object>(); + void put(Object loc, Object arg){ + args.put(loc.toString(), arg); + argsa.add(new Argument(loc, arg)); + argsv.add(arg); + } + + Object get(Object loc){ + return args.get(loc.toString()); + } + + public String toString(){ + String ret="["; + for (int i=0;i<argsv.size();i++){ + if (i>0) ret+=", "; + ret+= argsv.get(i).toString(); + } + return ret+"]"; + } + + public String toFullString(){ + return toFullVector().toString(); + } + + public Vector toFullVector(){ + Vector args= new Vector(); + for (int i=0;i<argsv.size();i++){ + Vector arg = new Vector(); + args.add(arg); + arg.add(argsa.get(i).loc); + arg.add(argsa.get(i).arg); + } + return args; + } + + Vector getArgs(){ + return argsv; + } + } + + static public class CompositeSource { + HashMap context; + Object source; + Reference path; + Object update; + String prefix; + Reference pred; + Object key; + Object retval; + Arguments arguments=new Arguments(); + boolean freevars=false; + int idx=-1; + + CompositeSource(HashMap context, Object source, String prefix, Reference path, Reference pred, Object key, Object update){ + this.context=context; + this.source=source; + this.prefix=prefix; + this.update=update; + this.key=key; + this.path=path; + this.pred=pred; + } + + public String toString(){ + return ""+context+":"+source+":"+prefix+":"+path+":"+pred+":"+key+":"+update+":"+arguments+":"+freevars+":"+idx; + } + } + /** * The method to implement the functionality of the if-then-else function. * @@ -47,8 +139,7 @@ * */ protected Object doFunction() throws SmartFrogFunctionResolutionException { //If constraint resolution is not pertinent or possible return - if (!CoreSolver.getInstance().getConstraintsPossible()) return null; - + /** * Records the attributes used for consraint goal preds */ @@ -73,82 +164,63 @@ * Automatic variables... */ Vector autos = new Vector(); - + /** - * The description pertaining to the Constraint - */ - ComponentDescription comp = context.getOriginatingDescr(); - - /** - * The context pertaining to the Constraint - */ - Context orgContext = comp.sfContext(); - - /** * User variables present? */ boolean isuservars=false; + HashMap<FreeVar, Object> assigns = new HashMap<FreeVar, Object>(); + + //System.out.println("In constraint..."); + + if (!CoreSolver.getInstance().getConstraintsPossible()) return comp; + CoreSolver.getInstance().setShouldUndo(true); - Enumeration attr_enum = orgContext.keys(); + + Vector<CompositeSource> aggs=new Vector<CompositeSource>(); + getCompositeSources(comp, aggs, null, true); - while (attr_enum.hasMoreElements()){ - Object attr = attr_enum.nextElement(); + for (int i=0;i<aggs.size();i++){ + CompositeSource cs = aggs.get(i); + + //System.out.println("%%%%%%%%%%%%%%%%%%%%%%"+cs+orgContext.get(cs.key)); + + extractArgumentsFromSource(cs); + + //System.out.println("+++++++++++++++++++++"+cs.key+":"+cs.arguments); + + //Unify arguments... + Object value = orgContext.get(cs.key); + unify(cs.arguments, value, assigns); + String csargs = cs.arguments.toString(); + //System.out.println("CSARGS!!!"+cs.key+":"+csargs); + orgContext.put(cs.key, cs.arguments.getArgs()); + + try { + if (cs.freevars) orgContext.sfAddTag(cs.key, "sfFreeVars"); + } catch (SmartFrogContextException context){/*Shouldn't happen*/} + } + + //System.out.println("111"); - try { - if (orgContext.sfContainsTag(attr, "sfAggregatedConstraintSource")){ - - Object val = orgContext.get(attr); - if (!(val instanceof Vector)) throw new SmartFrogFunctionResolutionException("sfAggregatedConstraintSource-tagged attributes in AggregatedConstraint: "+comp+" must have Vector values."); - Vector val_vec = (Vector) val; - if (val_vec.size()!=3) throw new SmartFrogFunctionResolutionException("sfAggregatedConstraintSource-tagged attributes in AggregatedConstraint: "+comp+" must have Vector values with 2 members."); - Object arraysource = val_vec.get(0); - - if (arraysource==null || !(arraysource instanceof String)) throw new SmartFrogFunctionResolutionException("First argument of an sfAggregatedConstraintSource tagged attribute in: "+comp+" should be a STRING which resolves to a Component Description"); - Object _arraysource = comp.sfResolve(Reference.fromString((String)arraysource)); - if (_arraysource==null || !(_arraysource instanceof ComponentDescription)) throw new SmartFrogFunctionResolutionException("First argument of an sfAggregatedConstraintSource tagged attribute in: "+comp+" should be a String which resolves to a COMPONENT DESCRIPTION"); - - - ComponentDescription source_cd = (ComponentDescription) _arraysource; - - Object sourceClass = source_cd.sfContext().get("sfFunctionClass"); - if (!sourceClass.equals("org.smartfrog.sfcore.languages.sf.functions.Array")) throw new SmartFrogFunctionResolutionException("First argument of an sfAggregatedConstraintSource tagged attribute in: "+comp+" must have orginated as an Array type"); - - Object attrpath = val_vec.get(1); - if (attrpath==null || !(attrpath instanceof String)) throw new SmartFrogFunctionResolutionException("Second argument of an sfAggregatedConstraintSource tagged attribute in: "+comp+" should be a STRING"); - String path_s = ":"+attrpath; - - Object newattr = val_vec.get(2); - if (newattr==null || !(newattr instanceof String)) throw new SmartFrogFunctionResolutionException("Third argument of an sfAggregatedConstraintSource tagged attribute in: "+comp+" should be a STRING"); - String newattr_s = (String)newattr; - - Vector ac_values = new Vector(); - - boolean freevars = Aggregator.extractArgumentsFromSource(comp, source_cd, path_s, ac_values); - - comp.sfContext().put(newattr_s, ac_values); - if (freevars) comp.sfContext().sfAddTag(newattr_s, "sfAggregatedConstraintFreeVars"); - - } - } catch (Exception e){/*shouldn't happen, so will ignore*/} - - } - CoreSolver.getInstance().setShouldUndo(false); + + Object ret_key=null; //Process attributes, either constraint goals or other... - attr_enum = orgContext.keys(); + Enumeration attr_enum = orgContext.keys(); while (attr_enum.hasMoreElements()){ Object key = attr_enum.nextElement(); Object val = orgContext.get(key); try { + + if (orgContext.sfContainsTag(key, "sfReturn")) ret_key=key; + if (orgContext.sfContainsTag(key, "sfConstraint")) goal_attrs.add(key); else { - if (val instanceof String && !isLegal((String)val)) continue; - - attrs.add(key); - values.add(val); + if (val instanceof String && !isLegal((String)val)) continue; //Set the attribute name originating this FreeVar if (val instanceof FreeVar) { @@ -156,15 +228,107 @@ if (fv.getConsEvalKey()==null) fv.setConsEvalKey(key); //Make sure range is appropriated in free var - fv.setRange(comp); + fv.constructRange(comp); - } - if (orgContext.sfContainsTag(key, "sfConstraintAutoVar")) autos.add(key); - else if (!isuservars && orgContext.sfContainsTag(key, "sfConstraintUserVar")) isuservars=true; + if (orgContext.sfContainsTag(key, "sfConstraintAutoVar")) autos.add(key); + else if (orgContext.sfContainsTag(key, "sfConstraintUserVar")) isuservars=true; + + } else if (val instanceof ComponentDescription){ + + ComponentDescription cd = (ComponentDescription) val; + + if (cd.sfContext().get("IsConstraintVar")!=null){ + + FreeVar fv = new FreeVar(); + + //System.out.println("cd:"+cd); + + //range + Object range = null; + if ((range=cd.sfContext().get(ConstraintConstants.RANGE))!=null) fv.setRange(range); + else if ((range=cd.sfContext().get(ConstraintConstants.RANGEREF))!=null) fv.setRangeRef(range); + else if (cd.sfContext().get(ConstraintConstants.IRANGE)!=null) fv.setRange(new Integer(0)); + else if (cd.sfContext().get(ConstraintConstants.BRANGE)!=null) fv.setRange(new Boolean(true)); + + //System.out.println("22222"); + + //qualification + Object qual_val=null; + if ((qual_val=cd.sfContext().get(ConstraintConstants.AUTOVAR))!=null){ + //System.out.println("Yes we have an autovar!"); + if (qual_val instanceof SFNull) { + //System.out.println("Yes we are null..."); + autos.add(key); + } else if (qual_val instanceof SFReference){ + Reference auto_ref=null; + try { + auto_ref=((SFReference) qual_val).sfAsReference(); + } catch (SmartFrogCompilationException sfce){ throw new SmartFrogFunctionResolutionException(sfce);} + Object label = cd.sfResolve(auto_ref); + //System.out.println("label:"+(label==null)); + + ComponentDescription label_cd = null; + try { + label_cd = (ComponentDescription) label; + } catch (ClassCastException cce){ + throw new SmartFrogFunctionResolutionException("Reference for autovar does not resolve to a Labelling CD, ref:"+qual_val+" in var dec: "+cd+", in constraint: "+comp); + } + + Object label_key = label_cd.sfParent().sfAttributeKeyFor(label); + CoreSolver.getInstance().addAutoVar(label_key, fv); + } + } else if ((qual_val=cd.sfContext().get(ConstraintConstants.DEFVAR))!=null){ + fv.setDefVal(qual_val); + } else if (cd.sfContext().get(ConstraintConstants.USERVAR)!=null){ + isuservars=true; + orgContext.sfAddTag(key, "sfConstraintUserVar"); + } + + + //System.out.println("AUTOEFFECTCDPARENT"+cd); + + //effects + ComponentDescription autoEffectsCD=null; + try {autoEffectsCD = (ComponentDescription) cd.sfContext().get(ConstraintConstants.AUTOEFFECTS); } + catch (ClassCastException cce){/**do**/} + + if (autoEffectsCD!=null){ + //System.out.println("AUTOEFFECTCD"+autoEffectsCD); + + Enumeration ae_enum = autoEffectsCD.sfContext().keys(); + + Vector<Reference> autoEffects = new Vector<Reference>(); + while (ae_enum.hasMoreElements()){ + try { autoEffects.add(((SFReference) autoEffectsCD.sfContext().get(ae_enum.nextElement())).sfAsReference()); } + catch (ClassCastException cce){ throw new SmartFrogFunctionResolutionException("Policy for autovar is not Reference in var dec: "+cd+", in constraint: "+comp); } + } + fv.setAutoEffectCD(autoEffectsCD); + fv.setAutoEffects(autoEffects); + } + + fv.constructRange(cd); + fv.setConsEvalKey(key); + + + val=fv; //so that freevar gets added instead... + //Insert this new FreeVar... + orgContext.put(key, fv); + + + //System.out.println("In In In4"+key+":"+val+":"+orgContext); + + } + } + + attrs.add(key); + values.add(val); + //System.out.println("Just Added"+key+":"+val); } - } catch (Exception e){/**Shouldn't happen**/} + } catch (Exception e){/**Shouldn't happen*/} } - + + //System.out.println("222"); + //Sort the goal in lex order Collections.sort(goal_attrs); @@ -175,100 +339,661 @@ } //Add empty goal if no goal... - if (goal_attrs.size()==0) goal.add("true"); + if (goal_attrs.size()==0) goal.add("nil"); + //Construct constraint context... + ConstraintContext cc = new ConstraintContext((ComponentDescription)rr, comp, arkey, ar, ret_key); + + //System.out.println("333"); + //Solve goal try { - CoreSolver.getInstance().solve(comp, attrs, values, goal, autos, isuservars); + CoreSolver.getInstance().solve(cc, attrs, values, goal, autos, isuservars, assigns); } catch (Exception e){ e.printStackTrace(); - throw new SmartFrogFunctionResolutionException("Error in solving constraints in: "+context); + ////System.out.println("WE ARE IN ERROR!!!"); + throw new Error("Error in solving constraints:"+e+" in: "+orgContext); } + //VAR effects... + try { + //System.out.println("Applying freevar effects..."+cc.getFVs()); + + Vector<FreeVar> fvs = cc.getFVs(); + for (FreeVar fv: fvs){ + fv.applyAutoEffects(); + } + } catch (SmartFrogResolutionException sfre){ throw new SmartFrogFunctionResolutionException(sfre);} - //Have we done backtracking, need to throw! - Context backtracked = CoreSolver.getInstance().hasBacktrackedTo(); - if (backtracked!=null) orgContext = backtracked; - + ConstraintContext cc_new = CoreSolver.getInstance().hasBacktrackedTo(); + if (cc_new!=null) { + cc=cc_new; + assignContext(cc); + } + boolean hasBacktracked = (cc_new!=null); + //System.out.println("�1"); + + ////System.out.println("HAS BACKTRACKED!!!"+hasBacktracked); + //Mark (poss. backtracked) constraint as done... CoreSolver.getInstance().setShouldUndo(true); + + //File preliminary results... + //fileAggregates(comp); + + //Do propositions + //Speculatively, write the constraint in to its future home, to assess propositions... + ////System.out.println("KEYKEY:"+arkey+":"+comp+":"+orgContext); + + //System.out.println("�2"); + + + if (!Proposition.getResult()) { + ////System.out.println("WE ARE EVALLING PRPS!"); + if (arkey!=null) ((ComponentDescription)rr).sfContext().put(arkey, comp); //this will be undone if backtracking occurs... + + + boolean backtracked=Proposition.evaluatePropositions(false); //to backtrack? rename + ////System.out.println("Post backtracking"+backtracked); + while (backtracked){ + ////System.out.println("Failing..."); + try {CoreSolver.getInstance().fail();} catch (Exception e){/***/} + ////System.out.println("Reevaling props..."); + + cc_new = CoreSolver.getInstance().hasBacktrackedTo(); + if (cc_new!=null) { + cc=cc_new; + assignContext(cc); + } + hasBacktracked = (cc_new!=null); + + //fileAggregates(comp); + if (arkey!=null) ((ComponentDescription)rr).sfContext().put(arkey, comp); + backtracked=Proposition.evaluatePropositions(true); + } + + //Write back apply reference for now... + ////System.out.println("Writing back..."); + if (arkey!=null) ((ComponentDescription)rr).sfContext().put(arkey, ar); + } + + //We're done... orgContext.put("sfFunctionClassStatus", "done"); + + //System.out.println("�3"); + + CoreSolver.getInstance().setShouldUndo(false); + + //System.out.println("�4"); - //Finally, am I an aggregated constraint? If so, map values back... - CoreSolver.getInstance().setShouldUndo(true); + if (hasBacktracked) { + CoreSolver.getInstance().resetDoneBacktracking(); + throw new SmartFrogConstraintBacktrackError(); + } + + ret_key=cc.getRetKey(); + + //System.out.println("�5"+ret_key); + + + + Object ret_val = (ret_key!=null?orgContext.get(ret_key):comp); + //System.out.println("RETURNING!!!"+ret_val); + + return ret_val; + } - attr_enum = orgContext.keys(); + void unify(Arguments arguments, Object val, HashMap<FreeVar, Object> assigns) throws SmartFrogFunctionResolutionException { + //System.out.println("Pre-specified value:"+val); + + String error_s = "aggregated value attribute has illegal pre-specfied value:"+val; + if (val instanceof SFNull) return; //Nothing to do... + if (!(val instanceof Vector)) throw new SmartFrogFunctionResolutionException(error_s+", not a Vector!"); + + Vector val_vec = (Vector) val; + for (int i=0; i<val_vec.size();i++){ + Object vitem = val_vec.get(i); + ////System.out.println("VITEM!!!"+vitem); + + if (!(vitem instanceof Vector)) { + ////System.out.println("Thrown VITEM!!!"+vitem); + throw new SmartFrogFunctionResolutionException(error_s+", should be a vector of [loc,value] pairs"); //items should be a vec of [loc, value], we ignore val... + } + Vector vitem_vec = (Vector) vitem; + + if (vitem_vec.size()!=2) { + ////System.out.println("Thrown VITEM!!!"+vitem); + throw new SmartFrogFunctionResolutionException(error_s+", should be a vector of [loc,value] pairs"); //wrong size, so ignore val... + } + + Object loc = vitem_vec.get(0); + Object vvalue = vitem_vec.get(1); + Object avalue = arguments.get(loc); + + if (avalue instanceof FreeVar){ + //if (vvalue instanceof SFNull) vvalue=new FreeVar(); + ////System.out.println("Location:"+loc+":"+avalue.toString()+":"+vvalue.toString()); + assigns.put((FreeVar)avalue, vvalue); + } else if (!avalue.equals(vvalue)) throw new SmartFrogFunctionResolutionException(error_s+", ununifiable values"); + } + } + + + //The next two methods are not currently used, but may be at some point and are left in as such... + void unify_(Vector arguments, Object val, Vector goal){ + + if (!(val instanceof Vector)) return; //Not unifiable on type + + String goal_s=unify_vec(arguments, (Vector)val); + + if (goal_s!=null) goal.add(goal_s); + } + + String unify_vec(Vector arguments, Vector val_vec){ + String goal_s=null; + if (val_vec.size()!=arguments.size()) return null; //Not unifiable on size + + for (int i=0; i<val_vec.size();i++){ + Object vitem = val_vec.get(i); + Object aitem = arguments.get(i); + if (vitem instanceof Vector && aitem instanceof Vector) { + String goal_s1 = unify_vec((Vector) aitem, (Vector) vitem); + if (goal_s1==null) return null; + if (goal_s!=null) goal_s += ", "+goal_s1; + else goal_s=goal_s1; + } else if (aitem instanceof FreeVar) { + String goal_s1 = aitem.toString()+"="+vitem.toString(); + if (goal_s!=null) goal_s += ", "+goal_s1; + else goal_s=goal_s1; + } else if (!(aitem.equals(vitem))) return null; + } + if (goal_s!=null) return goal_s; + else return ""; + } + + void assignContext(ConstraintContext cc){ + if (cc!=null){ + ar=cc.getAR(); + comp=cc.getCD(); + rr=cc.getParent(); + arkey=cc.getKey(); + orgContext=comp.sfContext(); + } + } + + void fileAggregates(ComponentDescription comp) throws SmartFrogFunctionResolutionException { + Vector<CompositeSource> aggs=new Vector<CompositeSource>(); + getCompositeSources(comp, aggs, null, true); - while (attr_enum.hasMoreElements()){ - Object attr = attr_enum.nextElement(); + for (int i=0;i<aggs.size();i++){ + CompositeSource cs = aggs.get(i); + try { + if (orgContext.sfContainsTag(cs.key, "sfFreeVars")){ + ////System.out.println("UPDATE UPDATE:"+cs.key+":"+cs.update); + if (cs.prefix==null) updateValue(cs); + else updateArrayOfValues(cs); + } + } catch (SmartFrogContextException context){/*Shouldn't happen*/} + } + } + + public static void getCompositeSources(ComponentDescription comp, Vector<CompositeSource> cs, java.util.Vector<Object> other, boolean mpred) throws SmartFrogFunctionResolutionException{ + Context context = comp.sfContext(); + Enumeration en = context.keys(); + Object key=null; + + ////System.out.println("Comp"+comp); + + while ((key=getNextKey(en,comp))!=null){ + //Context information firstly... + HashMap contextInfo_hm = new HashMap(); + Object contextInfo = getTaggedValue("sfContext", key, comp); + while (contextInfo!=null){ + contextInfo_hm.put(key, contextInfo); + contextInfo = getTaggedValue("sfContext", getNextKey(en,comp), comp); + } - try { - - if (orgContext.sfContainsTag(attr, "sfAggregatedConstraintSource")){ - Vector val = (Vector) orgContext.get(attr); - Object arraysource = val.get(0); - ComponentDescription source_cd = (ComponentDescription) comp.sfResolve(Reference.fromString((String)arraysource)); - String path_s = (String) val.get(1); - Object newattr = val.get(2); + Object source = getTaggedValue("sfSource", getNextKey(en,comp), comp, false); + + //System.out.println("Source"+source); + + if (source==null) { + /*Object val = getTaggedValue("sfReturn", key, comp); + if (val!=null){ + //sort ret val! + g_retval=val; + } else*/ if (other!=null) other.add(key); + leftover=null; + continue; //round while... + } + + //"Hand" resolve + if (!(source instanceof Reference)) throw new SmartFrogFunctionResolutionException("Tagged source: "+source+" in comp: "+comp+" should be a reference"); + Reference source_ref=null; + if (source instanceof SFReference) { + try {source_ref=((SFReference)source).sfAsReference();} + catch (SmartFrogCompilationException sfce){throw new SmartFrogFunctionResolutionException(sfce);} + } + else source_ref= (Reference) source; + + //System.out.println("SourceRef"+source_ref); + + Object prefix = getTaggedValue("sfPrefix", getNextKey(en,comp), comp); + Object path = getTaggedValue("sfPath", getNextKey(en,comp), comp, false); + + if (prefix!=null || path!=null) { + try { source = resolve(comp, source_ref); } catch (Exception e) {throw new SmartFrogFunctionResolutionException("Can not resolve source ref:"+source_ref+" in: "+comp);} + if (!(source instanceof ComponentDescription) && !(source instanceof Prim)) throw new SmartFrogFunctionResolutionException("Source ref:"+source_ref+" in: "+comp+" does not resolve to a Prim/ComponentDescription"); + } else { + path=source; + source=comp; + } + + Object pred = null; + Object update = null; + + //System.out.println("PREFIX:PATH"+prefix+path); + + if (path!=null && (!(path instanceof Reference))) throw new SmartFrogFunctionResolutionException("Tagged path in comp: "+comp+" must be a Reference"); + + boolean first=true; + + if (mpred){ + while (true){ + pred = getTaggedValue("sfPred", getNextKey(en,comp), comp, false); + update = getTaggedValue("sfUpdate", getNextKey(en,comp), comp); - //Manipulate path to get inter_path - int idx = path_s.lastIndexOf(":"); - String interpath_s = ""; - if (idx!=-1){ - interpath_s = ":"+path_s.substring(0, idx); - path_s = path_s.substring(idx+1); - } + //System.out.println("PRED:UPDATE"+pred+update); - if (orgContext.sfContainsTag(newattr, "sfAggregatedConstraintFreeVars")){ + if (pred!=null && !(pred instanceof Reference)){ + if ((pred instanceof Boolean && ((Boolean)pred).booleanValue()) || pred instanceof SFNull) pred=null; + else throw new SmartFrogFunctionResolutionException("Tagged pred: "+pred+" in comp: "+comp+" is not Reference or Boolean true"); + } - Vector ac_values = (Vector) orgContext.get(newattr); - - //Extent - Object extent = source_cd.sfContext().get("sfArrayExtent"); - - //Prefix - String prefix_s = (String) source_cd.sfContext().get("sfArrayPrefix"); - - if (extent instanceof Integer){ - int ext_int = ((Integer)extent).intValue(); - for (int i=0; i<ext_int; i++){ - String el = prefix_s+i; - Object ac_val = ac_values.get(i); - if (!(ac_val instanceof FreeVar)) replace(source_cd, el+interpath_s, path_s, ac_val); - } - } else if (extent instanceof Vector){ - Vector ext_vec = (Vector)extent; - for (int i=0; i<ext_vec.size(); i++){ - String suff_s = (String) ext_vec.get(i); - String el=prefix_s+suff_s; - Object ac_val = ac_values.get(i); - if (!(ac_val instanceof FreeVar)) replace(source_cd, el+interpath_s, path_s, ac_val); - } - } - } + if (pred!=null && update==null) throw new SmartFrogFunctionResolutionException("Tagged source in comp: "+comp+" with no update"); + + if (pred==null && update==null){ + if (first) { + //System.out.println("1Adding"); + CompositeSource comp_src = new CompositeSource(contextInfo_hm, source, (String)prefix, (Reference)path, null, null, null); + cs.add(comp_src); + } + break; + } + + first=false; + + //System.out.println("2Adding"); + CompositeSource comp_src = new CompositeSource(contextInfo_hm, source, (String)prefix, (Reference)path, (Reference)pred, lastKey, update); + cs.add(comp_src); + } + } else { + //System.out.println("nextup..."); + + pred = getTaggedValue("sfPred", getNextKey(en,comp), comp, false); + update = getTaggedValue("sfUpdate", getNextKey(en,comp), comp); + + //System.out.println("PRED:UPDATE"+pred+update); + + if (pred!=null && !(pred instanceof Reference)){ + if ((pred instanceof Boolean && ((Boolean)pred).booleanValue()) || pred instanceof SFNull) pred=null; + else throw new SmartFrogFunctionResolutionException("Tagged pred: "+pred+" in comp: "+comp+" is not Reference or Boolean true"); + } + + if (update==null) throw new SmartFrogFunctionResolutionException("Tagged source in comp: "+comp+" with no update"); + CompositeSource comp_src = new CompositeSource(contextInfo_hm, source, (String)prefix, (Reference)path, (Reference)pred, lastKey, update); + cs.add(comp_src); + } + } + + //System.out.println("Leaving getCS"); + + } + + static private abstract class AggregationOp { + CompositeSource cs; + AggregationOp(CompositeSource cs){ + this.cs=cs; + } + abstract void doIt(Object loc) throws SmartFrogFunctionResolutionException; + } + + static private class ExtractOp extends AggregationOp{ + ExtractOp(CompositeSource cs){ super(cs); } + void doIt(Object loc) throws SmartFrogFunctionResolutionException { + ComponentResolution cr = getComponentResolution(cs.source,cs.path); + cs.arguments.put(loc, cr.val); + if (cr.val instanceof FreeVar) cs.freevars=true; + } + } + + static private class UpdateOp extends AggregationOp{ + UpdateOp(CompositeSource cs){ super(cs); cs.idx=0;} + void doIt(Object loc) throws SmartFrogFunctionResolutionException{ + updateValue(cs); + cs.idx++; + } + } + + static void doAggregationUpdate(AggregationOp ao) throws SmartFrogFunctionResolutionException { + CompositeSource cs = ao.cs; + Object cssource = cs.source; + Prim p = (cssource instanceof Prim?(Prim)cssource:null); + ComponentDescription c = (cssource instanceof ComponentDescription?(ComponentDescription)cssource:null); + + ... [truncated message content] |
From: <st...@us...> - 2009-01-23 23:22:14
|
Revision: 7310 http://smartfrog.svn.sourceforge.net/smartfrog/?rev=7310&view=rev Author: steve_l Date: 2009-01-23 22:05:48 +0000 (Fri, 23 Jan 2009) Log Message: ----------- SFOS-1079 -better handling/detection of localhost connectivity problems. It is very hard-coded to Sun JDKs (string searching), but appears to be the same for OpenJDK6 and JDK6. Modified Paths: -------------- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/ActionPing.java trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/DefaultRootLocatorImpl.java Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/common/ActionPing.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/ActionPing.java 2009-01-23 21:54:10 UTC (rev 7309) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/common/ActionPing.java 2009-01-23 22:05:48 UTC (rev 7310) @@ -87,13 +87,13 @@ RemoteException { Prim targetC; + long start,finish; + start=System.currentTimeMillis(); if (name == null) { targetC = targetP; } else { targetC = (Prim) targetP.sfResolveWithParser(name); } - long start,finish; - start=System.currentTimeMillis(); targetC.sfPing(this); finish = System.currentTimeMillis(); return finish-start; Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/DefaultRootLocatorImpl.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/DefaultRootLocatorImpl.java 2009-01-23 21:54:10 UTC (rev 7309) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/DefaultRootLocatorImpl.java 2009-01-23 22:05:48 UTC (rev 7310) @@ -33,6 +33,7 @@ import org.smartfrog.sfcore.common.SmartFrogResolutionException; import org.smartfrog.sfcore.common.SFNull; import org.smartfrog.sfcore.security.SFSecurity; +import org.smartfrog.SFSystem; /** * Defines a default root locator for SmartFrog Processes. The root locator @@ -365,6 +366,13 @@ if ((localCompound != null)&&(pc.equals(localCompound))) { return localCompound; } + String internalState = pc.toString(); + if (internalState.contains("liveRef: [endpoint:[127.0.0.1:") + && !hostAddress.isLoopbackAddress()) { + SFSystem.sfLog().warn("Remote Process Compound for " + hostAddress + + " appears to think its IP address is \"127.0.0.1\""); + SFSystem.sfLog().warn("Communications with components are likely to fail with Connection refused exceptions"); + } return pc; } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2010-10-13 16:20:05
|
Revision: 8417 http://smartfrog.svn.sourceforge.net/smartfrog/?rev=8417&view=rev Author: steve_l Date: 2010-10-13 16:19:58 +0000 (Wed, 13 Oct 2010) Log Message: ----------- improve javadocs (spelling and content) and reformat some badly formatted code that snuck in. Modified Paths: -------------- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/Context.java trunk/core/smartfrog/src/org/smartfrog/sfcore/common/ContextImpl.java trunk/core/smartfrog/src/org/smartfrog/sfcore/componentdescription/ComponentDescription.java trunk/core/smartfrog/src/org/smartfrog/sfcore/componentdescription/ComponentDescriptionImpl.java Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/common/Context.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/Context.java 2010-10-13 16:18:37 UTC (rev 8416) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/common/Context.java 2010-10-13 16:19:58 UTC (rev 8417) @@ -240,7 +240,7 @@ * * @param name name of attribute to be removed * - * @return the removed value if successfull, null otherwise + * @return the removed value if successful, null otherwise * * @throws SmartFrogContextException when name is null */ Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/common/ContextImpl.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/ContextImpl.java 2010-10-13 16:18:37 UTC (rev 8416) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/common/ContextImpl.java 2010-10-13 16:19:58 UTC (rev 8417) @@ -232,7 +232,7 @@ * * @param name of attribute to be removed * - * @return removed attribute value if successfull or null if not + * @return removed attribute value if successful or null if not * * @throws SmartFrogContextException when name is null */ @@ -722,20 +722,21 @@ } /** - * Removes an entry from the hashtable. + * Removes an entry from the hashtable, the attribute tags and wrappers, and any core solver. * Overwrites OrderedHashtable.remove(). * * @param key key to remove * - * @return removed object + * @return removed object or null if there was no such entry. */ public Object remove(Object key) { Object r = super.remove(key); attributeTags.remove(key); attributeTagsWrappers.remove(key); - - if (r!=null) CoreSolver.getInstance().addUndoPut(this, key, r); - return r; + if (r != null) { + CoreSolver.getInstance().addUndoPut(this, key, r); + } + return r; } Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/componentdescription/ComponentDescription.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/componentdescription/ComponentDescription.java 2010-10-13 16:18:37 UTC (rev 8416) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/componentdescription/ComponentDescription.java 2010-10-13 16:19:58 UTC (rev 8417) @@ -63,7 +63,7 @@ * * @param name name of attribute to be removed * - * @return the removed value if successfull, null otherwise + * @return the removed value if successful, null otherwise * * @throws SmartFrogRuntimeException when name is null */ Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/componentdescription/ComponentDescriptionImpl.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/componentdescription/ComponentDescriptionImpl.java 2010-10-13 16:18:37 UTC (rev 8416) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/componentdescription/ComponentDescriptionImpl.java 2010-10-13 16:19:58 UTC (rev 8417) @@ -225,10 +225,8 @@ * * @param name of attribute to be removed * - * @return removed attribute value if successfull or null if not. If the attribute - * value removed is a component description, then its parent is - * removed as well. - + * @return removed attribute value if successful or null if not. If the attribute + * value removed is a component description, then its parent attribute is set to null. * * @throws SmartFrogRuntimeException when name is null */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2011-02-15 14:00:23
|
Revision: 8486 http://smartfrog.svn.sourceforge.net/smartfrog/?rev=8486&view=rev Author: steve_l Date: 2011-02-15 14:00:17 +0000 (Tue, 15 Feb 2011) Log Message: ----------- SFOS-1563 Add some @Annotations to SmartFrog Added Paths: ----------- trunk/core/smartfrog/src/org/smartfrog/sfcore/annotations/ trunk/core/smartfrog/src/org/smartfrog/sfcore/annotations/Description.java trunk/core/smartfrog/src/org/smartfrog/sfcore/annotations/SkippedTest.java trunk/core/smartfrog/src/org/smartfrog/sfcore/annotations/package-info.java Added: trunk/core/smartfrog/src/org/smartfrog/sfcore/annotations/Description.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/annotations/Description.java (rev 0) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/annotations/Description.java 2011-02-15 14:00:17 UTC (rev 8486) @@ -0,0 +1,14 @@ +package org.smartfrog.sfcore.annotations; + + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +/** + * This declares a test that should be skipped. In Junit3, the test still needs to be renamed; this + * attribute merely comments the test skipping and allows for it to be indexed + */ +@Retention(RetentionPolicy.RUNTIME) +public @interface Description { + String value(); +} Added: trunk/core/smartfrog/src/org/smartfrog/sfcore/annotations/SkippedTest.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/annotations/SkippedTest.java (rev 0) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/annotations/SkippedTest.java 2011-02-15 14:00:17 UTC (rev 8486) @@ -0,0 +1,14 @@ +package org.smartfrog.sfcore.annotations; + + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +/** + * This attribute is used to annotate tests that should be skipped, though we need a special test runner to + * skip it reliably + */ +@Retention(RetentionPolicy.RUNTIME) +public @interface SkippedTest { + String value(); +} Added: trunk/core/smartfrog/src/org/smartfrog/sfcore/annotations/package-info.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/annotations/package-info.java (rev 0) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/annotations/package-info.java 2011-02-15 14:00:17 UTC (rev 8486) @@ -0,0 +1,5 @@ +package org.smartfrog.sfcore.annotations; + +/** + * This package contains annotations for use within the SmartFrog framework + */ \ No newline at end of file This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2011-05-04 16:37:36
|
Revision: 8560 http://smartfrog.svn.sourceforge.net/smartfrog/?rev=8560&view=rev Author: steve_l Date: 2011-05-04 16:37:30 +0000 (Wed, 04 May 2011) Log Message: ----------- SFOS-1581 Include port number when sfPing fails Modified Paths: -------------- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/ErrorMessageBundle.java trunk/core/smartfrog/src/org/smartfrog/sfcore/common/MessageKeys.java trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/DefaultRootLocatorImpl.java trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/SFProcess.java Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/common/ErrorMessageBundle.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/ErrorMessageBundle.java 2011-04-03 22:22:13 UTC (rev 8559) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/common/ErrorMessageBundle.java 2011-05-04 16:37:30 UTC (rev 8560) @@ -84,6 +84,8 @@ { MSG_UNKNOWN_HOST, "Unable to locate IP address of the host: {0}"}, { MSG_CONNECT_ERR, "Unable to connect to sfDaemon on: {0}.\nReason: sfDaemon may not be running on {0}"}, + { MSG_CONNECT_ERR_WITH_PORT, + "Unable to connect to sfDaemon on: {0}:{1}.\nReason: sfDaemon may not be running on {0}:{1}"}, { MSG_REMOTE_CONNECT_ERR, "Unable to connect to sfDaemon on: {0}.\nReason: sfDaemon may not be authenticated properly"}, { MSG_PARENT_LOCATION_FAILED, Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/common/MessageKeys.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/MessageKeys.java 2011-04-03 22:22:13 UTC (rev 8559) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/common/MessageKeys.java 2011-05-04 16:37:30 UTC (rev 8560) @@ -202,6 +202,10 @@ */ String MSG_CONNECT_ERR = "MSG_CONNECT_ERR"; /** + * Message key: unable to connect to daemon. -include the port + */ + String MSG_CONNECT_ERR_WITH_PORT = "MSG_CONNECT_ERR_WITH_PORT"; + /** * Message key: unable to connect to daemon. */ String MSG_REMOTE_CONNECT_ERR = "MSG_REMOTE_CONNECT_ERR"; Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/DefaultRootLocatorImpl.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/DefaultRootLocatorImpl.java 2011-04-03 22:22:13 UTC (rev 8559) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/DefaultRootLocatorImpl.java 2011-05-04 16:37:30 UTC (rev 8560) @@ -22,6 +22,8 @@ import java.net.InetAddress; import java.net.UnknownHostException; +import java.rmi.ConnectException; +import java.rmi.NotBoundException; import java.rmi.RemoteException; import java.rmi.registry.Registry; @@ -321,12 +323,22 @@ portNum = getRegistryPort(localCompound); } - Registry reg = SFSecurity.getRegistry(hostAddress.getHostAddress(), portNum); + String registryHostAddress = hostAddress.getHostAddress(); + Registry reg = SFSecurity.getRegistry(registryHostAddress, portNum); - ProcessCompound pc = (ProcessCompound) reg.lookup(defaultName); + ProcessCompound pc = null; + try { + pc = (ProcessCompound) reg.lookup(defaultName); + } catch (ConnectException e) { + //include the port number in the exception + throw new ConnectException("Failed to connect to " + registryHostAddress + ":" + + portNum + + " : " + e, + e); + } // Get rid of the stub if local - if ((localCompound != null)&&(pc.equals(localCompound))) { + if ((localCompound != null) && (pc.equals(localCompound))) { return localCompound; } String internalState = pc.toString(); Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/SFProcess.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/SFProcess.java 2011-04-03 22:22:13 UTC (rev 8559) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/SFProcess.java 2011-05-04 16:37:30 UTC (rev 8560) @@ -196,21 +196,23 @@ public static synchronized int getRootLocatorPort(ProcessCompound c) throws RemoteException, SmartFrogException { Object portObj=null; try { - if (c!=null) { - portObj = (c.sfResolveHere(SmartFrogCoreKeys.SF_ROOT_LOCATOR_PORT, false)); + if (c != null) { + portObj = (c.sfResolveHere(SmartFrogCoreKeys.SF_ROOT_LOCATOR_PORT, false)); } else { - portObj = SFProcess.getProcessCompoundDescription().sfResolveHere(SmartFrogCoreKeys.SF_ROOT_LOCATOR_PORT, false); + portObj = SFProcess.getProcessCompoundDescription().sfResolveHere(SmartFrogCoreKeys.SF_ROOT_LOCATOR_PORT, false); } if (portObj == null) { - throw new SmartFrogResolutionException("Unable to locate registry port from ", c); + throw new SmartFrogResolutionException("Unable to locate registry port from ", c); } Number port = (Number) portObj; return port.intValue(); - } catch (ClassCastException ccex){ + } catch (ClassCastException ccex) { throw new SmartFrogResolutionException( - "Wrong object for "+SmartFrogCoreKeys.SF_ROOT_LOCATOR_PORT - +": "+portObj+", "+portObj!=null?portObj.getClass().getName():"", - ccex, c); + "Wrong object for " + SmartFrogCoreKeys.SF_ROOT_LOCATOR_PORT + + ": " + portObj + ", " + + portObj != null ? portObj.getClass().getName() : "", + ccex, + c); } } @@ -627,6 +629,7 @@ String subProcess) throws SmartFrogException, RemoteException { ProcessCompound target = null; + int port = DefaultRootLocatorImpl.getRegistryPort(SFProcess.getProcessCompound()); try { target = SFProcess.getProcessCompound(); if (host != null) { @@ -660,9 +663,11 @@ MSG_UNKNOWN_HOST, host), uhex); } catch (ConnectException cex) { + //include the port in this exception throw new SmartFrogException(MessageUtil.formatMessage( - MSG_CONNECT_ERR, - host), cex); + MSG_CONNECT_ERR_WITH_PORT, + host, Long.toString(port)), + cex); } catch (RemoteException rmiEx) { throw new SmartFrogException(MessageUtil.formatMessage( MSG_REMOTE_CONNECT_ERR, This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2011-06-14 16:45:27
|
Revision: 8620 http://smartfrog.svn.sourceforge.net/smartfrog/?rev=8620&view=rev Author: steve_l Date: 2011-06-14 16:45:20 +0000 (Tue, 14 Jun 2011) Log Message: ----------- SFOS-1606 mark @Override the methods in the core that are overrides or interface implementations, review and correct javadocs Modified Paths: -------------- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/Context.java trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogExtractedException.java trunk/core/smartfrog/src/org/smartfrog/sfcore/compound/CompoundImpl.java trunk/core/smartfrog/src/org/smartfrog/sfcore/prim/PrimDeployerImpl.java trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/ProcessCompoundImpl.java trunk/core/smartfrog/src/org/smartfrog/sfcore/workflow/eventbus/EventCompoundImpl.java Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/common/Context.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/Context.java 2011-06-14 16:43:27 UTC (rev 8619) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/common/Context.java 2011-06-14 16:45:20 UTC (rev 8620) @@ -294,12 +294,14 @@ /** * Returns the key at index idx in context + * @param idx the index to retrieve * @return key for given index, or null if index not valid */ public Object getKey(int idx); /** * Returns the value at index idx in context + * @param idx the index to retrieve * @return value for given key index, or null if index not valid */ public Object getVal(int idx); Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogExtractedException.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogExtractedException.java 2011-06-14 16:43:27 UTC (rev 8619) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogExtractedException.java 2011-06-14 16:45:20 UTC (rev 8620) @@ -102,7 +102,7 @@ * @param sfObject component that encountered exception */ public SmartFrogExtractedException(String message, Prim sfObject) { - super(message,sfObject); + super(message, sfObject); } /** @@ -158,7 +158,7 @@ public String shortClassName() { Object o = get(EXCEPTION_CLASSNAME); if (o != null) { - String name=(String) o; + String name = (String) o; return name.substring( name.lastIndexOf('.') + 1); } else { @@ -173,10 +173,10 @@ */ public String getExceptionClassname() { Object classname = get(EXCEPTION_CLASSNAME); - if(classname!=null) { + if (classname != null) { return classname.toString(); } else { - return getClass().getName(); + return getClass().getName(); } } @@ -262,7 +262,7 @@ private static SmartFrogExtractedException createFromThrowable(Throwable thrown, Throwable cause) { SmartFrogExtractedException fault = new SmartFrogExtractedException(thrown.getMessage()); fault.fillInFromThrowable(thrown); - if(cause!=null) { + if (cause != null) { fault.initCause(cause); } return fault; Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/compound/CompoundImpl.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/compound/CompoundImpl.java 2011-06-14 16:43:27 UTC (rev 8619) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/compound/CompoundImpl.java 2011-06-14 16:45:20 UTC (rev 8620) @@ -119,6 +119,7 @@ * * @throws SmartFrogDeploymentException failed to deploy compiled component */ + @Override public Prim sfDeployComponentDescription(Object name, Prim parent, ComponentDescription cmp, Context parms) throws SmartFrogDeploymentException { // check for attribute already named like given name @@ -225,6 +226,7 @@ * @throws SmartFrogRuntimeException when name or value are null * @throws RemoteException In case of Remote/nework error */ + @Override public synchronized Object sfAddAttribute(Object name, Object value) throws SmartFrogRuntimeException, RemoteException { if ((value instanceof Prim) && sfContext.contains(value) && (this.sfContainsChild((Prim) value))) { String message = MessageUtil @@ -255,6 +257,7 @@ * injection failed * @throws RemoteException In case of Remote/network error */ + @Override public synchronized Object sfReplaceAttribute(Object name, Object value) throws SmartFrogRuntimeException, RemoteException { if ((value instanceof Prim) && sfContext.contains(value) && (this.sfContainsChild((Prim) value))) { Object nameInContext = sfContext.sfAttributeKeyFor(value); @@ -288,10 +291,11 @@ * * @return deployed component if successful * - * @exception SmartFrogDeploymentException failed to deploy compiled + * @throws SmartFrogDeploymentException failed to deploy compiled * component - * @exception RemoteException In case of Remote/network error + * @throws RemoteException In case of Remote/network error */ + @Override public Prim sfCreateNewChild(Object name, ComponentDescription cmp, Context parms) throws RemoteException, SmartFrogDeploymentException { return sfCreateNewChild(name, this, cmp, parms); @@ -309,10 +313,11 @@ * * @return deployed component if successful * - * @exception SmartFrogDeploymentException failed to deploy compiled + * @throws SmartFrogDeploymentException failed to deploy compiled * component - * @exception RemoteException In case of Remote/network error + * @throws RemoteException In case of Remote/network error */ + @Override public Prim sfCreateNewApp(String name, ComponentDescription cmp, Context parms) throws RemoteException, SmartFrogDeploymentException { return sfCreateNewChild(name, null, cmp, parms); @@ -334,10 +339,11 @@ * * @return deployed component if successful * - * @exception SmartFrogDeploymentException failed to deploy compiled + * @throws SmartFrogDeploymentException failed to deploy compiled * component - * @exception RemoteException In case of Remote/network error + * @throws RemoteException In case of Remote/network error */ + @Override public Prim sfCreateNewChild(Object name, Prim parent, ComponentDescription cmp, Context parms) throws RemoteException, SmartFrogDeploymentException { @@ -439,6 +445,7 @@ */ //public synchronized void sfAddChild(Liveness target) { // if synchronized -> locks processCompound when it registers back! + @Override public void sfAddChild(Liveness target) throws RemoteException { sfChildren.addElement((Prim) target); ((Prim) target).sfParentageChanged(); @@ -472,6 +479,7 @@ * * @return true if child in compound, false otherwise */ + @Override public boolean sfContainsChild(Liveness child) { return sfChildren.contains(child); } @@ -482,6 +490,7 @@ * @return enumeration over children */ @SuppressWarnings("unchecked") + @Override public Enumeration<Liveness> sfChildren() { return new SerializableEnumeration<Liveness>((List) sfChildren); } @@ -523,6 +532,7 @@ * * @return Reference to removed object */ + @Override public synchronized Object sfRemoveAttribute(Object key) throws SmartFrogRuntimeException, RemoteException { @@ -545,9 +555,10 @@ * @param parent parent component * @param cxt context for compound * - * @exception SmartFrogDeploymentException failed to deploy sub-components + * @throws SmartFrogDeploymentException failed to deploy sub-components * @throws RemoteException In case of Remote/nework error */ + @Override public synchronized void sfDeployWith(Prim parent, Context cxt) throws SmartFrogDeploymentException, RemoteException { @@ -587,6 +598,7 @@ * sub-component * @throws RemoteException In case of Remote/network error */ + @Override public synchronized void sfDeploy() throws SmartFrogException, RemoteException { try { //set our order. We do this before calling our super, in case we have to handle an exception at this point. @@ -636,6 +648,7 @@ * @throws SmartFrogException failed to start compound * @throws RemoteException In case of Remote/network error */ + @Override public synchronized void sfStart() throws SmartFrogException, RemoteException { try { super.sfStart(); @@ -699,6 +712,7 @@ * * @param status termination status */ + @Override protected synchronized void sfTerminateWith(TerminationRecord status) { //Re-check of sfSynchTerminate to get runtime changes. try { @@ -765,6 +779,7 @@ * @param status termination status of sender * @param comp sender of termination */ + @Override public void sfTerminatedWith(TerminationRecord status, Prim comp) { // Compound dies if sub-components die if (sfContainsChild(comp)) { @@ -777,6 +792,7 @@ * * @param target target to dump to */ + @Override public void sfDumpState(Dump target) { super.sfDumpState(target); // call sfDumpState in every child. @@ -810,8 +826,9 @@ * * @param source source of ping * - * @exception SmartFrogLivenessException liveness failed + * @throws SmartFrogLivenessException liveness failed */ + @Override public void sfPing(Object source) throws SmartFrogLivenessException, RemoteException { // check the timing of the parent pings super.sfPing(source); @@ -887,6 +904,7 @@ * Parentage changed in component hierarchy. A notification is sent to all * children. */ + @Override public void sfParentageChanged() throws RemoteException { for (Prim p : sfChildList()) { p.sfParentageChanged(); @@ -940,6 +958,7 @@ /** * Run part, just do the call, ignoring exceptions */ + @Override public void run() { String name = "unnamed"; try { @@ -958,6 +977,7 @@ * @throws RemoteException * @throws SmartFrogException - not OK to update */ + @Override public synchronized void sfPrepareUpdate() throws RemoteException, SmartFrogException { super.sfPrepareUpdate(); // iterate over all children, preparing them for update. @@ -978,6 +998,7 @@ * @throws RemoteException In case of Remote/network error * @throws SmartFrogException - failure, not OK to update */ + @Override public synchronized boolean sfUpdateWith(Context newCxt) throws RemoteException, SmartFrogException { // validate the description, return false if it requires termination, exception to fail // cache context @@ -1038,6 +1059,7 @@ * @throws RemoteException In case of Remote/network error * @throws SmartFrogException - failure, to be treated like a normal lifecycle error, by default with termination */ + @Override public synchronized void sfUpdate() throws RemoteException, SmartFrogException { Reference componentId = sfCompleteName(); if (sfIsTerminated) { @@ -1081,6 +1103,7 @@ * @throws SmartFrogException other problems */ + @Override public synchronized void sfUpdateDeploy() throws RemoteException, SmartFrogException { super.sfUpdateDeploy(); @@ -1102,6 +1125,7 @@ * @throws RemoteException In case of Remote/network error * @throws SmartFrogException other problems */ + @Override public synchronized void sfUpdateStart() throws RemoteException, SmartFrogException { super.sfUpdateStart(); @@ -1121,6 +1145,7 @@ * Can occur after prepare and check, but not afterwards to roll back from actual update process. * @throws RemoteException In case of Remote/network error */ + @Override public synchronized void sfAbandonUpdate() throws RemoteException { // notify all children of the abandon, ignoring all errors? // only occurs after failure of prepare or updatewith, future failure considered fatal @@ -1139,6 +1164,7 @@ * @throws RemoteException In case of Remote/network error * @throws SmartFrogException other problems */ + @Override public void sfUpdateComponent(ComponentDescription desc) throws RemoteException, SmartFrogException { boolean ready; Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/prim/PrimDeployerImpl.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/prim/PrimDeployerImpl.java 2011-06-14 16:43:27 UTC (rev 8619) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/prim/PrimDeployerImpl.java 2011-06-14 16:45:20 UTC (rev 8620) @@ -165,7 +165,7 @@ * * @return class for target * - * @exception Exception failed to load class + * @throws Exception failed to load class */ protected Class getPrimClass() throws Exception { String targetCodeBase=null; @@ -242,7 +242,7 @@ * * @return Prim * - * @exception SmartFrogDeploymentException failed to deploy description + * @throws SmartFrogDeploymentException failed to deploy description */ public Prim deploy(Reference name, Prim parent, Context params) throws SmartFrogDeploymentException { Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/ProcessCompoundImpl.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/ProcessCompoundImpl.java 2011-06-14 16:43:27 UTC (rev 8619) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/ProcessCompoundImpl.java 2011-06-14 16:45:20 UTC (rev 8620) @@ -135,7 +135,6 @@ protected Set<Object> processLocks = new HashSet<Object>(); public static final String ATTR_PORT = "sfPort"; private static final String JAVA_SECURITY_POLICY = "java.security.policy"; - ; public ProcessCompoundImpl() throws RemoteException { @@ -148,6 +147,7 @@ * * @throws RemoteException In case of network/rmi error */ + @Override public boolean sfIsRoot() throws RemoteException { return sfIsRoot; } @@ -210,7 +210,7 @@ /** * Override standard compound behaviour to register all components that go - * throug here as a child compound. Sub-components of given description will + * through here as a child compound. Sub-components of given description will * not go through here, and so will not be registered here. A component is * registered through sfRegister. The component can define its name in the * process compound through the sfProcessComponentName attribute. @@ -224,6 +224,7 @@ * * @throws SmartFrogDeploymentException failed to deploy compiled component */ + @Override public Prim sfDeployComponentDescription(Object name, Prim parent, ComponentDescription cmp, @@ -268,6 +269,7 @@ * @throws SmartFrogDeploymentException In case of any error while deploying * the component */ + @Override public synchronized void sfDeployWith(Prim parent, Context cxt) throws SmartFrogDeploymentException, RemoteException { try { @@ -324,10 +326,10 @@ } /** - * Exports this component using portObj. portObj can be a port or a vector + * Exports this component using portObj. portObj can be a port or a vector * containing a set of valid ports. If a vector is used the component tries * to see if the port used by the local ProcessCompound is in the vector set - * and use that if so. If not tries to use the first one avaible + * and use that if so. If not tries to use the first one available. * * @param portObj Object * @@ -337,6 +339,7 @@ * @throws SmartFrogDeploymentException In case of any error while exporting * the component */ + @Override protected Object sfExport(Object portObj) throws RemoteException, SmartFrogException { Object exportRef = null; @@ -377,6 +380,7 @@ * @throws SmartFrogDeploymentException In case of any error while * registering the component */ + @Override protected void registerWithProcessCompound() throws RemoteException, SmartFrogException { //This is a ProcessCompound. Don't need to register @@ -390,6 +394,7 @@ * @throws SmartFrogException failed to start compound * @throws RemoteException In case of Remote/nework error */ + @Override public synchronized void sfStart() throws SmartFrogException, RemoteException { super.sfStart(); //Set itself as single instance of process compound for this process @@ -472,6 +477,7 @@ * @param rec termination record * @param comp component that terminated */ + @Override public void sfTerminatedWith(TerminationRecord rec, Prim comp) { try { sfRemoveAttribute(sfAttributeKeyFor(comp)); @@ -499,6 +505,7 @@ * @param target target for the failure * @param failure The error */ + @Override public void sfLivenessFailure(Object source, Object target, Throwable failure) { if ((source == this) && (sfParent != null) && (target == sfParent)) { @@ -521,6 +528,7 @@ * * @param rec termination record */ + @Override public synchronized void sfTerminateWith(TerminationRecord rec) { super.sfTerminateWith(rec); if (sfIsRoot) { @@ -553,6 +561,7 @@ * * @param status status to terminate with */ + @Override protected void sfSyncTerminateWith(TerminationRecord status) { // Terminate legitimate children except subProc for (Prim child : sfReverseChildren()) { @@ -604,6 +613,7 @@ * * @param status status to terminate with */ + @Override protected void sfASyncTerminateWith(TerminationRecord status) { // Terminate legitimate children except subProc @@ -660,6 +670,7 @@ * * @throws RemoteException In case of network/rmi error */ + @Override public void systemExitOnTermination(boolean exit) throws RemoteException { systemExit = exit; } @@ -672,6 +683,7 @@ * @throws SmartFrogException failed detaching process compound * @throws RemoteException In case of network/rmi error */ + @Override public void sfDetach() throws SmartFrogException, RemoteException { try { super.sfDetach(); @@ -690,6 +702,7 @@ * @throws SmartFrogLivenessException liveness failure * @throws RemoteException In case of network/rmi error */ + @Override public void sfPing(Object source) throws SmartFrogLivenessException, RemoteException { super.sfPing(source); @@ -740,6 +753,7 @@ * * @return process name for this process */ + @Override public String sfProcessName() { return sfProcessName; } @@ -754,6 +768,7 @@ * TODO: clean cache when re-parenting */ + @Override public Reference sfCompleteName() throws RemoteException { if (sfCompleteName == null) { Reference r; @@ -812,6 +827,7 @@ * @throws SmartFrogException In case of resolution failure * @throws RemoteException In case of network/rmi error */ + @Override public synchronized Object sfRegister(Object name, Prim comp) throws SmartFrogException, RemoteException { if ((name != null) && (sfContext.containsKey(name))) { @@ -853,6 +869,7 @@ * @throws SmartFrogException when component was not registered * @throws RemoteException In case of network/rmi error */ + @Override public boolean sfDeRegister(Prim comp) throws SmartFrogException, RemoteException { boolean success = false; if (sfContext.contains(comp)) { @@ -883,6 +900,7 @@ * @throws Exception attribute not found after timeout * @throws RemoteException if there is any network or remote error */ + @Override public Object sfResolveHereOrWait(Object name, long timeout) throws Exception { long endTime = (new Date()).getTime() + timeout; synchronized (processLocks) { @@ -919,6 +937,7 @@ * * @throws RemoteException if there is any network or remote error */ + @Override public void sfNotifySubprocessReady(String name) throws RemoteException { // Notify any waiting threads that an attribute was added @@ -938,6 +957,7 @@ * * @throws Exception failed to deploy process */ + @Override public ProcessCompound sfResolveProcess(Object name, ComponentDescription cd) throws Exception { @@ -1217,9 +1237,11 @@ * as a command line parameter for the subprocess. The class path is created * reading one of the following in order selection: * <p/> - * 1.- from a property named sfcore.processcompound.PROCESS_NAME.java.class.path. - * 2.- attribute java.class.path inside sfProcessAttribute - * componentDescription + * <ol> + * <li>from a property named sfcore.processcompound.PROCESS_NAME.java.class.path.</li> + * <li>attribute java.class.path inside sfProcessAttribute + * componentDescription</li> + * </ol> * <p/> * The result if any is added (default) to the system property: System * property java.class.path or replaced if sfProcessReplaceClassPath=true @@ -1259,9 +1281,11 @@ * returns it as a command line parameter for the subprocess. The class path * is created reading one of the following in order selection: * <p/> - * 1.- from a property named sfcore.processcompound.PROCESS_NAME.'org.smartfrog.codebase'. - * 2.- attribute 'org.smartfrog.codebase' inside sfProcessAttribute - * componentDescription + * <ol> + * <li>from a property named sfcore.processcompound.PROCESS_NAME.'org.smartfrog.codebase'.</li> + * <li>attribute 'org.smartfrog.codebase' inside sfProcessAttribute + * componentDescription</li> + * </ol> * <p/> * The result if any is added (default) to the system property: System * property 'org.smartfrog.codebase' or replaced if @@ -1299,7 +1323,7 @@ /** * Set the classpath or other path enviroment variable up. Includes the value of the current process - * @param cd CD to work wit + * @param cd CD to work with * @param defVal default value * @param replaceBoolKey name of a boolean attribute to control replace/extend policy * @param attributeKey attribute @@ -1387,7 +1411,8 @@ * If o is a String, then it is returned withouth further modification. * The method uses the platform separator for the classpath. * @param o structured data to create the classpath - * @return String representing a classpath using the platform's separator. If the wrong data object if found the null is returned and a message is logged + * @return String representing a classpath using the platform's separator. + * If the wrong data object if found the null is returned and a message is logged */ public String convertToClassPath(Object o) { if (o == null) return null; @@ -1607,7 +1632,7 @@ /** * Set the TAGS for this component. TAGS are simply uninterpreted strings * associated with each attribute. rooProcess does not do anything. - * rootProcess does not have tags. + * The rootProcess does not have tags. * * @param tags a set of tags * @@ -1624,13 +1649,14 @@ /** * Get the TAGS for this process compound. TAGS are simply uninterpreted * strings associated with each attribute. rooProcess returns null. - * rootProcess does not have tags. + * The rootProcess does not have tags. * * @return the set of tags * * @throws RemoteException network or RMI problems * @throws SmartFrogRuntimeException the attribute does not exist; */ + @Override public Set sfGetTags() throws RemoteException, SmartFrogRuntimeException { if (sfParent != null) { return super.sfGetTags(); @@ -1640,7 +1666,7 @@ } /** - * add a tag to the tag set of this component rootProcess does not have + * add a tag to the tag set of this component. The rootProcess does not have * tags. * * @param tag a tag to add to the set @@ -1648,6 +1674,7 @@ * @throws RemoteException network or RMI problems * @throws SmartFrogRuntimeException the attribute does not exist; */ + @Override public void sfAddTag(String tag) throws RemoteException, SmartFrogRuntimeException { if (sfParent != null) { @@ -1656,7 +1683,7 @@ } /** - * remove a tag from the tag set of this component if it exists rootProcess + * remove a tag from the tag set of this component if it exists. The rootProcess * does not have tags. * * @param tag a tag to remove from the set @@ -1672,7 +1699,7 @@ } /** - * add a tag to the tag set of this component rootProcess does not have + * add a tag to the tag set of this component. The rootProcess does not have * tags. * * @param tags a set of tags to add to the set @@ -1680,6 +1707,7 @@ * @throws RemoteException network or RMI problems * @throws SmartFrogRuntimeException the attribute does not exist; */ + @Override public void sfAddTags(Set tags) throws RemoteException, SmartFrogRuntimeException { if (sfParent != null) { @@ -1688,14 +1716,15 @@ } /** - * remove a tag from the tag set of this component if it exists rootProcess - * does not have tags. + * Remove a tag from the tag set of this component if it exists. + * The rootProcess does not have tags. * * @param tags a set of tags to remove from the set * * @throws RemoteException network or RMI problems * @throws SmartFrogRuntimeException the attribute does not exist; */ + @Override public void sfRemoveTags(Set tags) throws RemoteException, SmartFrogRuntimeException { if (sfParent != null) { @@ -1714,6 +1743,7 @@ * @throws RemoteException network or RMI problems * @throws SmartFrogRuntimeException the attribute does not exist; */ + @Override public boolean sfContainsTag(String tag) throws RemoteException, SmartFrogRuntimeException { if (sfParent != null) { Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/workflow/eventbus/EventCompoundImpl.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/workflow/eventbus/EventCompoundImpl.java 2011-06-14 16:43:27 UTC (rev 8619) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/workflow/eventbus/EventCompoundImpl.java 2011-06-14 16:45:20 UTC (rev 8620) @@ -30,7 +30,6 @@ import org.smartfrog.sfcore.common.TerminatorThread; import org.smartfrog.sfcore.componentdescription.ComponentDescription; import org.smartfrog.sfcore.compound.CompoundImpl; -import org.smartfrog.sfcore.logging.Log; import org.smartfrog.sfcore.prim.Liveness; import org.smartfrog.sfcore.prim.Prim; import org.smartfrog.sfcore.prim.TerminationRecord; @@ -39,6 +38,7 @@ import java.rmi.RemoteException; import java.util.Enumeration; +import java.util.Iterator; import java.util.NoSuchElementException; @@ -173,7 +173,7 @@ * @param event the event to send */ public synchronized void sendEvent(Object event) { - if (sfLog().isDebugEnabled()) sfLog().debug("Sending event " + event); + if (sfLog().isDebugEnabled()) sfLog().debug("Sending event from " + sfCompleteNameSafe() + " -- " + event); registrar.sendEvent(event); } @@ -304,7 +304,7 @@ * </p> * @param status exit record of the component * @param comp child component that is terminating - * @return true if the termination event is to be forwarded up the chain. + * @return true iff the termination event is to be forwarded up the chain. * @throws SmartFrogRuntimeException for runtime exceptions * @throws RemoteException for network problems */ @@ -460,4 +460,25 @@ } return child; } + + + /** + * Get the actions list as a + * @return an iterator over the actions + */ + protected Iterable<Object> actionAttributes() { + return new ActionAttributesIterable(); + } + + private class ActionAttributesIterable implements Iterable<Object> { + + @Override + @SuppressWarnings("unchecked") + public Iterator<Object> iterator() { + return (Iterator<Object>) getActions().sfAttributes(); + } + + } + + } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2011-09-28 10:34:43
|
Revision: 8742 http://smartfrog.svn.sourceforge.net/smartfrog/?rev=8742&view=rev Author: steve_l Date: 2011-09-28 10:34:36 +0000 (Wed, 28 Sep 2011) Log Message: ----------- SFOS-1656 Ant component test AntComplexPropertiesTest failing Modified Paths: -------------- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogException.java trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogPhaseResolutionException.java trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogResolutionException.java trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogRuntimeException.java trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/sfcomponentdescription/SFComponentDescriptionImpl.java Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogException.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogException.java 2011-09-26 16:50:09 UTC (rev 8741) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogException.java 2011-09-28 10:34:36 UTC (rev 8742) @@ -43,7 +43,7 @@ public static final String DATA = "data"; /** Context associated with the exception. */ - protected Context cxt = null; + protected Context cxt; /** Attribute name for primContect in exceptioncontext. */ @@ -257,8 +257,11 @@ * @return boolean true if the attribute was added. */ public boolean add (Object key, Object value){ - if (cxt == null) cxt = new ContextImpl(); - else if (cxt.containsKey(key)) return false; + if (cxt == null) { + cxt = new ContextImpl(); + } else if (cxt.containsKey(key)) { + return false; + } put(key,value); return true; } @@ -292,12 +295,12 @@ try { add(PRIM_CONTEXT, serializableContext(sfObject.sfContext())); - } catch (Throwable rex){ + } catch (Throwable ignored){ //Ignore. } try { add(PRIM_COMPLETE_NAME, sfObject.sfCompleteName().toString()); - } catch (Throwable thr){ + } catch (Throwable ignored){ //Ignore. } } Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogPhaseResolutionException.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogPhaseResolutionException.java 2011-09-26 16:50:09 UTC (rev 8741) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogPhaseResolutionException.java 2011-09-28 10:34:36 UTC (rev 8742) @@ -99,10 +99,6 @@ public String toString(String nm){ StringBuilder strb = new StringBuilder(); strb.append(super.toString(nm)); -// strb.append ((((this.containsKey(SOURCE) -// && (this.get(SOURCE)!=null) -// &&(((Reference)this.get(SOURCE)).size()!=0))) -// ? (nm+SOURCE+ ": " + get(SOURCE)) : "" )); strb.append (" during phase "); strb.append (RESOLUTION_PHASE); return strb.toString(); Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogResolutionException.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogResolutionException.java 2011-09-26 16:50:09 UTC (rev 8741) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogResolutionException.java 2011-09-28 10:34:36 UTC (rev 8742) @@ -302,11 +302,13 @@ * @return a resolution exception */ public static SmartFrogResolutionException illegalClassType(Reference ref, - Reference source, Object resolvedValue, - String referenceValueType, String defaultValueType) { + Reference source, + Object resolvedValue, + String referenceValueType, + String defaultValueType) { SmartFrogResolutionException srex = new SmartFrogResolutionException(ref, source, MessageUtil.formatMessage(MSG_ILLEGAL_CLASS_TYPE_EXPECTING_GOT, defaultValueType, resolvedValue, - referenceValueType)); + referenceValueType)); srex.put(REFERENCE_OBJECT_RESOLVED, resolvedValue.toString()); srex.put(REFERENCE_OBJECT_CLASS_TYPE, referenceValueType); srex.put(DEFAULT_OBJECT_CLASS_TYPE, defaultValueType); @@ -323,12 +325,12 @@ * @param thr throwable object to be forwarded * @return Throwable that is a SmartFrogResolutionException */ - public static SmartFrogException forward (String message, Throwable thr){ + public static SmartFrogException forward(String message, Throwable thr) { if (thr instanceof SmartFrogResolutionException) { - if (message!=null){ - ((SmartFrogResolutionException)thr).add("msg: ",message); + if (message != null) { + ((SmartFrogResolutionException) thr).add("msg: ", message); } - return (SmartFrogResolutionException)thr; + return (SmartFrogResolutionException) thr; } else { return new SmartFrogResolutionException(message, thr); } Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogRuntimeException.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogRuntimeException.java 2011-09-26 16:50:09 UTC (rev 8741) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/common/SmartFrogRuntimeException.java 2011-09-28 10:34:36 UTC (rev 8742) @@ -104,8 +104,6 @@ init(sfObject); } - private void init(){ - } /** * Initializes the exception context with the SmartFrog component. * @@ -115,12 +113,12 @@ if (sfObject == null) return; try { super.init(sfObject); - } catch (Throwable rex){ + } catch (Throwable ignored){ //ignore } try { add(REFERENCE,sfObject.sfCompleteName().copy()); - } catch (Throwable rex){ + } catch (Throwable ignored){ //ignore } } @@ -152,10 +150,10 @@ */ public static SmartFrogException forward (String message, Throwable thr){ if (thr instanceof SmartFrogRuntimeException) { - if (message!=null){ - ((SmartFrogRuntimeException)thr).add("msg: ",message); + if (message != null) { + ((SmartFrogRuntimeException) thr).add("msg: ", message); } - return (SmartFrogRuntimeException)thr; + return (SmartFrogRuntimeException) thr; } else { return new SmartFrogRuntimeException(message, thr); } @@ -172,12 +170,12 @@ public String toString(String nm) { StringBuilder strb = new StringBuilder(); strb.append(super.toString(nm)); - strb.append ((((this.containsKey(REFERENCE))) ? (nm+REFERENCE+ ": " - + get(REFERENCE)) : "" )); - strb.append ((((this.containsKey(SOURCE))) ? (nm+SOURCE+ ": " - + get(SOURCE)) : "" )); - strb.append ((((this.containsKey(PRIM_CONTEXT))) ? (nm+PRIM_CONTEXT - + ": " + "included") : "" )); + strb.append((((containsKey(REFERENCE))) ? (nm + REFERENCE + ": " + + get(REFERENCE)) : "")); + strb.append((((containsKey(SOURCE))) ? (nm + SOURCE + ": " + + get(SOURCE)) : "")); + strb.append((((containsKey(PRIM_CONTEXT))) ? (nm + PRIM_CONTEXT + + ": " + "included") : "")); return strb.toString(); } } Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/sfcomponentdescription/SFComponentDescriptionImpl.java =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/sfcomponentdescription/SFComponentDescriptionImpl.java 2011-09-26 16:50:09 UTC (rev 8741) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/languages/sf/sfcomponentdescription/SFComponentDescriptionImpl.java 2011-09-28 10:34:36 UTC (rev 8742) @@ -434,6 +434,7 @@ * * @throws SmartFrogResolutionException failed to type resolve */ + @SuppressWarnings({"InstanceofCatchParameter"}) public void doTypeResolve(ResolutionState resState) throws SmartFrogResolutionException { /* System.out.println("-----------------------"); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2011-11-21 13:50:55
|
Revision: 8816 http://smartfrog.svn.sourceforge.net/smartfrog/?rev=8816&view=rev Author: steve_l Date: 2011-11-21 13:50:44 +0000 (Mon, 21 Nov 2011) Log Message: ----------- document sfLivenessDelay better Modified Paths: -------------- trunk/core/smartfrog/src/org/smartfrog/sfcore/prim/prim.sf trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/processcompound.sf Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/prim/prim.sf =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/prim/prim.sf 2011-11-21 13:49:11 UTC (rev 8815) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/prim/prim.sf 2011-11-21 13:50:44 UTC (rev 8816) @@ -59,6 +59,7 @@ // sfDeployerClass "org.smartfrog.sfcore.processcompound.PrimProcessDeployerImpl"; // sfExport true; // Export remote interface? // sfExportPort 0; //Use anonymous port for export. +// // liveness delay: set to zero for no liveness checks (not recommended) // sfLivenessDelay 0; // sfLivenessFactor 2; // sfLog "name"; //optional attribute to define a log name for a component. Modified: trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/processcompound.sf =================================================================== --- trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/processcompound.sf 2011-11-21 13:49:11 UTC (rev 8815) +++ trunk/core/smartfrog/src/org/smartfrog/sfcore/processcompound/processcompound.sf 2011-11-21 13:50:44 UTC (rev 8816) @@ -56,6 +56,7 @@ sfRootLocatorClass "org.smartfrog.sfcore.processcompound.DefaultRootLocatorImpl"; + //port to listen on sfRootLocatorPort 3800; //sfRootLocatorBindAddress "localhost"; //by default not defined This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |