replaced <code></code> with more concise {@code}
[idea/community.git] / platform / external-system-api / src / com / intellij / openapi / externalSystem / model / Key.java
index b065741606534e0b3a9a7258dd88f2782a2f7aa9..91d91591591ae4ca227fea7516b79d6d74a3f33d 100644 (file)
@@ -31,19 +31,49 @@ import java.io.Serializable;
  * @since 4/12/13 11:49 AM
  * @param <T>  data class
  */
-public class Key<T> implements Serializable {
+@SuppressWarnings("UnusedDeclaration")
+public class Key<T> implements Serializable, Comparable<Key<?>> {
 
   private static final long serialVersionUID = 1L;
   
   @NotNull private final String myDataClass;
+  
+  private final int myProcessingWeight;
 
-  public Key(@NotNull String dataClass) {
+  /**
+   * Creates new {@code Key} object.
+   * 
+   * @param dataClass         class of the payload data which will be associated with the current key
+   * @param processingWeight  there is a possible case that when a {@link DataNode} object has children of more than on type (children
+   *                          with more than one different {@link Key} we might want to process one type of children before another.
+   *                          That's why we need a way to define that processing order. This parameter serves exactly for that -
+   *                          lower value means that key's payload should be processed <b>before</b> payload of the key with a greater
+   *                          value
+   */
+  public Key(@NotNull String dataClass, int processingWeight) {
     myDataClass = dataClass;
+    myProcessingWeight = processingWeight;
   }
 
   @NotNull
-  public static <T> Key<T> create(@NotNull Class<T> dataClass) {
-    return new Key<T>(dataClass.getName());
+  public static <T> Key<T> create(@NotNull Class<T> dataClass, int processingWeight) {
+    return new Key<>(dataClass.getName(), processingWeight);
+  }
+
+  public String getDataType() {
+    return myDataClass;
+  }
+
+  /**
+   * There is a possible case that when a {@link DataNode} object has children of more than on type (children with more than
+   * one different {@link Key} we might want to process one type of children before another. That's why we need a way to define
+   * that processing order. This property serves exactly for that - lower value means that key's payload should be processed
+   * <b>before</b> payload of the key with a greater value.
+   * 
+   * @return    processing weight for data associated with the current key
+   */
+  public int getProcessingWeight() {
+    return myProcessingWeight;
   }
 
   @Override
@@ -64,7 +94,14 @@ public class Key<T> implements Serializable {
   }
 
   @Override
+  public int compareTo(@NotNull Key<?> that) {
+    if(myProcessingWeight == that.myProcessingWeight) return myDataClass.compareTo(that.myDataClass);
+    return myProcessingWeight - that.myProcessingWeight;
+  }
+
+  @Override
   public String toString() {
-    return myDataClass;
+    int i = myDataClass.lastIndexOf('.');
+    return i > 0 ? myDataClass.substring(i + 1) : myDataClass;
   }
 }