Ignore:
Timestamp:
08/17/12 08:33:29 (12 years ago)
Author:
pharms
Message:
  • adapted task tree creation stuff to more general event handling
File:
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeNode.java

    r498 r557  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: TreeNode.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: Patrick $  $Date: 06.11.2011 11:00:46 $ 
    … …  
    54// Creation  : 2011 by Patrick 
    65// Copyright : Patrick Harms, 2011 
    7 //------------------------------------------------------------------------------------------------- 
    86 
    97package de.ugoe.cs.quest.tasktrees.treeimpl; 
    … …  
    1210import java.util.List; 
    1311 
    14 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; 
    15  
    16  
    17 //------------------------------------------------------------------------------------------------- 
     12import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; 
     13 
    1814/** 
    1915 * TODO comment 
    20  * 
     16 *  
    2117 * @version $Revision: $ $Date: $ 
    22  * @author  2011, last modified by $Author: $ 
     18 * @author 2011, last modified by $Author: $ 
    2319 */ 
    24 //------------------------------------------------------------------------------------------------- 
    25 public class TaskTreeNodeImpl implements TaskTreeNode 
    26 { 
    27   /** */ 
    28   private static int sTemporalId = 0; 
    29  
    30   /** */ 
    31   private String mName; 
    32  
    33   /** */ 
    34   private String mDescription; 
    35    
    36   /** */ 
    37   private int mId; 
    38    
    39   /** children */ 
    40   private List<TaskTreeNode> mChildren; 
    41  
    42   //----------------------------------------------------------------------------------------------- 
    43   /** 
    44    */ 
    45   //----------------------------------------------------------------------------------------------- 
    46   TaskTreeNodeImpl(String name) 
    47   { 
    48     mName = name; 
    49     mId = getNewId(); 
    50   } 
    51    
    52   //----------------------------------------------------------------------------------------------- 
    53   /** 
    54    * TODO: comment 
    55    * 
    56    * @return 
    57    */ 
    58   //----------------------------------------------------------------------------------------------- 
    59   private static synchronized int getNewId() 
    60   { 
    61     if (sTemporalId == Integer.MAX_VALUE) 
    62     { 
    63       sTemporalId = 0; 
    64     } 
    65      
    66     return sTemporalId++; 
    67   } 
    68  
    69   //----------------------------------------------------------------------------------------------- 
    70   /** 
    71    * @return Returns the name. 
    72    */ 
    73   //----------------------------------------------------------------------------------------------- 
    74   public String getName() 
    75   { 
    76     return mName; 
    77   } 
    78  
    79   //----------------------------------------------------------------------------------------------- 
    80   /* (non-Javadoc) 
    81    * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNode#getDescription() 
    82    */ 
    83   //----------------------------------------------------------------------------------------------- 
    84   @Override 
    85   public String getDescription() 
    86   { 
    87     return mDescription; 
    88   } 
    89  
    90   //----------------------------------------------------------------------------------------------- 
    91   /** 
    92    */ 
    93   //----------------------------------------------------------------------------------------------- 
    94   public synchronized List<TaskTreeNode> getChildren() 
    95   { 
    96     if ((mChildren == null) || (mChildren.size() == 0)) 
    97     { 
    98       return new ArrayList<TaskTreeNode>(); 
    99     } 
    100      
    101     return mChildren.subList(0, mChildren.size()); 
    102   } 
    103    
    104   //----------------------------------------------------------------------------------------------- 
    105   /* (non-Javadoc) 
    106    * @see de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode#equals(TaskTreeNode) 
    107    */ 
    108   //----------------------------------------------------------------------------------------------- 
    109   @Override 
    110   public boolean equals(TaskTreeNode taskTreeNode) 
    111   { 
    112     if (!this.getClass().isInstance(taskTreeNode)) 
    113     { 
    114       return false; 
    115     } 
    116      
    117     if (taskTreeNode.hashCode() != hashCode()) 
    118     { 
    119       return false; 
    120     } 
    121      
    122     TaskTreeNodeImpl other = (TaskTreeNodeImpl) taskTreeNode; 
    123      
    124     if (mId != other.mId) 
    125     { 
    126       return false; 
    127     } 
    128      
    129     if (!mName.equals(other.mName)) 
    130     { 
    131       return false; 
    132     } 
    133      
    134     synchronized (other) 
    135     { 
    136       if (mChildren == null) 
    137       { 
    138         return (other.mChildren == null); 
    139       } 
    140       else if (other.mChildren == null) 
    141       { 
    142         return (mChildren == null); 
    143       } 
    144       else if (other.mChildren.size() != mChildren.size()) 
    145       { 
    146         return false; 
    147       } 
    148        
    149       for (int i = 0; i < mChildren.size(); i++) 
    150       { 
    151         if (!mChildren.get(i).equals(other.mChildren.get(i))) 
    152         { 
    153           return false; 
    154         } 
    155       } 
    156     } 
    157  
    158     return true; 
    159   } 
    160  
    161   //----------------------------------------------------------------------------------------------- 
    162   /* (non-Javadoc) 
    163    * @see java.lang.Object#hashCode() 
    164    */ 
    165   //----------------------------------------------------------------------------------------------- 
    166   @Override 
    167   public synchronized int hashCode() 
    168   { 
    169     return getClass().getSimpleName().hashCode(); 
    170   } 
    171  
    172   //----------------------------------------------------------------------------------------------- 
    173   /* (non-Javadoc) 
    174    * @see java.lang.Object#toString() 
    175    */ 
    176   //----------------------------------------------------------------------------------------------- 
    177   @Override 
    178   public synchronized String toString() 
    179   { 
    180     if (mChildren == null) 
    181     { 
    182       return mName + "(" + mId + ")"; 
    183     } 
    184     else 
    185     { 
    186       return mName + "(" + mId + ", " + mChildren.size() + " children)"; 
    187     } 
    188   } 
    189    
    190   //----------------------------------------------------------------------------------------------- 
    191   /** 
    192    * TODO: comment 
    193    * 
    194    * @param i 
    195    * @return  
    196    */ 
    197   //----------------------------------------------------------------------------------------------- 
    198   void setDescription(String description) 
    199   { 
    200     mDescription = description; 
    201   } 
    202  
    203   //----------------------------------------------------------------------------------------------- 
    204   /** 
    205    */ 
    206   //----------------------------------------------------------------------------------------------- 
    207   synchronized void addChild(TaskTreeNode child) 
    208   { 
    209     if (mChildren == null) 
    210     { 
    211       mChildren = new ArrayList<TaskTreeNode>(); 
    212     } 
    213      
    214     mChildren.add(child); 
    215   } 
    216    
    217   //----------------------------------------------------------------------------------------------- 
    218   /** 
    219    */ 
    220   //----------------------------------------------------------------------------------------------- 
    221   synchronized void addChild(int index, TaskTreeNode child) 
    222   { 
    223     if (mChildren == null) 
    224     { 
    225       mChildren = new ArrayList<TaskTreeNode>(); 
    226     } 
    227      
    228     mChildren.add(index, child); 
    229   } 
    230    
    231   //----------------------------------------------------------------------------------------------- 
    232   /** 
    233    * TODO: comment 
    234    * 
    235    * @param i 
    236    * @return  
    237    */ 
    238   //----------------------------------------------------------------------------------------------- 
    239   synchronized TaskTreeNode removeChild(int index) 
    240   { 
    241     return mChildren.remove(index); 
    242   } 
    243  
    244   //----------------------------------------------------------------------------------------------- 
    245   /* (non-Javadoc) 
    246    * @see java.lang.Object#clone() 
    247    */ 
    248   //----------------------------------------------------------------------------------------------- 
    249   @Override 
    250   public TaskTreeNode clone() 
    251   { 
    252     TaskTreeNodeImpl clone = null; 
    253     try 
    254     { 
    255       clone = (TaskTreeNodeImpl) super.clone(); 
    256        
    257       if (mChildren != null) 
    258       { 
    259         clone.mChildren = new ArrayList<TaskTreeNode>(); 
    260        
    261         for (TaskTreeNode child : mChildren) 
    262         { 
    263           clone.mChildren.add(child.clone()); 
    264         } 
    265       } 
    266        
    267     } 
    268     catch (CloneNotSupportedException e) 
    269     { 
    270       // this should never happen. Therefore simply dump the exception 
    271       e.printStackTrace(); 
    272     } 
    273      
    274     return clone; 
    275   } 
     20public class TaskTreeNode implements ITaskTreeNode { 
     21    /** */ 
     22    private static int temporalId = 0; 
     23 
     24    /** */ 
     25    private String name; 
     26 
     27    /** */ 
     28    private String description; 
     29 
     30    /** */ 
     31    private int id; 
     32 
     33    /** children */ 
     34    private List<ITaskTreeNode> children; 
     35 
     36    /** 
     37     *  
     38     */ 
     39    public TaskTreeNode(String name) { 
     40        this.name = name; 
     41        id = getNewId(); 
     42    } 
     43 
     44    /** 
     45     * TODO: comment 
     46     *  
     47     * @return 
     48     */ 
     49    private static synchronized int getNewId() { 
     50        if (temporalId == Integer.MAX_VALUE) { 
     51            temporalId = 0; 
     52        } 
     53 
     54        return temporalId++; 
     55    } 
     56 
     57    /** 
     58     * @return Returns the name. 
     59     */ 
     60    public String getName() { 
     61        return name; 
     62    } 
     63 
     64    /* 
     65     * (non-Javadoc) 
     66     *  
     67     * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNode#getDescription() 
     68     */ 
     69    @Override 
     70    public String getDescription() { 
     71        return description; 
     72    } 
     73 
     74    /** 
     75     *  
     76     */ 
     77    public synchronized List<ITaskTreeNode> getChildren() { 
     78        if ((children == null) || (children.size() == 0)) { 
     79            return new ArrayList<ITaskTreeNode>(); 
     80        } 
     81 
     82        return children.subList(0, children.size()); 
     83    } 
     84 
     85    /* 
     86     * (non-Javadoc) 
     87     *  
     88     * @see de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode#equals(TaskTreeNode) 
     89     */ 
     90    @Override 
     91    public boolean equals(ITaskTreeNode taskTreeNode) { 
     92        if (!this.getClass().isInstance(taskTreeNode)) { 
     93            return false; 
     94        } 
     95 
     96        if (taskTreeNode.hashCode() != hashCode()) { 
     97            return false; 
     98        } 
     99 
     100        TaskTreeNode other = (TaskTreeNode) taskTreeNode; 
     101 
     102        if (id != other.id) { 
     103            return false; 
     104        } 
     105 
     106        if (!name.equals(other.name)) { 
     107            return false; 
     108        } 
     109 
     110        synchronized (other) { 
     111            if (children == null) { 
     112                return (other.children == null); 
     113            } 
     114            else if (other.children == null) { 
     115                return (children == null); 
     116            } 
     117            else if (other.children.size() != children.size()) { 
     118                return false; 
     119            } 
     120 
     121            for (int i = 0; i < children.size(); i++) { 
     122                if (!children.get(i).equals(other.children.get(i))) { 
     123                    return false; 
     124                } 
     125            } 
     126        } 
     127 
     128        return true; 
     129    } 
     130 
     131    /* 
     132     * (non-Javadoc) 
     133     *  
     134     * @see java.lang.Object#hashCode() 
     135     */ 
     136    @Override 
     137    public synchronized int hashCode() { 
     138        return getClass().getSimpleName().hashCode(); 
     139    } 
     140 
     141    /* 
     142     * (non-Javadoc) 
     143     *  
     144     * @see java.lang.Object#toString() 
     145     */ 
     146    @Override 
     147    public synchronized String toString() { 
     148        if (children == null) { 
     149            return name + "(" + id + ")"; 
     150        } 
     151        else { 
     152            return name + "(" + id + ", " + children.size() + " children)"; 
     153        } 
     154    } 
     155 
     156    /** 
     157     * TODO: comment 
     158     *  
     159     * @param i 
     160     * @return 
     161     */ 
     162    void setDescription(String description) { 
     163        this.description = description; 
     164    } 
     165 
     166    /** 
     167     *  
     168     */ 
     169    synchronized void addChild(ITaskTreeNode child) { 
     170        if (children == null) { 
     171            children = new ArrayList<ITaskTreeNode>(); 
     172        } 
     173 
     174        children.add(child); 
     175    } 
     176 
     177    /** 
     178     *  
     179     */ 
     180    synchronized void addChild(int index, ITaskTreeNode child) { 
     181        if (children == null) { 
     182            children = new ArrayList<ITaskTreeNode>(); 
     183        } 
     184 
     185        children.add(index, child); 
     186    } 
     187 
     188    /** 
     189     * TODO: comment 
     190     *  
     191     * @param i 
     192     * @return 
     193     */ 
     194    synchronized ITaskTreeNode removeChild(int index) { 
     195        return children.remove(index); 
     196    } 
     197 
     198    /* 
     199     * (non-Javadoc) 
     200     *  
     201     * @see java.lang.Object#clone() 
     202     */ 
     203    @Override 
     204    public ITaskTreeNode clone() { 
     205        TaskTreeNode clone = null; 
     206        try { 
     207            clone = (TaskTreeNode) super.clone(); 
     208 
     209            if (children != null) { 
     210                clone.children = new ArrayList<ITaskTreeNode>(); 
     211 
     212                for (ITaskTreeNode child : children) { 
     213                    clone.children.add(child.clone()); 
     214                } 
     215            } 
     216 
     217        } 
     218        catch (CloneNotSupportedException e) { 
     219            // this should never happen. Therefore simply dump the exception 
     220            e.printStackTrace(); 
     221        } 
     222 
     223        return clone; 
     224    } 
    276225 
    277226} 
Note: See TracChangeset for help on using the changeset viewer.