Changeset 1526


Ignore:
Timestamp:
03/01/2012 12:43:05 PM (7 years ago)
Author:
michael.kriegel
Message:

variables refering to world model or black board in competency execution plans are now only resolved when the competency is invoked and not as previously when the whole plan starts

Location:
libs/cmion/cmionMain/src/cmion/level2
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • libs/cmion/cmionMain/src/cmion/level2/Competency.java

    r1241 r1526  
    5454        /** the concrete values of parameters when running this competence */ 
    5555        private HashMap<String, String> parameters; 
     56 
     57        /** the id identifying this particular execution of this competency */ 
     58        private long executionID;        
    5659         
    5760        /** this boolean indicates whether the competency is running or not */ 
     
    118121        { 
    119122                // raise event that we are starting this competency 
    120                 this.raise(new EventCompetencyStarted(this, parameters, plan)); 
     123                this.raise(new EventCompetencyStarted(this, parameters, plan, executionID)); 
    121124                 
    122125                // start competency code and when finished store the return value 
     
    137140                {                        
    138141                        if (cancelled) 
    139                                 this.raise(new EventCompetencyCancelled(this, parameters, plan)); 
     142                                this.raise(new EventCompetencyCancelled(this, parameters, plan, executionID)); 
    140143                        else if (succeeded)  
    141                                 this.raise(new EventCompetencySucceeded(this, parameters, plan)); 
     144                                this.raise(new EventCompetencySucceeded(this, parameters, plan, executionID)); 
    142145                        else  
    143                                 this.raise(new EventCompetencyFailed(this, parameters, plan)); 
     146                                this.raise(new EventCompetencyFailed(this, parameters, plan, executionID)); 
    144147                         
    145148                        this.running = false; 
     
    164167         * @param cep the competency execution plan, as part of which this competency was started,  
    165168         *                or null if the competency was not started by the execution system 
     169         * @param executionID  
    166170         */ 
    167         public void requestStartCompetency(HashMap<String,String> parameters, CompetencyExecutionPlan cep) 
    168         { 
    169                 this.schedule(new RequestStartCompetency(parameters,cep)); 
     171        public void requestStartCompetency(HashMap<String,String> parameters, CompetencyExecutionPlan cep, long executionID) 
     172        { 
     173                this.schedule(new RequestStartCompetency(parameters,cep,executionID)); 
    170174        } 
    171175         
    172176        /** internal method for starting the competence  
     177         * @param executionID  
    173178         * @param competencyExecutionPlan */ 
    174         private synchronized void startCompetence(HashMap<String,String> parameters, CompetencyExecutionPlan plan) 
     179        private synchronized void startCompetence(HashMap<String,String> parameters, CompetencyExecutionPlan plan, long executionID) 
    175180        { 
    176181                // check if the competence is available and not already running 
     
    185190                        // copy current plan 
    186191                        this.plan = plan; 
     192                         
     193                        // copy execution id 
     194                        this.executionID = executionID; 
    187195                         
    188196                        // run competency in a new thread                        
     
    219227                { 
    220228                        // if there are more than one request, only the first one will normally succeed 
    221                         startCompetence(request.getParameters(), request.getPlan()); 
     229                        startCompetence(request.getParameters(), request.getPlan(), request.getExecutionID()); 
    222230                }        
    223231            } 
  • libs/cmion/cmionMain/src/cmion/level2/CompetencyExecution.java

    r1241 r1526  
    4040import java.util.ArrayList; 
    4141import java.util.HashMap; 
     42import java.util.StringTokenizer; 
    4243 
    4344import cmion.architecture.IArchitecture; 
    4445import cmion.architecture.CmionComponent; 
     46import cmion.storage.CmionStorageContainer; 
    4547 
    4648 
     
    197199                                runningCompetencies.put(competency,cep); 
    198200                                 
     201                                // get parameters for executing the competency and replace black board / world model variables  
     202                                HashMap<String,String> parameters =  replaceVariables(step.getCompetencyParameters());                           
     203                                 
     204                                // assign an execution id to the step 
     205                                step.assignExecutionID(); 
     206                                 
    199207                                // request the competency to start 
    200                                 competency.requestStartCompetency(step.getCompetencyParameters(),cep); 
     208                                competency.requestStartCompetency(parameters,cep,step.getExecutionID()); 
    201209                                 
    202210                                break; 
     
    207215        } 
    208216 
     217        /** replace variables in comptetency execution parameters */ 
     218        private HashMap<String, String> replaceVariables( 
     219                        HashMap<String, String> parameters)  
     220        { 
     221                HashMap<String, String> copiedParameters = new HashMap<String, String>(); 
     222                 
     223                // copy all parameters  
     224                for (String parameterName : parameters.keySet()) 
     225                { 
     226                        // retrieve original value 
     227                        String value = parameters.get(parameterName); 
     228                         
     229         
     230                        // Check if there are any blackboard variables to replace 
     231                        // this means search for $BB, variables look like this $BB(utterance) reads the value 
     232                        // of the blackboard property utterance, $BB(messages.1) reads the value of the property 1 
     233                        // in the sub container 1, etc. 
     234 
     235                        value = replaceStorageContainerVars(value,"$BB",architecture.getBlackBoard()); 
     236                         
     237                        // do exactly the same for world model variables ($WM) 
     238                         
     239                        value = replaceStorageContainerVars(value,"$WM",architecture.getWorldModel()); 
     240                                                 
     241                        // add parameter and value 
     242                        copiedParameters.put(parameterName, value);                      
     243                } 
     244 
     245                 
     246                return copiedParameters; 
     247        } 
     248 
     249        /** method for retrieving the String contents of a storage container slot  
     250         * @param input the expression to evaluate  
     251         * @param varIdentifier  the String used to identify the topContainer 
     252         * @param topContainer the top container to read the value from  
     253         * */ 
     254        private String replaceStorageContainerVars(String input, String varIdentifier, 
     255                        CmionStorageContainer topContainer)  
     256        { 
     257                String value = input; 
     258                while (value.contains(varIdentifier)) 
     259                { 
     260                        int idx = value.indexOf(varIdentifier); 
     261                        String substring = ""; 
     262                        for (int i=idx; value.charAt(i)!=')'; i++) 
     263                                substring += value.charAt(i); 
     264                         
     265                        // substring should now contain the $BB/WM expression, excluding the closing bracket, 
     266                        // next we split on the '.' and '(' characters 
     267                        StringTokenizer st = new StringTokenizer(substring,".("); 
     268                        ArrayList<String> tokens = new ArrayList<String>(); 
     269                        if (st.hasMoreTokens()) st.nextToken(); // discard the first token 
     270                        while (st.hasMoreTokens()) tokens.add(st.nextToken()); // store the rest in the array list 
     271                         
     272                        // now add the closing bracket to the substring, so that when we replace it, it gets replaced completely 
     273                        substring += ")"; 
     274                         
     275                        // if there isnt at least one token this variable is malformed, remove from string 
     276                        if (tokens.size()<1)  
     277                                value = value.replace(substring, ""); 
     278                        else 
     279                        { 
     280                                // last token is the name of the property 
     281                                String propName = tokens.remove(tokens.size()-1); 
     282                                CmionStorageContainer csc = topContainer; 
     283                                while (tokens.size()>0) 
     284                                { 
     285                                        String containerName = tokens.remove(tokens.size()-1); 
     286                                        if (csc!=null) 
     287                                                csc = csc.getSubContainer(containerName); 
     288                                } 
     289                                if (csc==null) 
     290                                        value = value.replace(substring, ""); 
     291                                else 
     292                                { 
     293                                        Object propValue = csc.getPropertyValue(propName); 
     294                                        if (propValue==null) 
     295                                                value = value.replace(substring, ""); 
     296                                        else 
     297                                                value = value.replace(substring, propValue.toString()); 
     298                                } 
     299                        } 
     300                } 
     301 
     302                return value; 
     303        } 
     304         
     305         
    209306        /** this method should be called when an execution plan has failed */ 
    210307        private synchronized void planFailed(CompetencyExecutionPlan cep) 
     
    245342         
    246343        /** process the success of a competency*/ 
    247         private synchronized void processCompetencySuccess(Competency competency, HashMap<String,String> parameters) 
     344        private synchronized void processCompetencySuccess(Competency competency, HashMap<String,String> parameters, long executionID) 
    248345        { 
    249346                // get the plan that this competency is part of realizing 
     
    262359                for (CompetencyExecutionPlanStep step : plan.getStepsCurrentlyExecuted()) 
    263360                        if (step.getCompetencyType().equals(competency.getCompetencyType())) 
    264                                 // compare parameters to make sure this competency was what the plan step required 
    265                                 if (parameters.equals(step.getCompetencyParameters())) 
     361                                // compare execution ids to find out this competency was what the plan step required 
     362                                if (executionID == step.getExecutionID()) 
    266363                                { 
    267364                                        s = step; 
     
    280377 
    281378        /** process the failure of a competency*/ 
    282         private synchronized void processCompetencyFailure(Competency competency, HashMap<String,String> parameters) 
     379        private synchronized void processCompetencyFailure(Competency competency, HashMap<String,String> parameters, long executionID) 
    283380        { 
    284381                // get the plan that this competency is part of realizing 
     
    296393                for (CompetencyExecutionPlanStep step : plan.getStepsCurrentlyExecuted()) 
    297394                        if (step.getCompetencyType().equals(competency.getCompetencyType())) 
    298                                 // compare parameters to make sure this competency was what the plan step required 
    299                                 if (parameters.equals(step.getCompetencyParameters())) 
     395                                // compare execution ids to find out this competency was what the plan step required 
     396                                if (executionID == step.getExecutionID()) 
    300397                                { 
    301398                                        s = step; 
     
    316413 
    317414        /** process the cancelation of a competency*/ 
    318         private synchronized void processCompetencyCancel(Competency competency, HashMap<String,String> parameters) 
     415        private synchronized void processCompetencyCancel(Competency competency, HashMap<String,String> parameters, long executionID) 
    319416        { 
    320417                // get the plan that this competency is part of realizing 
     
    333430                for (CompetencyExecutionPlanStep step : plan.getStepsCurrentlyExecuted()) 
    334431                        if (step.getCompetencyType().equals(competency.getCompetencyType())) 
    335                                 // compare parameters to make sure this competency was what the plan step required 
    336                                 if (parameters.equals(step.getCompetencyParameters())) 
     432                                // compare execution ids to find out this competency was what the plan step required 
     433                                if (executionID == step.getExecutionID()) 
    337434                                { 
    338435                                        s = step; 
     
    412509                Competency competency = ((EventCompetencySucceeded)evt).getCompetency(); 
    413510                HashMap<String,String> parameters = ((EventCompetencySucceeded)evt).getParameters(); 
    414                 processCompetencySuccess(competency, parameters); 
     511                long executionID = ((EventCompetencyCancelled)evt).getExecutionID(); 
     512                processCompetencySuccess(competency, parameters,executionID); 
    415513            } 
    416514        } 
     
    428526                Competency competency = ((EventCompetencyFailed)evt).getCompetency(); 
    429527                HashMap<String,String> parameters = ((EventCompetencyFailed)evt).getParameters(); 
    430                 processCompetencyFailure(competency, parameters); 
     528                long executionID = ((EventCompetencyCancelled)evt).getExecutionID(); 
     529                processCompetencyFailure(competency, parameters, executionID); 
    431530            } 
    432531        } 
     
    444543                Competency competency = ((EventCompetencyCancelled)evt).getCompetency(); 
    445544                HashMap<String,String> parameters = ((EventCompetencyCancelled)evt).getParameters(); 
    446                 processCompetencyCancel(competency, parameters); 
     545                long executionID = ((EventCompetencyCancelled)evt).getExecutionID(); 
     546                processCompetencyCancel(competency, parameters, executionID); 
    447547            } 
    448548        } 
  • libs/cmion/cmionMain/src/cmion/level2/CompetencyExecutionPlanStep.java

    r1130 r1526  
    3939 
    4040import cmion.architecture.IArchitecture; 
    41 import cmion.storage.CmionStorageContainer; 
    4241 
    4342/** represents a step in a competency execution plan, can be instantiated or uninstantiated, 
     
    6867        private IArchitecture architecture; 
    6968         
     69        /** an id assigned to this step when executed and transimitted to the competency, so that we know */ 
     70        private long executionID; 
     71         
     72        private static Object executionIDLock = new Object(); 
     73         
     74        private static long nextExecutionID = 0; 
     75         
    7076        /** private constructor only used from within this class */ 
    7177        private CompetencyExecutionPlanStep(IArchitecture architecture) 
    7278        { 
     79                executionID = 0; 
    7380                this.architecture = architecture; 
    7481                preconditions = new ArrayList<String>(); 
     
    159166                                value = value.replace(key, mappings.get(key)); 
    160167                        } 
    161          
    162                         // after replacing all variables, check if there are any blackboard variables to replace 
    163                         // this means search for $BB, variables look like this $BB(utterance) reads the value 
    164                         // of the blackboard property utterance, $BB(messages.1) reads the value of the property 1 
    165                         // in the sub container 1, etc. 
    166  
    167                         value = replaceStorageContainerVars(value,"$BB",architecture.getBlackBoard()); 
    168                          
    169                         // do exactly the same for world model variables ($WM) 
    170                          
    171                         value = replaceStorageContainerVars(value,"$WM",architecture.getWorldModel()); 
    172                                                  
     168                                                         
    173169                        // add parameter and value 
    174170                        returnStep.competencyParameters.put(parameterName, value);                       
     
    181177        } 
    182178 
    183         private String replaceStorageContainerVars(String input, String varIdentifier, 
    184                         CmionStorageContainer topContainer)  
    185         { 
    186                 String value = input; 
    187                 while (value.contains(varIdentifier)) 
    188                 { 
    189                         int idx = value.indexOf(varIdentifier); 
    190                         String substring = ""; 
    191                         for (int i=idx; value.charAt(i)!=')'; i++) 
    192                                 substring += value.charAt(i); 
    193                          
    194                         // substring should now contain the $BB/WM expression, excluding the closing bracket, 
    195                         // next we split on the '.' and '(' characters 
    196                         StringTokenizer st = new StringTokenizer(substring,".("); 
    197                         ArrayList<String> tokens = new ArrayList<String>(); 
    198                         if (st.hasMoreTokens()) st.nextToken(); // discard the first token 
    199                         while (st.hasMoreTokens()) tokens.add(st.nextToken()); // store the rest in the array list 
    200                          
    201                         // now add the closing bracket to the substring, so that when we replace it, it gets replaced completely 
    202                         substring += ")"; 
    203                          
    204                         // if there isnt at least one token this variable is malformed, remove from string 
    205                         if (tokens.size()<1)  
    206                                 value = value.replace(substring, ""); 
    207                         else 
    208                         { 
    209                                 // last token is the name of the property 
    210                                 String propName = tokens.remove(tokens.size()-1); 
    211                                 CmionStorageContainer csc = topContainer; 
    212                                 while (tokens.size()>0) 
    213                                 { 
    214                                         String containerName = tokens.remove(tokens.size()-1); 
    215                                         if (csc!=null) 
    216                                                 csc = csc.getSubContainer(containerName); 
    217                                 } 
    218                                 if (csc==null) 
    219                                         value = value.replace(substring, ""); 
    220                                 else 
    221                                 { 
    222                                         Object propValue = csc.getPropertyValue(propName); 
    223                                         if (propValue==null) 
    224                                                 value = value.replace(substring, ""); 
    225                                         else 
    226                                                 value = value.replace(substring, propValue.toString()); 
    227                                 } 
    228                         } 
    229                 } 
    230  
    231                 return value; 
    232         } 
    233  
     179        public void assignExecutionID() 
     180        { 
     181                synchronized(executionIDLock) 
     182                { 
     183                        nextExecutionID ++; 
     184                        executionID = nextExecutionID; 
     185                } 
     186        } 
     187 
     188        /** returns the executionID of this plan step */ 
     189        public long getExecutionID() 
     190        { 
     191                return executionID; 
     192        } 
     193         
    234194        /** returns the ID of this plan step */ 
    235195        public String getID()  
  • libs/cmion/cmionMain/src/cmion/level2/CompetencyLibrary.java

    r1241 r1526  
    308308                                                        // note: competency start parameters are empty, if something needs to be passed to 
    309309                                                        // the competency, the constructor can be used 
    310                                                         competency.requestStartCompetency(new HashMap<String,String>(),null); 
     310                                                        competency.requestStartCompetency(new HashMap<String,String>(),null,0); 
    311311                                                        alreadyStartedCompetencies.add(competency); 
    312312                                                } 
     
    397397                        Competency comp = (Competency) whatAdded; 
    398398                        // request start now 
    399                         comp.requestStartCompetency(new HashMap<String,String>(),null); 
     399                        comp.requestStartCompetency(new HashMap<String,String>(),null,0); 
    400400                        // remove object from list 
    401401                        competenciesToStart.remove(whatAdded); 
  • libs/cmion/cmionMain/src/cmion/level2/EventCompetencyCancelled.java

    r1243 r1526  
    3232import java.util.HashMap; 
    3333 
    34 import cmion.architecture.CmionEvent; 
    35  
    3634/** this event signifies that the execution of a competency was cancelled */ 
    3735public class EventCompetencyCancelled extends CompetencyEvent  
     
    4745        protected CompetencyExecutionPlan plan; 
    4846 
     47        /** execution id */ 
     48        private long executionID;                
    4949         
    5050        public EventCompetencyCancelled(Competency competency, 
    51                         HashMap<String, String> parameters, CompetencyExecutionPlan plan)  
     51                        HashMap<String, String> parameters, CompetencyExecutionPlan plan, long executionID)  
    5252        { 
    5353                this.competency = competency; 
    5454                this.parameters = parameters; 
     55                this.executionID = executionID; 
    5556                this.plan = plan; 
    5657        } 
     
    7677        } 
    7778         
     79        public long getExecutionID() 
     80        { 
     81                return executionID; 
     82        }                
     83         
    7884        /** displays information about this event */ 
    7985        @Override 
    8086        public String toString() 
    8187        { 
    82                 String evtString =  "Competency cancelled: " + competency.getCompetencyName(); 
     88                String evtString =  "Competency "+executionID+" cancelled: " + competency.getCompetencyName(); 
    8389                evtString += ", parameters:"; 
    8490                if (parameters.size()==0) evtString += " none"; 
  • libs/cmion/cmionMain/src/cmion/level2/EventCompetencyFailed.java

    r1243 r1526  
    3232import java.util.HashMap; 
    3333 
    34 import cmion.architecture.CmionEvent; 
    35  
    3634/** this event signifies that the execution of a competency has failed */ 
    3735public class EventCompetencyFailed extends CompetencyEvent  
     
    4543         
    4644        /** the competency execution plan as part of which this competency was started */ 
    47         protected CompetencyExecutionPlan plan;          
     45        protected CompetencyExecutionPlan plan;  
     46         
     47        /** execution id */ 
     48        private long executionID; 
    4849         
    4950        public EventCompetencyFailed(Competency competency, 
    50                         HashMap<String, String> parameters, CompetencyExecutionPlan plan)  
     51                        HashMap<String, String> parameters, CompetencyExecutionPlan plan, long executionID)  
    5152        { 
    5253                this.competency = competency; 
    5354                this.parameters = parameters; 
     55                this.executionID = executionID; 
    5456                this.plan = plan;                        
    5557        } 
     
    7577        }        
    7678         
     79        public long getExecutionID() 
     80        { 
     81                return executionID; 
     82        } 
     83         
    7784        /** displays information about this event */ 
    7885        @Override 
    7986        public String toString() 
    8087        { 
    81                 String evtString =  "Competency failed: " + competency.getCompetencyName(); 
     88                String evtString =  "Competency "+executionID+" failed: " + competency.getCompetencyName(); 
    8289                evtString += ", parameters:"; 
    8390                if (parameters.size()==0) evtString += " none"; 
  • libs/cmion/cmionMain/src/cmion/level2/EventCompetencyStarted.java

    r1243 r1526  
    3333import java.util.HashMap; 
    3434 
    35 import cmion.architecture.CmionEvent; 
    36  
    3735/** this event signifies that the execution of a competency has started */ 
    3836public class EventCompetencyStarted extends CompetencyEvent  { 
     
    4442        private HashMap<String, String> parameters; 
    4543         
     44        /** execution id */ 
     45        private long executionID; 
     46         
    4647        /** the competency execution plan as part of which this competency was started */ 
    4748        protected CompetencyExecutionPlan plan;  
    4849         
    4950        public EventCompetencyStarted(Competency competency, 
    50                         HashMap<String, String> parameters, CompetencyExecutionPlan plan)  
     51                        HashMap<String, String> parameters, CompetencyExecutionPlan plan, long executionID)  
    5152        { 
    5253                this.competency = competency; 
    5354                this.parameters = parameters; 
     55                this.executionID = executionID; 
    5456                this.plan = plan;                
    5557        } 
     
    5961        { 
    6062                return competency; 
     63        } 
     64                 
     65        public long getExecutionID() 
     66        { 
     67                return executionID; 
    6168        } 
    6269         
     
    7986        public String toString() 
    8087        { 
    81                 String evtString =  "Competency started: " + competency.getCompetencyName(); 
     88                String evtString =  "Competency "+executionID+" started: " + competency.getCompetencyName(); 
    8289                evtString += ", parameters:"; 
    8390                if (parameters.size()==0) evtString += " none"; 
  • libs/cmion/cmionMain/src/cmion/level2/EventCompetencySucceeded.java

    r1243 r1526  
    3333import java.util.HashMap; 
    3434 
    35 import cmion.architecture.CmionEvent; 
    36  
    3735/** this event signifies that the execution of a competency has suceeded */ 
    3836public class EventCompetencySucceeded extends CompetencyEvent  { 
     
    4341        /** the parameters the competency was running with, when suceeding */ 
    4442        private HashMap<String, String> parameters; 
     43 
     44        /** execution id */ 
     45        private long executionID;        
    4546         
    4647        /** the competency execution plan as part of which this competency was started */ 
     
    4849         
    4950        public EventCompetencySucceeded(Competency competency, 
    50                         HashMap<String, String> parameters, CompetencyExecutionPlan plan)  
     51                        HashMap<String, String> parameters, CompetencyExecutionPlan plan, long executionID)  
    5152        { 
    5253                this.competency = competency; 
    5354                this.parameters = parameters; 
     55                this.executionID = executionID; 
    5456                this.plan = plan;                
    5557        } 
     
    6668                return parameters; 
    6769        } 
     70 
     71        public long getExecutionID() 
     72        { 
     73                return executionID; 
     74        }        
    6875         
    6976        /** returns the competency execution plan as part of which this competency  
     
    7986        public String toString() 
    8087        { 
    81                 String evtString =  "Competency succeeded: " + competency.getCompetencyName(); 
     88                String evtString =  "Competency "+executionID+" succeeded: " + competency.getCompetencyName(); 
    8289                evtString += ", parameters:"; 
    8390                if (parameters.size()==0) evtString += " none"; 
  • libs/cmion/cmionMain/src/cmion/level2/RequestStartCompetency.java

    r1241 r1526  
    4343        private CompetencyExecutionPlan cep; 
    4444         
     45        /** the execution id for the competency */ 
     46        private long executionID; 
    4547         
    4648        /** create a new request to start a competency 
     
    4850         * @param parameters the parameters for starting the competency 
    4951         * @param cep the competency execution plan, as part of which this competency was started 
     52         * @param executionID  
    5053         */ 
    51         public RequestStartCompetency(HashMap<String, String> parameters, CompetencyExecutionPlan cep) { 
     54        public RequestStartCompetency(HashMap<String, String> parameters, CompetencyExecutionPlan cep, long executionID) { 
    5255                this.parameters = parameters; 
    5356                this.cep = cep; 
     57                this.executionID = executionID; 
    5458        } 
    5559 
     
    6670        } 
    6771         
     72        /** returns the execution id for this competency*/ 
     73        public long getExecutionID() 
     74        { 
     75                return executionID; 
     76        } 
     77         
    6878} 
Note: See TracChangeset for help on using the changeset viewer.