1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
/*******************************************************************************
* Copyright (c) 2006, 2008 Wind River Systems, Inc. and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Markus Schorn - initial API and implementation
* Andrew Ferguson (Symbian)
*******************************************************************************/
package org.eclipse.cdt.internal.core.index;
import java.util.Collection;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.ast.IASTPreprocessorStatement;
import org.eclipse.cdt.core.index.IIndexFile;
import org.eclipse.cdt.core.index.IIndexFileLocation;
import org.eclipse.cdt.internal.core.pdom.ASTFilePathResolver;
import org.eclipse.core.runtime.CoreException;
public class WritableCIndex extends CIndex implements IWritableIndex {
final private IWritableIndexFragment fWritableFragment;
private boolean fIsWriteLocked= false;
public WritableCIndex(IWritableIndexFragment writable, IIndexFragment[] readonly) {
super (concat(writable, readonly));
fWritableFragment= writable;
}
private static IIndexFragment[] concat(IIndexFragment writable, IIndexFragment[] readonly) {
IIndexFragment[] result= new IIndexFragment[1 + readonly.length];
result[0]= writable;
System.arraycopy(readonly, 0, result, 1, readonly.length);
return result;
}
public IWritableIndexFragment getWritableFragment() {
return fWritableFragment;
}
public IIndexFragmentFile getWritableFile(int linkageID, IIndexFileLocation location) throws CoreException {
return fWritableFragment.getFile(linkageID, location);
}
public IIndexFragmentFile[] getWritableFiles(IIndexFileLocation location) throws CoreException {
return fWritableFragment.getFiles(location);
}
public IIndexFragmentFile addFile(int linkageID, IIndexFileLocation fileLocation) throws CoreException {
return fWritableFragment.addFile(linkageID, fileLocation);
}
private boolean isWritableFragment(IIndexFragment frag) {
return frag == fWritableFragment;
}
public void setFileContent(IIndexFragmentFile file, int linkageID,
IncludeInformation[] includes,
IASTPreprocessorStatement[] macros, IASTName[][] names, ASTFilePathResolver resolver) throws CoreException {
IIndexFragment indexFragment = file.getIndexFragment();
if (!isWritableFragment(indexFragment)) {
assert false : "Attempt to update file of read-only fragment"; //$NON-NLS-1$
}
else {
for (IncludeInformation ii : includes) {
if (ii.fLocation != null) {
ii.fTargetFile= addFile(linkageID, ii.fLocation);
}
}
((IWritableIndexFragment) indexFragment).addFileContent(file, includes, macros, names, resolver);
}
}
public void clear() throws CoreException {
fWritableFragment.clear();
}
public boolean isWritableFile(IIndexFile file) {
return file instanceof IIndexFragmentFile &&
isWritableFragment(((IIndexFragmentFile)file).getIndexFragment());
}
public void clearFile(IIndexFragmentFile file, Collection<IIndexFileLocation> clearedContexts) throws CoreException {
IIndexFragment indexFragment = file.getIndexFragment();
if (!isWritableFragment(indexFragment)) {
assert false : "Attempt to clear file of read-only fragment"; //$NON-NLS-1$
}
else {
((IWritableIndexFragment) indexFragment).clearFile(file, clearedContexts);
}
}
@Override
public synchronized void acquireReadLock() throws InterruptedException {
assert !fIsWriteLocked: "Read locks are not allowed while write-locked."; //$NON-NLS-1$
super.acquireReadLock();
}
@Override
public synchronized void releaseReadLock() {
assert !fIsWriteLocked: "Read locks are not allowed while write-locked."; //$NON-NLS-1$
super.releaseReadLock();
}
public synchronized void acquireWriteLock(int giveupReadlockCount) throws InterruptedException {
assert !fIsWriteLocked: "Multiple write locks is not allowed"; //$NON-NLS-1$
assert giveupReadlockCount == getReadLockCount(): "Unexpected read lock is not allowed"; //$NON-NLS-1$
fWritableFragment.acquireWriteLock(giveupReadlockCount);
fIsWriteLocked= true;
}
public synchronized void releaseWriteLock(int establishReadlockCount) {
releaseWriteLock(establishReadlockCount, true);
}
public synchronized void releaseWriteLock(int establishReadlockCount, boolean flush) {
assert fIsWriteLocked: "No write lock to be released"; //$NON-NLS-1$
assert establishReadlockCount == getReadLockCount(): "Unexpected read lock is not allowed"; //$NON-NLS-1$
fIsWriteLocked= false;
fWritableFragment.releaseWriteLock(establishReadlockCount, flush);
}
public void flush() throws CoreException {
assert !fIsWriteLocked;
fWritableFragment.flush();
}
/* (non-Javadoc)
* @see org.eclipse.cdt.internal.core.index.IWritableIndex#getDatabaseSizeBytes()
*/
public long getDatabaseSizeBytes() {
return fWritableFragment.getDatabaseSizeBytes();
}
}
|
