IDEA-108938 External system: Provide ability to detach linked external project
[idea/community.git] / platform / external-system-api / src / com / intellij / openapi / externalSystem / model / Key.java
1 /*
2  * Copyright 2000-2013 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.openapi.externalSystem.model;
17
18 import org.jetbrains.annotations.NotNull;
19
20 import java.io.Serializable;
21
22 /**
23  * The basic design of external system integration assumes that target project info if represented as a generic graph
24  * of {@link DataNode} objects where every {@link DataNode} content type is identified by an instance of this class.
25  * <p/>
26  * That makes it possible to register custom {@link DataNode} processor per-{@link Key}
27  * <p/>
28  * Thread-safe.
29  * 
30  * @author Denis Zhdanov
31  * @since 4/12/13 11:49 AM
32  * @param <T>  data class
33  */
34 @SuppressWarnings("UnusedDeclaration")
35 public class Key<T> implements Serializable, Comparable<Key<?>> {
36
37   private static final long serialVersionUID = 1L;
38   
39   @NotNull private final String myDataClass;
40   
41   private final int myProcessingWeight;
42
43   /**
44    * Creates new <code>Key</code> object.
45    * 
46    * @param dataClass         class of the payload data which will be associated with the current key
47    * @param processingWeight  there is a possible case that when a {@link DataNode} object has children of more than on type (children
48    *                          with more than one different {@link Key} we might want to process one type of children before another.
49    *                          That's why we need a way to define that processing order. This parameter serves exactly for that -
50    *                          lower value means that key's payload should be processed <b>before</b> payload of the key with a greater
51    *                          value
52    */
53   public Key(@NotNull String dataClass, int processingWeight) {
54     myDataClass = dataClass;
55     myProcessingWeight = processingWeight;
56   }
57
58   @NotNull
59   public static <T> Key<T> create(@NotNull Class<T> dataClass, int processingWeight) {
60     return new Key<T>(dataClass.getName(), processingWeight);
61   }
62
63   /**
64    * There is a possible case that when a {@link DataNode} object has children of more than on type (children with more than
65    * one different {@link Key} we might want to process one type of children before another. That's why we need a way to define
66    * that processing order. This property serves exactly for that - lower value means that key's payload should be processed
67    * <b>before</b> payload of the key with a greater value.
68    * 
69    * @return    processing weight for data associated with the current key
70    */
71   public int getProcessingWeight() {
72     return myProcessingWeight;
73   }
74
75   @Override
76   public int hashCode() {
77     return myDataClass.hashCode();
78   }
79
80   @Override
81   public boolean equals(Object o) {
82     if (this == o) return true;
83     if (o == null || getClass() != o.getClass()) return false;
84
85     Key key = (Key)o;
86
87     if (!myDataClass.equals(key.myDataClass)) return false;
88
89     return true;
90   }
91
92   @Override
93   public int compareTo(@NotNull Key<?> that) {
94     return myProcessingWeight - that.myProcessingWeight;
95   }
96
97   @Override
98   public String toString() {
99     int i = myDataClass.lastIndexOf('.');
100     return i > 0 ? myDataClass.substring(i + 1) : myDataClass;
101   }
102 }