Changeset 1707


Ignore:
Timestamp:
09/01/14 19:03:47 (10 years ago)
Author:
rkrimmel
Message:

Possibility to save intermediate results

Files:
1 deleted
6 edited

Legend:

Unmodified
Added
Removed

  • branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/alignment/matrix/ObjectDistanceSubstitionMatrix.java

    r1702 r1707  
    11package de.ugoe.cs.autoquest.tasktrees.alignment.matrix; 
    22 
     3import java.io.Serializable; 
    34import java.util.HashMap; 
     5import java.util.concurrent.ExecutorService; 
     6import java.util.concurrent.Executors; 
     7import java.util.concurrent.TimeUnit; 
    48import java.util.HashSet; 
    59import java.util.Iterator; 
    … …  
    1822 
    1923 
    20 public class ObjectDistanceSubstitionMatrix implements SubstitutionMatrix { 
    21  
     24public class ObjectDistanceSubstitionMatrix implements SubstitutionMatrix,Serializable { 
     25 
     26        /** 
     27         *  
     28         */ 
     29        private static final long serialVersionUID = -4253258274617754083L; 
    2230        private HashMap<Integer, Integer> idmapping; 
    2331        private ITriangleMatrix matrix; 
    … …  
    9098                        this.updateEventTaskInstances(newTasks); 
    9199                         
    92                 for(Iterator<ITask> it = newTasks.iterator();it.hasNext();) { 
    93                         int index1 = -1; 
    94                         int index2 = -1; 
    95                         float distance = 0; 
    96                         ITask task1 = it.next(); 
    97                         for (Iterator<ITask> jt = uniqueTasks.iterator(); jt.hasNext();) { 
    98                                 ITask task2 = jt.next(); 
    99                                 ITaskInstance ti1 = null; 
    100                                 ITaskInstance ti2 = null; 
    101                                 // We just need to the first instance here 
    102                                 if (task1.getInstances().size() > 0) { 
    103                                         ti1 = (ITaskInstance) task1.getInstances().iterator() 
    104                                                         .next(); 
     100                        int nThreads = de.ugoe.cs.autoquest.tasktrees.temporalrelation.SequenceForTaskDetectionRuleAlignment.nThreads; 
     101                        ExecutorService executor = Executors.newFixedThreadPool(nThreads); 
     102                         
     103                               
     104                        int count=0; 
     105                        int size=uniqueTasks.size(); 
     106                         
     107                        for(Iterator<ITask> it = newTasks.iterator();it.hasNext();) { 
     108                                ITask task1 = it.next(); 
     109                                for (Iterator<ITask> jt = uniqueTasks.iterator(); jt.hasNext();) { 
     110                                        ITask task2 = jt.next(); 
     111                                        Runnable worker = new DistanceCalculator(task1,task2); 
     112                                    executor.execute(worker); 
    105113                                } 
    106                                 if (task2.getInstances().size() > 0) { 
    107                                         ti2 = (ITaskInstance) task2.getInstances().iterator() 
    108                                                         .next(); 
    109                                 } 
    110                                 IEventTaskInstance eti1 = null; 
    111                                 IEventTaskInstance eti2 = null; 
    112  
    113                                 if (ti1 instanceof IEventTaskInstance 
    114                                                 && ti2 instanceof IEventTaskInstance) { 
    115                                         eti1 = (IEventTaskInstance) ti1; 
    116                                         index1 = getIndex(eti1); 
    117                                         eti2 = (IEventTaskInstance) ti2; 
    118                                         index2 = getIndex(eti2); 
    119                                         distance = distanceBetweenInstances(eti1, eti2); 
    120                                 } else if (ti1 instanceof IEventTaskInstance 
    121                                                 && !(ti2 instanceof IEventTaskInstance)) { 
    122                                         task1 = ((ITaskInstance) ti1).getTask(); 
    123                                         index2 = getIndex(task2); 
    124                                         eti1 = (IEventTaskInstance) ti1; 
    125                                         index1 = getIndex(eti1); 
    126                                         distance = distanceBetweenTaskAndInstance(task2, eti1); 
    127                                 } else if (!(ti1 instanceof IEventTaskInstance) 
    128                                                 && ti2 instanceof IEventTaskInstance) { 
    129                                         index1 = getIndex(task1); 
    130                                         eti2 = (IEventTaskInstance) ti2; 
    131                                         index2 = getIndex(eti2); 
    132                                         distance = distanceBetweenTaskAndInstance(task1, eti2); 
    133                                 } else if (!(ti1 instanceof IEventTaskInstance) 
    134                                                 && !(ti2 instanceof IEventTaskInstance)) { 
    135                                         index1 = getIndex(task1); 
    136                                         index2 = getIndex(task2); 
    137                                         distance = distanceBetweenTasks(task1, task2); 
    138                                 } else { 
    139                                         System.out.println("Unknown error"); 
    140                                 } 
    141  
    142                                 matrix.set(index1, index2, distance); 
    143  
    144                         } 
    145                 } 
     114                        } 
     115                         
     116                         executor.shutdown(); 
     117                            // Wait until all threads are finish 
     118                         try { 
     119                                executor.awaitTermination(60, TimeUnit.MINUTES); 
     120                        } catch (InterruptedException e) { 
     121                                e.printStackTrace(); 
     122                        } 
     123                         System.out.println("Finished all threads"); 
     124                         
    146125                } 
    147126        } 
    … …  
    158137                } 
    159138                matrix.initialize(0); 
    160                 Console.traceln(Level.INFO, "calculating distances"); 
    161                 int index1 = -1; 
    162                 int index2 = -1; 
    163                 float distance = 0; 
     139                 
     140                 
     141                int nThreads = de.ugoe.cs.autoquest.tasktrees.temporalrelation.SequenceForTaskDetectionRuleAlignment.nThreads; 
     142                Console.traceln(Level.INFO, "calculating distances with " + nThreads + " threads"); 
     143                ExecutorService executor = Executors.newFixedThreadPool(nThreads); 
     144                 
     145                       
     146                int count=0; 
     147                int size=uniqueTasks.size(); 
    164148                for (Iterator<ITask> it = uniqueTasks.iterator(); it.hasNext();) { 
    165149                        ITask task1 = it.next(); 
     150                        count++; 
     151                        if((size%count*100)==0) { 
     152                                Console.traceln(Level.INFO,(Math.round((float) count/size*100))+ "%"); 
     153                        } 
    166154                        for (Iterator<ITask> jt = uniqueTasks.iterator(); jt.hasNext();) { 
    167155                                ITask task2 = jt.next(); 
    168                                 ITaskInstance ti1 = null; 
    169                                 ITaskInstance ti2 = null; 
    170                                 // We just need to the first instance here 
    171                                 if (task1.getInstances().size() > 0) { 
    172                                         ti1 = (ITaskInstance) task1.getInstances().iterator() 
    173                                                         .next(); 
    174                                 } 
    175                                 if (task2.getInstances().size() > 0) { 
    176                                         ti2 = (ITaskInstance) task2.getInstances().iterator() 
    177                                                         .next(); 
    178                                 } 
    179                                 IEventTaskInstance eti1 = null; 
    180                                 IEventTaskInstance eti2 = null; 
    181  
    182                                 if (ti1 instanceof IEventTaskInstance 
    183                                                 && ti2 instanceof IEventTaskInstance) { 
    184                                         eti1 = (IEventTaskInstance) ti1; 
    185                                         index1 = getIndex(eti1); 
    186                                         eti2 = (IEventTaskInstance) ti2; 
    187                                         index2 = getIndex(eti2); 
    188                                         distance = distanceBetweenInstances(eti1, eti2); 
    189                                 } else if (ti1 instanceof IEventTaskInstance 
    190                                                 && !(ti2 instanceof IEventTaskInstance)) { 
    191                                         task1 = ((ITaskInstance) ti1).getTask(); 
    192                                         index2 = getIndex(task2); 
    193                                         eti1 = (IEventTaskInstance) ti1; 
    194                                         index1 = getIndex(eti1); 
    195                                         distance = distanceBetweenTaskAndInstance(task2, eti1); 
    196                                 } else if (!(ti1 instanceof IEventTaskInstance) 
    197                                                 && ti2 instanceof IEventTaskInstance) { 
    198                                         index1 = getIndex(task1); 
    199                                         eti2 = (IEventTaskInstance) ti2; 
    200                                         index2 = getIndex(eti2); 
    201                                         distance = distanceBetweenTaskAndInstance(task1, eti2); 
    202                                 } else if (!(ti1 instanceof IEventTaskInstance) 
    203                                                 && !(ti2 instanceof IEventTaskInstance)) { 
    204                                         index1 = getIndex(task1); 
    205                                         index2 = getIndex(task2); 
    206                                         distance = distanceBetweenTasks(task1, task2); 
    207                                 } else { 
    208                                         System.out.println("Unknown error"); 
    209                                 } 
    210                                 matrix.set(index1, index2, distance); 
    211  
    212                         } 
    213                 } 
     156                                Runnable worker = new DistanceCalculator(task1,task2); 
     157                            executor.execute(worker); 
     158                        } 
     159                } 
     160                 executor.shutdown(); 
     161                    // Wait until all threads are finish 
     162                 try { 
     163                        executor.awaitTermination(60, TimeUnit.MINUTES); 
     164                } catch (InterruptedException e) { 
     165                        e.printStackTrace(); 
     166                } 
     167                 System.out.println("Finished all threads"); 
     168                 
    214169                this.firstRoundMaxIndex=index; 
    215170        } 
    216171         
    217         private void computeDistance(ITask task1, ITask task2) { 
    218                  
    219                  
    220         } 
    221          
     172                 
     173 
    222174         
    223175         
    … …  
    233185                                        .iterator(); it.hasNext();) { 
    234186                                IEventTaskInstance eti2 = it.next(); 
    235                                 int taskId1 = eti1.getTask().getId(); 
    236                                 int taskId2 = eti2.getTask().getId(); 
    237                                 if (scoreExists(taskId1, taskId2)) { 
    238                                         tmpDistance += getScore(taskId1, taskId2); 
    239                                 } else { 
     187                                //int taskId1 = eti1.getTask().getId(); 
     188                                //int taskId2 = eti2.getTask().getId(); 
     189                                //if (scoreExists(taskId1, taskId2)) { 
     190                                //      tmpDistance += getScore(taskId1, taskId2); 
     191                                //} else { 
    240192                                        float dist = distanceBetweenInstances(eti1, eti2); 
    241193                                        matrix.set(getIndex(eti1), getIndex(eti2), dist); 
    242194                                        tmpDistance += dist; 
    243                                 } 
     195                                //} 
    244196                        } 
    245197                        return tmpDistance / eventTaskInstances.size(); 
    … …  
    249201        } 
    250202 
    251         public boolean scoreExists(int id, int id2) { 
     203        //public boolean scoreExists(int id, int id2) { 
    252204                //return idmapping.containsKey(id) && idmapping.containsKey(id2); 
    253                 return false; 
    254         } 
     205        //      return false; 
     206        //} 
    255207 
    256208        private float distanceBetweenTasks(ITask task1, ITask task2) { 
    … …  
    271223        } 
    272224 
    273         private int getIndex(ITask task) { 
     225        synchronized private int getIndex(ITask task) { 
    274226                int tempindex = -1; 
    275227 
    276228                if (!idmapping.containsKey(task.getId())) { 
     229                         
    277230                        idmapping.put(task.getId(), index); 
    278231                        tempindex = index; 
    … …  
    285238        } 
    286239 
    287         private int getIndex(IEventTaskInstance eti) { 
     240        synchronized private int getIndex(IEventTaskInstance eti) { 
    288241                int tempindex = -1; 
    289242                if (!idmapping.containsKey(eti.getTask().getId())) { 
    … …  
    327280 
    328281        } 
     282         
     283         
     284        private class DistanceCalculator implements Runnable { 
     285 
     286                private ITask task1; 
     287                private ITask task2; 
     288                 
     289                public DistanceCalculator(ITask task1, ITask task2){ 
     290                        this.task1 = task1; 
     291                        this.task2 = task2; 
     292                } 
     293                 
     294                 
     295                @Override 
     296                public void run() { 
     297                        computeDistance(task1,task2); 
     298                } 
     299                private void computeDistance(ITask task1, ITask task2) { 
     300                        int index1 = -1; 
     301                        int index2 = -1; 
     302                        float distance = 0; 
     303                        ITaskInstance ti1 = null; 
     304                        ITaskInstance ti2 = null; 
     305                        // We just need to the first instance here 
     306                        if (task1.getInstances().size() > 0) { 
     307                                ti1 = (ITaskInstance) task1.getInstances().iterator() 
     308                                                .next(); 
     309                        } 
     310                        if (task2.getInstances().size() > 0) { 
     311                                ti2 = (ITaskInstance) task2.getInstances().iterator() 
     312                                                .next(); 
     313                        } 
     314                        IEventTaskInstance eti1 = null; 
     315                        IEventTaskInstance eti2 = null; 
     316 
     317                        if (ti1 instanceof IEventTaskInstance 
     318                                        && ti2 instanceof IEventTaskInstance) { 
     319                                eti1 = (IEventTaskInstance) ti1; 
     320                                index1 = getIndex(eti1); 
     321                                eti2 = (IEventTaskInstance) ti2; 
     322                                index2 = getIndex(eti2); 
     323                                distance = distanceBetweenInstances(eti1, eti2); 
     324                        } else if (ti1 instanceof IEventTaskInstance 
     325                                        && !(ti2 instanceof IEventTaskInstance)) { 
     326                                task1 = ((ITaskInstance) ti1).getTask(); 
     327                                index2 = getIndex(task2); 
     328                                eti1 = (IEventTaskInstance) ti1; 
     329                                index1 = getIndex(eti1); 
     330                                distance = distanceBetweenTaskAndInstance(task2, eti1); 
     331                        } else if (!(ti1 instanceof IEventTaskInstance) 
     332                                        && ti2 instanceof IEventTaskInstance) { 
     333                                index1 = getIndex(task1); 
     334                                eti2 = (IEventTaskInstance) ti2; 
     335                                index2 = getIndex(eti2); 
     336                                distance = distanceBetweenTaskAndInstance(task1, eti2); 
     337                        } else if (!(ti1 instanceof IEventTaskInstance) 
     338                                        && !(ti2 instanceof IEventTaskInstance)) { 
     339                                index1 = getIndex(task1); 
     340                                index2 = getIndex(task2); 
     341                                distance = distanceBetweenTasks(task1, task2); 
     342                        } else { 
     343                                System.out.println("Unknown error"); 
     344                        } 
     345                        matrix.set(index1, index2, distance); 
     346                        //return distance; 
     347                         
     348                } 
     349                 
     350                 
     351        } 
    329352 
    330353} 

  • branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/alignment/matrix/StaticTriangleMatrix.java

    r1703 r1707  
    11package de.ugoe.cs.autoquest.tasktrees.alignment.matrix; 
    22 
    3 public class StaticTriangleMatrix implements ITriangleMatrix { 
     3import java.io.Serializable; 
     4 
     5public class StaticTriangleMatrix implements ITriangleMatrix,Serializable { 
    46         
     7        /** 
     8         *  
     9         */ 
     10        private static final long serialVersionUID = 7599542322424894866L; 
    511        private float[] matrix; 
    612        protected int size; 

  • branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/RuleApplicationResult.java

    r1146 r1707  
    1515package de.ugoe.cs.autoquest.tasktrees.temporalrelation; 
    1616 
     17import java.io.Serializable; 
    1718import java.util.ArrayList; 
    1819import java.util.List; 
    … …  
    3132 * @author Patrick Harms 
    3233 */ 
    33 class RuleApplicationResult { 
     34class RuleApplicationResult implements Serializable { 
    3435 
    35     /** */ 
     36 
     37        /** 
     38         *  
     39         */ 
     40        private static final long serialVersionUID = -5927099713841481328L; 
     41 
     42        /** */ 
    3643    private RuleApplicationStatus status = RuleApplicationStatus.NOT_APPLIED; 
    3744 

  • branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceForTaskDetectionRuleAlignment.java

    r1702 r1707  
    1515package de.ugoe.cs.autoquest.tasktrees.temporalrelation; 
    1616 
     17import java.io.FileInputStream; 
     18import java.io.FileOutputStream; 
     19import java.io.IOException; 
     20import java.io.ObjectInputStream; 
     21import java.io.ObjectOutputStream; 
     22import java.io.Serializable; 
    1723import java.util.ArrayList; 
    1824import java.util.Collections; 
    … …  
    2733import java.util.logging.Level; 
    2834 
     35import de.ugoe.cs.autoquest.CommandHelpers; 
    2936import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.Match; 
    3037import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.MatchOccurence; 
    … …  
    4956import de.ugoe.cs.util.StopWatch; 
    5057import de.ugoe.cs.util.console.Console; 
     58import de.ugoe.cs.util.console.GlobalDataContainer; 
    5159 
    5260/** 
    … …  
    6674 * @author Patrick Harms 
    6775 */ 
    68 class SequenceForTaskDetectionRuleAlignment implements ISessionScopeRule { 
     76public class SequenceForTaskDetectionRuleAlignment implements ISessionScopeRule { 
     77         
     78         
     79        public static int nThreads; 
     80        public static boolean harmonizeSequences; 
     81         
    6982 
    7083        private int iteration = 0; 
    … …  
    137150        public RuleApplicationResult apply(List<IUserSession> sessions) { 
    138151                RuleApplicationData appData = new RuleApplicationData(sessions); 
    139  
    140                 harmonizeEventTaskInstancesModel(appData); 
    141                 // Generate a substitution matrix between all occurring events. 
    142                 Console.traceln(Level.INFO, "generating substitution matrix"); 
    143                 Console.traceln(Level.INFO,"Got " + appData.getUniqueTasks().size() + "tasks"); 
    144                 appData.getSubmat().generate(appData.getUniqueTasks()); 
     152                if(SequenceForTaskDetectionRuleAlignment.harmonizeSequences) { 
     153                        harmonizeEventTaskInstancesModel(appData); 
     154                        Console.traceln(Level.INFO, "generating substitution matrix from " + appData.getUniqueTasks().size() + " unique tasks"); 
     155                        appData.getSubmat().generate(appData.getUniqueTasks()); 
     156                        appData.getStopWatch().stop("substitution matrix"); 
     157                        GlobalDataContainer.getInstance().addData("appData", appData); 
     158                        //Saving intermediate results to file 
     159                        Console.traceln(Level.INFO,"saving substitution matrix to file"); 
     160                        String objectName = "appData"; 
     161                        String filename = "appData.dat"; 
     162                        Object dataObject = GlobalDataContainer.getInstance().getData( 
     163                                        objectName); 
     164                        if (dataObject == null) { 
     165                                CommandHelpers.objectNotFoundMessage(objectName); 
     166                        } 
     167                        FileOutputStream fos = null; 
     168                        ObjectOutputStream out = null; 
     169                        try { 
     170                                fos = new FileOutputStream(filename); 
     171                                out = new ObjectOutputStream(fos); 
     172                                out.writeObject(dataObject); 
     173                                out.close(); 
     174                        } catch (IOException ex) { 
     175                                Console.logException(ex); 
     176                        } 
     177                } 
     178                else { 
     179                        Console.traceln(Level.INFO,"loading substitution matrix from file"); 
     180                        String objectName = "appData"; 
     181                        String filename = "appData.dat"; 
     182                        Object data = null; 
     183                        FileInputStream fis = null; 
     184                        ObjectInputStream in = null; 
     185                        try { 
     186                                fis = new FileInputStream(filename); 
     187                                in = new ObjectInputStream(fis); 
     188                                data = in.readObject(); 
     189                                in.close(); 
     190                        } catch (IOException ex) { 
     191                                Console.logException(ex); 
     192                        } catch (ClassNotFoundException ex) { 
     193                                Console.logException(ex); 
     194                        } 
     195                        if (GlobalDataContainer.getInstance().addData(objectName, data)) { 
     196                                CommandHelpers.dataOverwritten(objectName); 
     197                        } 
     198                        appData = (RuleApplicationData) GlobalDataContainer.getInstance().getData("appData"); 
     199                } 
    145200                 
    146201                 
    … …  
    733788     *  
    734789     */ 
    735         private static class RuleApplicationData { 
     790        private static class RuleApplicationData implements Serializable { 
     791 
     792                /** 
     793                 *  
     794                 */ 
     795                private static final long serialVersionUID = -7559657686755522960L; 
    736796 
    737797                private HashMap<Integer, ITask> number2task; 

  • trunk/autoquest-ui-core-alignment/src/main/java/de/ugoe/cs/autoquest/commands/usability/CMDgenerateTaskTree.java

    r1146 r1707  
    2828/** 
    2929 * <p> 
    30  * This command generates a task tree based on the provided sequences. It uses the 
    31  * {@link TaskTreeManager} for this purpose. Please consult the documentation of the task tree 
    32  * manager for more details. 
     30 * This command generates a task tree based on the provided sequences. It uses 
     31 * the {@link TaskTreeManager} for this purpose. Please consult the 
     32 * documentation of the task tree manager for more details. 
    3333 * </p> 
    3434 *  
    … …  
    3838public class CMDgenerateTaskTree implements Command { 
    3939 
    40     /* 
    41     * (non-Javadoc) 
    42     *  
    43     * @see de.ugoe.cs.util.console.Command#help() 
    44     */ 
    45     @Override 
    46     public String help() { 
    47         return "generateTaskTree <sequences> {<tasktree>}"; 
    48     } 
     40        /* 
     41        * (non-Javadoc) 
     42        *  
     43        * @see de.ugoe.cs.util.console.Command#help() 
     44        */ 
     45        @Override 
     46        public String help() { 
     47                return "generateTaskTree <sequences> {<tasktree>} {<boolean: harmonize sequences or not (true or false)>} {<integer: number of threads>}"; 
     48        } 
    4949 
    50     /* 
    51      * (non-Javadoc) 
    52      *  
    53      * @see de.ugoe.cs.util.console.Command#run(java.util.List) 
    54      */ 
    55     @SuppressWarnings("unchecked") 
    56     @Override 
    57     public void run(List<Object> parameters) { 
    58         String sequencesName; 
    59         String tasktreeName; 
    60         try { 
    61             sequencesName = (String) parameters.get(0); 
    62             if (parameters.size() > 1) { 
    63                 tasktreeName = (String) parameters.get(1); 
    64             } 
    65             else { 
    66                 tasktreeName = "tasktree"; 
    67             } 
    68         } 
    69         catch (Exception e) { 
    70             throw new IllegalArgumentException("must provide a sequences name"); 
    71         } 
     50        /* 
     51         * (non-Javadoc) 
     52         *  
     53         * @see de.ugoe.cs.util.console.Command#run(java.util.List) 
     54         */ 
     55        @SuppressWarnings("unchecked") 
     56        @Override 
     57        public void run(List<Object> parameters) { 
     58                String sequencesName; 
     59                String tasktreeName; 
     60                try { 
     61                        sequencesName = (String) parameters.get(0); 
     62                        if (parameters.size() > 1) { 
     63                                tasktreeName = (String) parameters.get(1); 
     64                        } else { 
     65                                tasktreeName = "tasktree"; 
     66                        } 
     67                } catch (Exception e) { 
     68                        throw new IllegalArgumentException("must provide a sequences name"); 
     69                } 
     70                if (parameters.size() > 2) { 
     71                        String harmonize = (String) parameters.get(2); 
     72                        de.ugoe.cs.autoquest.tasktrees.temporalrelation.SequenceForTaskDetectionRuleAlignment.harmonizeSequences = true; 
     73                        System.out.println(harmonize); 
     74                        if (harmonize.equals("false")) { 
     75                                System.out.println("Not harmonizing"); 
     76                                de.ugoe.cs.autoquest.tasktrees.temporalrelation.SequenceForTaskDetectionRuleAlignment.harmonizeSequences = false; 
     77                        } 
     78                } 
     79                if (parameters.size() > 3) { 
     80                        String threadCount = (String) parameters.get(3); 
     81                        de.ugoe.cs.autoquest.tasktrees.temporalrelation.SequenceForTaskDetectionRuleAlignment.nThreads = 1; 
     82                        try { 
     83                                int tmp = Integer.parseInt(threadCount); 
     84                                de.ugoe.cs.autoquest.tasktrees.temporalrelation.SequenceForTaskDetectionRuleAlignment.nThreads = tmp; 
     85                        } catch (Exception e) { 
     86                                throw new IllegalArgumentException( 
     87                                                "The fourth parameter must be an integer. Did you forget to name the tasktree?"); 
     88                        } 
     89                } 
    7290 
    73         Collection<List<Event>> sequences = null; 
    74         Object dataObject = GlobalDataContainer.getInstance().getData(sequencesName); 
    75         if (dataObject == null) { 
    76             CommandHelpers.objectNotFoundMessage(sequencesName); 
    77             return; 
    78         } 
    79         if (!SequenceInstanceOf.isCollectionOfSequences(dataObject)) { 
    80             CommandHelpers.objectNotType(sequencesName, "Collection<List<Event<?>>>"); 
    81             return; 
    82         } 
     91                Collection<List<Event>> sequences = null; 
     92                Object dataObject = GlobalDataContainer.getInstance().getData( 
     93                                sequencesName); 
     94                if (dataObject == null) { 
     95                        CommandHelpers.objectNotFoundMessage(sequencesName); 
     96                        return; 
     97                } 
     98                if (!SequenceInstanceOf.isCollectionOfSequences(dataObject)) { 
     99                        CommandHelpers.objectNotType(sequencesName, 
     100                                        "Collection<List<Event<?>>>"); 
     101                        return; 
     102                } 
    83103 
    84         sequences = (Collection<List<Event>>) dataObject; 
    85          
    86         ITaskModel taskModel = new TaskTreeManager().createTaskModel(sequences); 
    87          
    88         if (GlobalDataContainer.getInstance().addData(tasktreeName, taskModel)) { 
    89             CommandHelpers.dataOverwritten(sequencesName); 
    90         } 
    91          
    92     } 
     104                sequences = (Collection<List<Event>>) dataObject; 
     105 
     106                ITaskModel taskModel = new TaskTreeManager().createTaskModel(sequences); 
     107 
     108                if (GlobalDataContainer.getInstance().addData(tasktreeName, taskModel)) { 
     109                        CommandHelpers.dataOverwritten(sequencesName); 
     110                } 
     111 
     112        } 
    93113 
    94114} 

  • trunk/java-utils-alignment/src/main/java/de/ugoe/cs/util/StopWatch.java

    r1128 r1707  
    1616 
    1717import java.io.PrintStream; 
     18import java.io.Serializable; 
    1819import java.text.DecimalFormat; 
    1920import java.util.HashMap; 
    … …  
    3435 * @author Patrick Harms 
    3536 */ 
    36 public class StopWatch { 
    37      
    38     /** 
     37public class StopWatch implements Serializable{ 
     38     
     39    /** 
     40         *  
     41         */ 
     42        private static final long serialVersionUID = -4216393284789336830L; 
     43        /** 
    3944     * the splits hold internally 
    4045     */ 
Note: See TracChangeset for help on using the changeset viewer.