← Back to branch summary

~ubuntu-branches/debian/sid/eclipse-cdt/sid

« back to all changes in this revision

Viewing changes to core/org.eclipse.cdt.core/model/org/eclipse/cdt/core/settings/model/util/KindBasedStore.java

  • Committer: Package Import Robot
  • Author(s): Jakub Adam
  • Date: 2011-10-06 21:15:04 UTC
  • mfrom: (1.1.4)
  • Revision ID: package-import@ubuntu.com-20111006211504-8dutmljjih0zikfv
Tags: 8.0.1-1
* New upstream release.
* Split the JNI packages into a separate architecture dependent
  package and made eclipse-cdt architecture independent.
* Install JNI libraries into multiarch aware location
* Bumped Standards-Version to 3.9.2.

Show diffs side-by-side

added added

removed removed

Lines of Context:
core/org.eclipse.cdt.core/model/org/eclipse/cdt/core/settings/model/util/KindBasedStore.java
 
1
/*******************************************************************************
 
2
 * Copyright (c) 2007, 2010 Intel Corporation and others.
 
3
 * All rights reserved. This program and the accompanying materials
 
4
 * are made available under the terms of the Eclipse Public License v1.0
 
5
 * which accompanies this distribution, and is available at
 
6
 * http://www.eclipse.org/legal/epl-v10.html
 
7
 *
 
8
 * Contributors:
 
9
 * Intel Corporation - Initial API and implementation
 
10
 *******************************************************************************/
 
11
package org.eclipse.cdt.core.settings.model.util;
 
12
 
 
13
import org.eclipse.cdt.core.settings.model.ICLanguageSettingEntry;
 
14
import org.eclipse.cdt.core.settings.model.ICSettingEntry;
 
15
 
 
16
/**
 
17
 * A storage where stored data is organized by "kind".
 
18
 * In most cases kind is one of {@link ICLanguageSettingEntry}, i.e. include path, macro etc.
 
19
 * 
 
20
 * @param <T> - stored type
 
21
 * 
 
22
 * @see ICSettingEntry#INCLUDE_PATH
 
23
 * @see ICSettingEntry#INCLUDE_FILE
 
24
 * @see ICSettingEntry#MACRO
 
25
 * @see ICSettingEntry#MACRO_FILE
 
26
 * @see ICSettingEntry#LIBRARY_PATH
 
27
 * @see ICSettingEntry#LIBRARY_FILE
 
28
 * @see ICSettingEntry#OUTPUT_PATH
 
29
 * @see ICSettingEntry#SOURCE_PATH
 
30
 *
 
31
 */
 
32
public class KindBasedStore<T> implements Cloneable {
 
33
        private static final int INDEX_INCLUDE_PATH = 0;
 
34
        private static final int INDEX_INCLUDE_FILE = 1;
 
35
        private static final int INDEX_MACRO = 2;
 
36
        private static final int INDEX_MACRO_FILE = 3;
 
37
        private static final int INDEX_LIBRARY_PATH = 4;
 
38
        private static final int INDEX_LIBRARY_FILE = 5;
 
39
        private static final int LANG_STORAGE_SIZE = 6;
 
40
 
 
41
        private static final int INDEX_SOURCE_PATH = 6;
 
42
        private static final int INDEX_OUPUT_PATH = 7;
 
43
        private static final int ALL_STORAGE_SIZE = 8;
 
44
        
 
45
        public static final int ORED_LANG_ENTRY_KINDS = 
 
46
                ICLanguageSettingEntry.INCLUDE_PATH
 
47
                | ICLanguageSettingEntry.INCLUDE_FILE
 
48
                | ICLanguageSettingEntry.MACRO
 
49
                | ICLanguageSettingEntry.MACRO_FILE
 
50
                | ICLanguageSettingEntry.LIBRARY_PATH
 
51
                | ICLanguageSettingEntry.LIBRARY_FILE;
 
52
 
 
53
        public static final int ORED_ALL_ENTRY_KINDS = 
 
54
                ICLanguageSettingEntry.INCLUDE_PATH
 
55
                | ICLanguageSettingEntry.INCLUDE_FILE
 
56
                | ICLanguageSettingEntry.MACRO
 
57
                | ICLanguageSettingEntry.MACRO_FILE
 
58
                | ICLanguageSettingEntry.LIBRARY_PATH
 
59
                | ICLanguageSettingEntry.LIBRARY_FILE
 
60
                | ICLanguageSettingEntry.SOURCE_PATH
 
61
                | ICLanguageSettingEntry.OUTPUT_PATH;
 
62
        
 
63
        private static final int LANG_ENTRY_KINDS[] = new int[]{
 
64
                ICLanguageSettingEntry.INCLUDE_PATH,
 
65
                ICLanguageSettingEntry.INCLUDE_FILE,
 
66
                ICLanguageSettingEntry.MACRO,
 
67
                ICLanguageSettingEntry.MACRO_FILE,
 
68
                ICLanguageSettingEntry.LIBRARY_PATH,
 
69
                ICLanguageSettingEntry.LIBRARY_FILE,
 
70
        };
 
71
 
 
72
        private static final int ALL_ENTRY_KINDS[] = new int[]{
 
73
                ICLanguageSettingEntry.INCLUDE_PATH,
 
74
                ICLanguageSettingEntry.INCLUDE_FILE,
 
75
                ICLanguageSettingEntry.MACRO,
 
76
                ICLanguageSettingEntry.MACRO_FILE,
 
77
                ICLanguageSettingEntry.LIBRARY_PATH,
 
78
                ICLanguageSettingEntry.LIBRARY_FILE,
 
79
                ICLanguageSettingEntry.SOURCE_PATH,
 
80
                ICLanguageSettingEntry.OUTPUT_PATH,
 
81
        };
 
82
 
 
83
//      private static final int INEXISTENT_INDEX = -1;
 
84
        
 
85
        private Object[] fEntryStorage;
 
86
 
 
87
        public KindBasedStore(){
 
88
                this(true);
 
89
        }
 
90
 
 
91
        public KindBasedStore(boolean langOnly){
 
92
                if(langOnly)
 
93
                        fEntryStorage = new Object[LANG_STORAGE_SIZE];
 
94
                else
 
95
                        fEntryStorage = new Object[ALL_STORAGE_SIZE];
 
96
        }
 
97
 
 
98
        private int kindToIndex(int kind){
 
99
                switch (kind){
 
100
                case ICLanguageSettingEntry.INCLUDE_PATH:
 
101
                        return INDEX_INCLUDE_PATH;
 
102
                case ICLanguageSettingEntry.INCLUDE_FILE:
 
103
                        return INDEX_INCLUDE_FILE;
 
104
                case ICLanguageSettingEntry.MACRO:
 
105
                        return INDEX_MACRO;
 
106
                case ICLanguageSettingEntry.MACRO_FILE:
 
107
                        return INDEX_MACRO_FILE;
 
108
                case ICLanguageSettingEntry.LIBRARY_PATH:
 
109
                        return INDEX_LIBRARY_PATH;
 
110
                case ICLanguageSettingEntry.LIBRARY_FILE:
 
111
                        return INDEX_LIBRARY_FILE;
 
112
                case ICSettingEntry.SOURCE_PATH:
 
113
                        if(INDEX_SOURCE_PATH < fEntryStorage.length)
 
114
                                return INDEX_SOURCE_PATH;
 
115
                        break;
 
116
                case ICSettingEntry.OUTPUT_PATH:
 
117
                        if(INDEX_OUPUT_PATH < fEntryStorage.length)
 
118
                                return INDEX_OUPUT_PATH;
 
119
                        break;
 
120
                }
 
121
                throw new IllegalArgumentException(UtilMessages.getString("KindBasedStore.0")); //$NON-NLS-1$
 
122
        }
 
123
 
 
124
        public static int[] getLanguageEntryKinds(){
 
125
                return LANG_ENTRY_KINDS.clone();
 
126
        }
 
127
 
 
128
        public static int[] getAllEntryKinds(){
 
129
                return ALL_ENTRY_KINDS.clone();
 
130
        }
 
131
 
 
132
        private int indexToKind(int index){
 
133
                switch (index){
 
134
                case INDEX_INCLUDE_PATH:
 
135
                        return ICLanguageSettingEntry.INCLUDE_PATH;
 
136
                case INDEX_INCLUDE_FILE:
 
137
                        return ICLanguageSettingEntry.INCLUDE_FILE;
 
138
                case INDEX_MACRO:
 
139
                        return ICLanguageSettingEntry.MACRO;
 
140
                case INDEX_MACRO_FILE:
 
141
                        return ICLanguageSettingEntry.MACRO_FILE;
 
142
                case INDEX_LIBRARY_PATH:
 
143
                        return ICLanguageSettingEntry.LIBRARY_PATH;
 
144
                case INDEX_LIBRARY_FILE:
 
145
                        return ICLanguageSettingEntry.LIBRARY_FILE;
 
146
                case INDEX_SOURCE_PATH:
 
147
                        return ICSettingEntry.SOURCE_PATH;
 
148
                case INDEX_OUPUT_PATH:
 
149
                        return ICSettingEntry.OUTPUT_PATH;
 
150
                }
 
151
                throw new IllegalArgumentException(UtilMessages.getString("KindBasedStore.1")); //$NON-NLS-1$
 
152
        }
 
153
        @SuppressWarnings("unchecked")
 
154
        public T get(int kind){
 
155
                return (T) fEntryStorage[kindToIndex(kind)];
 
156
        }
 
157
 
 
158
        public T put(int kind, T object){
 
159
                int index = kindToIndex(kind);
 
160
                @SuppressWarnings("unchecked")
 
161
                T old = (T) fEntryStorage[index];
 
162
                fEntryStorage[index] = object;
 
163
                return old;
 
164
        }
 
165
        
 
166
        private class KindBasedInfo implements IKindBasedInfo<T> {
 
167
                int fIdex;
 
168
                int fKind;
 
169
                
 
170
                KindBasedInfo(int num, boolean isKind){
 
171
                        if(isKind){
 
172
                                fIdex = kindToIndex(num);
 
173
                                fKind = num;
 
174
                        } else {
 
175
                                fIdex = num;
 
176
                                fKind = indexToKind(num);
 
177
                        }
 
178
                }
 
179
        
 
180
                public T getInfo() {
 
181
                        @SuppressWarnings("unchecked")
 
182
                        T info = (T)fEntryStorage[fIdex];
 
183
                        return info;
 
184
                }
 
185
 
 
186
                public int getKind() {
 
187
                        return fKind;
 
188
                }
 
189
 
 
190
                public T setInfo(T newInfo) {
 
191
                        @SuppressWarnings("unchecked")
 
192
                        T old = (T)fEntryStorage[fIdex];
 
193
                        fEntryStorage[fIdex] = newInfo;
 
194
                        return old;
 
195
                }
 
196
                
 
197
        }
 
198
        
 
199
        public IKindBasedInfo<T>[] getContents(){
 
200
                @SuppressWarnings("unchecked")
 
201
                IKindBasedInfo<T> infos[] = new IKindBasedInfo[fEntryStorage.length];
 
202
                for(int i = 0; i < fEntryStorage.length; i++){
 
203
                        infos[i] = new KindBasedInfo(i, false);
 
204
                }
 
205
                return infos;
 
206
        }
 
207
        
 
208
        public IKindBasedInfo<T> getInfo(int kind){
 
209
                return new KindBasedInfo(kind, true);
 
210
        }
 
211
        
 
212
        public void clear(){
 
213
                for(int i = 0; i < fEntryStorage.length; i++){
 
214
                        fEntryStorage[i] = null;
 
215
                }
 
216
        }
 
217
 
 
218
        @Override
 
219
        public Object clone() {
 
220
                try {
 
221
                        @SuppressWarnings("unchecked")
 
222
                        KindBasedStore<T> clone = (KindBasedStore<T>)super.clone();
 
223
                        clone.fEntryStorage = fEntryStorage.clone();
 
224
                        return clone;
 
225
                } catch (CloneNotSupportedException e) {
 
226
                }
 
227
                return null;
 
228
        }
 
229
        
 
230
        
 
231
}