mirrors/cdt
1
0
Fork 0
mirror of https://github.com/eclipse-cdt/cdt synced 2025-07-24 01:15:29 +02:00
Code Issues Wiki Activity

2004-08-15 Alain Magloire

Browse source 
First draft, work in progress.
	Removing ResolveDelta to make the ResolverChange processing easier.
	* src/org/eclipse/cdt/core/filetype/IResolverChangeListener
	* src/org/eclipse/cdt/core/filetype/ResolverChangeEvent.java
	* src/org/eclipse/cdt/core/internal/filetype/CFiletTypeResolver.java
	* src/org/eclipse/cdt/core/internal/filetype/ResolverModel.java
This commit is contained in:
Alain Magloire 2004-08-16 04:03:53 +00:00
parent 2752f103f9
commit 0df0f3cbdd
9 changed files with 526 additions and 554 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

571
core/org.eclipse.cdt.core.tests/misc/org/eclipse/cdt/core/filetype/tests/ResolverTests.java
View file

@ -25,7 +25,6 @@ import org.eclipse.cdt.core.filetype.ICLanguage;
import org.eclipse.cdt.core.filetype.IResolverChangeListener;
import org.eclipse.cdt.core.filetype.IResolverModel;
import org.eclipse.cdt.core.filetype.ResolverChangeEvent;
import org.eclipse.cdt.core.filetype.ResolverDelta;
import org.eclipse.cdt.core.internal.filetype.CFileType;
import org.eclipse.cdt.core.internal.filetype.CFileTypeAssociation;
import org.eclipse.cdt.core.internal.filetype.CFileTypeResolver;
@ -43,27 +42,27 @@ public class ResolverTests extends TestCase {
private ICFileTypeResolver workspaceResolver;
private ICFileTypeResolver projectResolver;
private IResolverModel model;
protected IResolverModel model;
private static IProject project;
private static final String PLUGIN_ID = "org.eclipse.cdt.core.filetype.tests";
private static final String LANG_TEST = PLUGIN_ID + ".test";
private static final String FT_TEST_HEADER = LANG_TEST + ".header";
private static final String FT_TEST_SOURCE = LANG_TEST + ".source";
private static final String FT_TEST_WHASAT = LANG_TEST + ".unknown";
private static final String PLUGIN_ID = "org.eclipse.cdt.core.filetype.tests"; //$NON-NLS-1$
private static final String LANG_TEST = PLUGIN_ID + ".test"; //$NON-NLS-1$
private static final String FT_TEST_HEADER = LANG_TEST + ".header"; //$NON-NLS-1$
private static final String FT_TEST_SOURCE = LANG_TEST + ".source"; //$NON-NLS-1$
private static final String FT_TEST_WHASAT = LANG_TEST + ".unknown"; //$NON-NLS-1$
public static Test suite() {
TestSuite suite = new TestSuite(ResolverTests.class.getName());
suite.addTest(new ResolverTests("testInternalCtors"));
suite.addTest(new ResolverTests("testDefaultFileTypeResolution"));
suite.addTest(new ResolverTests("testWorkspaceFileTypeResolution"));
suite.addTest(new ResolverTests("testProjectFileTypeResolution"));
suite.addTest(new ResolverTests("testGetLanguages"));
suite.addTest(new ResolverTests("testGetTypes"));
suite.addTest(new ResolverTests("testGetFileTypeAssociations"));
suite.addTest(new ResolverTests("testAdd"));
suite.addTest(new ResolverTests("testRemove"));
suite.addTest(new ResolverTests("testChangeNotifications"));
suite.addTest(new ResolverTests("testInternalCtors")); //$NON-NLS-1$
suite.addTest(new ResolverTests("testDefaultFileTypeResolution")); //$NON-NLS-1$
suite.addTest(new ResolverTests("testWorkspaceFileTypeResolution")); //$NON-NLS-1$
suite.addTest(new ResolverTests("testProjectFileTypeResolution")); //$NON-NLS-1$
suite.addTest(new ResolverTests("testGetLanguages")); //$NON-NLS-1$
suite.addTest(new ResolverTests("testGetTypes")); //$NON-NLS-1$
suite.addTest(new ResolverTests("testGetFileTypeAssociations")); //$NON-NLS-1$
suite.addTest(new ResolverTests("testAdd")); //$NON-NLS-1$
suite.addTest(new ResolverTests("testRemove")); //$NON-NLS-1$
suite.addTest(new ResolverTests("testChangeNotifications")); //$NON-NLS-1$
TestSetup wrapper = new TestSetup(suite) {
protected void setUp() throws Exception {
@ -89,7 +88,7 @@ public class ResolverTests extends TestCase {
static void oneTimeSetUp() throws Exception {
IWorkspaceRoot root = CTestPlugin.getWorkspace().getRoot();
IProject project = root.getProject("testResolverProject");
IProject project = root.getProject("testResolverProject"); //$NON-NLS-1$
if (!project.exists()) {
project.create(null);
} else {
@ -160,38 +159,38 @@ public class ResolverTests extends TestCase {
assertNull(lang);
try {
lang = new CLanguage(LANG_TEST, "");
lang = new CLanguage(LANG_TEST, ""); //$NON-NLS-1$
} catch (IllegalArgumentException e) {
}
assertNull(lang);
try {
lang = new CLanguage(null, "L");
lang = new CLanguage(null, "L"); //$NON-NLS-1$
} catch (IllegalArgumentException e) {
}
assertNull(lang);
try {
lang = new CLanguage("", "L");
lang = new CLanguage("", "L"); //$NON-NLS-1$ //$NON-NLS-2$
} catch (IllegalArgumentException e) {
}
assertNull(lang);
lang = new CLanguage(LANG_TEST, "Test Language");
lang = new CLanguage(LANG_TEST, "Test Language"); //$NON-NLS-1$
assertNotNull(lang);
// File type
// str id, cls lang, str name, int type
try {
type = new CFileType(FT_TEST_HEADER, lang, "T", -1);
type = new CFileType(FT_TEST_HEADER, lang, "T", -1); //$NON-NLS-1$
} catch (IllegalArgumentException e) {
}
assertNull(type);
try {
type = new CFileType(FT_TEST_HEADER, lang, "T", 0x04091998);
type = new CFileType(FT_TEST_HEADER, lang, "T", 0x04091998); //$NON-NLS-1$
} catch (IllegalArgumentException e) {
}
assertNull(type);
@ -203,36 +202,36 @@ public class ResolverTests extends TestCase {
assertNull(type);
try {
type = new CFileType(FT_TEST_HEADER, lang, "", ICFileType.TYPE_HEADER);
type = new CFileType(FT_TEST_HEADER, lang, "", ICFileType.TYPE_HEADER); //$NON-NLS-1$
} catch (IllegalArgumentException e) {
}
assertNull(type);
try {
type = new CFileType(FT_TEST_HEADER, null, "T", ICFileType.TYPE_HEADER);
type = new CFileType(FT_TEST_HEADER, null, "T", ICFileType.TYPE_HEADER); //$NON-NLS-1$
} catch (IllegalArgumentException e) {
}
assertNull(type);
try {
type = new CFileType(null, lang, "T", ICFileType.TYPE_HEADER);
type = new CFileType(null, lang, "T", ICFileType.TYPE_HEADER); //$NON-NLS-1$
} catch (IllegalArgumentException e) {
}
assertNull(type);
try {
type = new CFileType("", lang, "T", ICFileType.TYPE_HEADER);
type = new CFileType("", lang, "T", ICFileType.TYPE_HEADER); //$NON-NLS-1$ //$NON-NLS-2$
} catch (IllegalArgumentException e) {
}
assertNull(type);
type = new CFileType(FT_TEST_HEADER, lang, "T", ICFileType.TYPE_HEADER);
type = new CFileType(FT_TEST_HEADER, lang, "T", ICFileType.TYPE_HEADER); //$NON-NLS-1$
assertNotNull(type);
// Association
try {
assoc = new CFileTypeAssociation("*.xyz", null);
assoc = new CFileTypeAssociation("*.xyz", null); //$NON-NLS-1$
} catch (IllegalArgumentException e) {
}
assertNull(assoc);
@ -244,12 +243,12 @@ public class ResolverTests extends TestCase {
assertNull(assoc);
try {
assoc = new CFileTypeAssociation("", type);
assoc = new CFileTypeAssociation("", type); //$NON-NLS-1$
} catch (IllegalArgumentException e) {
}
assertNull(assoc);
assoc = new CFileTypeAssociation("*.xyz", type);
assoc = new CFileTypeAssociation("*.xyz", type); //$NON-NLS-1$
assertNotNull(assoc);
}
@ -273,88 +272,88 @@ public class ResolverTests extends TestCase {
public final void testDefaultFileTypeResolution() {
// - Null string, Empty string, Strings w/spaces
doTestFileTypeResolution(workspaceResolver, null, ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, " ", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, " ", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
// Odd filenames
doTestFileTypeResolution(workspaceResolver, ".", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, ".c.", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, ".cpp.", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "file.c.", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "file.cpp.", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "file.c.input", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "file.cpp.input", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "c", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "cpp", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "numerical", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "some/path/file.c", ICFileTypeConstants.FT_C_SOURCE);
doTestFileTypeResolution(workspaceResolver, "some/path/file.cpp", ICFileTypeConstants.FT_CXX_SOURCE);
doTestFileTypeResolution(workspaceResolver, ".", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, ".c.", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, ".cpp.", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.c.", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.cpp.", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.c.input", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.cpp.input", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "c", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "cpp", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "numerical", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "some/path/file.c", ICFileTypeConstants.FT_C_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "some/path/file.cpp", ICFileTypeConstants.FT_CXX_SOURCE); //$NON-NLS-1$
// C source/header
doTestFileTypeResolution(workspaceResolver, "file.c", ICFileTypeConstants.FT_C_SOURCE);
doTestFileTypeResolution(workspaceResolver, "file.h", ICFileTypeConstants.FT_C_HEADER);
doTestFileTypeResolution(workspaceResolver, "some.file.c", ICFileTypeConstants.FT_C_SOURCE);
doTestFileTypeResolution(workspaceResolver, "some.file.h", ICFileTypeConstants.FT_C_HEADER);
doTestFileTypeResolution(workspaceResolver, "file.c", ICFileTypeConstants.FT_C_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.h", ICFileTypeConstants.FT_C_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "some.file.c", ICFileTypeConstants.FT_C_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "some.file.h", ICFileTypeConstants.FT_C_HEADER); //$NON-NLS-1$
// C++ source/header
doTestFileTypeResolution(workspaceResolver, "file.cpp", ICFileTypeConstants.FT_CXX_SOURCE);
doTestFileTypeResolution(workspaceResolver, "file.cxx", ICFileTypeConstants.FT_CXX_SOURCE);
doTestFileTypeResolution(workspaceResolver, "file.cc", ICFileTypeConstants.FT_CXX_SOURCE);
doTestFileTypeResolution(workspaceResolver, "file.C", ICFileTypeConstants.FT_CXX_SOURCE);
doTestFileTypeResolution(workspaceResolver, "file.hpp", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "file.hxx", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "file.hh", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "file.H", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "some.file.cpp", ICFileTypeConstants.FT_CXX_SOURCE);
doTestFileTypeResolution(workspaceResolver, "some.file.hxx", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "file.cpp", ICFileTypeConstants.FT_CXX_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.cxx", ICFileTypeConstants.FT_CXX_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.cc", ICFileTypeConstants.FT_CXX_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.C", ICFileTypeConstants.FT_CXX_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.hpp", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.hxx", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.hh", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.H", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "some.file.cpp", ICFileTypeConstants.FT_CXX_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "some.file.hxx", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
// Assembly
doTestFileTypeResolution(workspaceResolver, "file.asm", ICFileTypeConstants.FT_ASM_SOURCE);
doTestFileTypeResolution(workspaceResolver, "file.s", ICFileTypeConstants.FT_ASM_SOURCE);
doTestFileTypeResolution(workspaceResolver, "file.S", ICFileTypeConstants.FT_ASM_SOURCE);
doTestFileTypeResolution(workspaceResolver, "file.asm", ICFileTypeConstants.FT_ASM_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.s", ICFileTypeConstants.FT_ASM_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.S", ICFileTypeConstants.FT_ASM_SOURCE); //$NON-NLS-1$
// Std C++ library
doTestFileTypeResolution(workspaceResolver, "algorithm", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "bitset", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "deque", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "exception", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "fstream", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "functional", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "iomanip", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "ios", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "iosfwd", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "iostream", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "istream", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "iterator", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "limits", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "list", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "locale", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "map", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "memory", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "new", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "numeric", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "ostream", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "queue", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "set", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "sstream", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "stack", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "stdexcept", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "streambuf", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "string", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "typeinfo", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "utility", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "valarray", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "vector", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "algorithm", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "bitset", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "deque", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "exception", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "fstream", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "functional", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "iomanip", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "ios", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "iosfwd", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "iostream", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "istream", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "iterator", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "limits", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "list", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "locale", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "map", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "memory", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "new", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "numeric", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "ostream", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "queue", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "set", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "sstream", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "stack", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "stdexcept", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "streambuf", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "string", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "typeinfo", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "utility", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "valarray", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "vector", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
// Failure cases
doTestFileTypeResolution(workspaceResolver, "file.txt", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "file.doc", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "files", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "FILES", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "stream", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "streambu", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "streambuff", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "sstreams", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "file.txt", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.doc", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "files", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "FILES", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "stream", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "streambu", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "streambuff", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "sstreams", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
}
public final void testWorkspaceFileTypeResolution() {
@ -364,55 +363,55 @@ public class ResolverTests extends TestCase {
workspaceResolver = model.getResolver();
// Validate that we are using the default resolver set...
doTestFileTypeResolution(workspaceResolver, "file.c", ICFileTypeConstants.FT_C_SOURCE);
doTestFileTypeResolution(workspaceResolver, "file.h", ICFileTypeConstants.FT_C_HEADER);
doTestFileTypeResolution(workspaceResolver, "file.cpp", ICFileTypeConstants.FT_CXX_SOURCE);
doTestFileTypeResolution(workspaceResolver, "file.hpp", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "file.s", ICFileTypeConstants.FT_ASM_SOURCE);
doTestFileTypeResolution(workspaceResolver, "file.sam", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "file.shari", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "file.delainey", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "file.c", ICFileTypeConstants.FT_C_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.h", ICFileTypeConstants.FT_C_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.cpp", ICFileTypeConstants.FT_CXX_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.hpp", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.s", ICFileTypeConstants.FT_ASM_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.sam", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.shari", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.delainey", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
// Set up a new resolver just for the tests
// This one will only recognize '*.c', '*.h', and '*.sam'
ICFileTypeResolver resolver = createResolver();
resolver.addAssociation(model.createAssocation("*.sam", model.getFileTypeById(ICFileTypeConstants.FT_C_SOURCE)));
resolver.addAssociation(model.createAssocation("*.shari", model.getFileTypeById(ICFileTypeConstants.FT_C_HEADER)));
resolver.addAssociation(model.createAssocation("*.delainey", model.getFileTypeById(ICFileTypeConstants.FT_ASM_SOURCE)));
resolver.addAssociation(model.createAssocation("*.sam", model.getFileTypeById(ICFileTypeConstants.FT_C_SOURCE))); //$NON-NLS-1$
resolver.addAssociation(model.createAssocation("*.shari", model.getFileTypeById(ICFileTypeConstants.FT_C_HEADER))); //$NON-NLS-1$
resolver.addAssociation(model.createAssocation("*.delainey", model.getFileTypeById(ICFileTypeConstants.FT_ASM_SOURCE))); //$NON-NLS-1$
// Set the workspace to use the new resolver
model.setResolver(resolver);
workspaceResolver = model.getResolver();
// Test the known types
doTestFileTypeResolution(workspaceResolver, "file.sam", ICFileTypeConstants.FT_C_SOURCE);
doTestFileTypeResolution(workspaceResolver, "file.shari", ICFileTypeConstants.FT_C_HEADER);
doTestFileTypeResolution(workspaceResolver, "file.delainey", ICFileTypeConstants.FT_ASM_SOURCE);
doTestFileTypeResolution(workspaceResolver, "some.file.sam", ICFileTypeConstants.FT_C_SOURCE);
doTestFileTypeResolution(workspaceResolver, "some.file.shari", ICFileTypeConstants.FT_C_HEADER);
doTestFileTypeResolution(workspaceResolver, "some.file.delainey", ICFileTypeConstants.FT_ASM_SOURCE);
doTestFileTypeResolution(workspaceResolver, "file.sam", ICFileTypeConstants.FT_C_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.shari", ICFileTypeConstants.FT_C_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.delainey", ICFileTypeConstants.FT_ASM_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "some.file.sam", ICFileTypeConstants.FT_C_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "some.file.shari", ICFileTypeConstants.FT_C_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "some.file.delainey", ICFileTypeConstants.FT_ASM_SOURCE); //$NON-NLS-1$
// Failure cases
doTestFileTypeResolution(workspaceResolver, "file.c", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "file.h", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "file.cpp", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "file.hpp", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "file.s", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "file.c", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.h", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.cpp", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.hpp", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.s", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
// Reset the resolver
model.setResolver(null);
workspaceResolver = model.getResolver();
// Validate that we are back to using the default resolver set...
doTestFileTypeResolution(workspaceResolver, "file.c", ICFileTypeConstants.FT_C_SOURCE);
doTestFileTypeResolution(workspaceResolver, "file.h", ICFileTypeConstants.FT_C_HEADER);
doTestFileTypeResolution(workspaceResolver, "file.cpp", ICFileTypeConstants.FT_CXX_SOURCE);
doTestFileTypeResolution(workspaceResolver, "file.hpp", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(workspaceResolver, "file.s", ICFileTypeConstants.FT_ASM_SOURCE);
doTestFileTypeResolution(workspaceResolver, "file.sam", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "file.shari", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "file.delainey", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(workspaceResolver, "file.c", ICFileTypeConstants.FT_C_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.h", ICFileTypeConstants.FT_C_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.cpp", ICFileTypeConstants.FT_CXX_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.hpp", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.s", ICFileTypeConstants.FT_ASM_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.sam", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.shari", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(workspaceResolver, "file.delainey", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
}
public final void testProjectFileTypeResolution() {
@ -425,54 +424,54 @@ public class ResolverTests extends TestCase {
projectResolver = model.getResolver(project);
// Validate that we are using the default resolver set...
doTestFileTypeResolution(projectResolver, "file.c", ICFileTypeConstants.FT_C_SOURCE);
doTestFileTypeResolution(projectResolver, "file.cpp", ICFileTypeConstants.FT_CXX_SOURCE);
doTestFileTypeResolution(projectResolver, "file.hpp", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(projectResolver, "file.s", ICFileTypeConstants.FT_ASM_SOURCE);
doTestFileTypeResolution(projectResolver, "file.sam", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(projectResolver, "file.shari", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(projectResolver, "file.delainey", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(projectResolver, "file.c", ICFileTypeConstants.FT_C_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.cpp", ICFileTypeConstants.FT_CXX_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.hpp", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.s", ICFileTypeConstants.FT_ASM_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.sam", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.shari", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.delainey", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
// Set up a new resolver just for the tests
// This one will only recognize '*.c', '*.h', and '*.sam'
ICFileTypeResolver resolver = createResolver();
resolver.addAssociation(model.createAssocation("*.sam", model.getFileTypeById(ICFileTypeConstants.FT_C_SOURCE)));
resolver.addAssociation(model.createAssocation("*.shari", model.getFileTypeById(ICFileTypeConstants.FT_C_HEADER)));
resolver.addAssociation(model.createAssocation("*.delainey", model.getFileTypeById(ICFileTypeConstants.FT_ASM_SOURCE)));
resolver.addAssociation(model.createAssocation("*.sam", model.getFileTypeById(ICFileTypeConstants.FT_C_SOURCE))); //$NON-NLS-1$
resolver.addAssociation(model.createAssocation("*.shari", model.getFileTypeById(ICFileTypeConstants.FT_C_HEADER))); //$NON-NLS-1$
resolver.addAssociation(model.createAssocation("*.delainey", model.getFileTypeById(ICFileTypeConstants.FT_ASM_SOURCE))); //$NON-NLS-1$
// Set the workspace to use the new resolver
model.setResolver(project, resolver);
projectResolver = model.getResolver(project);
// Test the known types
doTestFileTypeResolution(projectResolver, "file.sam", ICFileTypeConstants.FT_C_SOURCE);
doTestFileTypeResolution(projectResolver, "file.shari", ICFileTypeConstants.FT_C_HEADER);
doTestFileTypeResolution(projectResolver, "file.delainey", ICFileTypeConstants.FT_ASM_SOURCE);
doTestFileTypeResolution(projectResolver, "some.file.sam", ICFileTypeConstants.FT_C_SOURCE);
doTestFileTypeResolution(projectResolver, "some.file.shari", ICFileTypeConstants.FT_C_HEADER);
doTestFileTypeResolution(projectResolver, "some.file.delainey", ICFileTypeConstants.FT_ASM_SOURCE);
doTestFileTypeResolution(projectResolver, "file.sam", ICFileTypeConstants.FT_C_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.shari", ICFileTypeConstants.FT_C_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.delainey", ICFileTypeConstants.FT_ASM_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "some.file.sam", ICFileTypeConstants.FT_C_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "some.file.shari", ICFileTypeConstants.FT_C_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "some.file.delainey", ICFileTypeConstants.FT_ASM_SOURCE); //$NON-NLS-1$
// Failure cases
doTestFileTypeResolution(projectResolver, "file.c", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(projectResolver, "file.h", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(projectResolver, "file.cpp", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(projectResolver, "file.hpp", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(projectResolver, "file.s", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(projectResolver, "file.c", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.h", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.cpp", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.hpp", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.s", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
// Reset the resolver
model.setResolver(project, null);
projectResolver = model.getResolver(project);
// Validate that we are back to using the default resolver set...
doTestFileTypeResolution(projectResolver, "file.c", ICFileTypeConstants.FT_C_SOURCE);
doTestFileTypeResolution(projectResolver, "file.h", ICFileTypeConstants.FT_C_HEADER);
doTestFileTypeResolution(projectResolver, "file.cpp", ICFileTypeConstants.FT_CXX_SOURCE);
doTestFileTypeResolution(projectResolver, "file.hpp", ICFileTypeConstants.FT_CXX_HEADER);
doTestFileTypeResolution(projectResolver, "file.s", ICFileTypeConstants.FT_ASM_SOURCE);
doTestFileTypeResolution(projectResolver, "file.sam", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(projectResolver, "file.shari", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(projectResolver, "file.delainey", ICFileTypeConstants.FT_UNKNOWN);
doTestFileTypeResolution(projectResolver, "file.c", ICFileTypeConstants.FT_C_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.h", ICFileTypeConstants.FT_C_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.cpp", ICFileTypeConstants.FT_CXX_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.hpp", ICFileTypeConstants.FT_CXX_HEADER); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.s", ICFileTypeConstants.FT_ASM_SOURCE); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.sam", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.shari", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
doTestFileTypeResolution(projectResolver, "file.delainey", ICFileTypeConstants.FT_UNKNOWN); //$NON-NLS-1$
}
public final void testGetLanguages() {
@ -546,7 +545,7 @@ public class ResolverTests extends TestCase {
// Languages
ICLanguage langIn = new CLanguage(LANG_TEST, "Test Language");
ICLanguage langIn = new CLanguage(LANG_TEST, "Test Language"); //$NON-NLS-1$
result = ((ResolverModel) model).removeLanguage(langIn);
assertFalse(result);
@ -560,9 +559,9 @@ public class ResolverTests extends TestCase {
// File types
ICFileType th = new CFileType(FT_TEST_HEADER, langIn, "Test Language Header", ICFileType.TYPE_HEADER);
ICFileType ts = new CFileType(FT_TEST_SOURCE, langIn, "Test Language Source", ICFileType.TYPE_SOURCE);
ICFileType tu = new CFileType(FT_TEST_WHASAT, langIn, "Test Language Unknown", ICFileType.TYPE_UNKNOWN);
ICFileType th = new CFileType(FT_TEST_HEADER, langIn, "Test Language Header", ICFileType.TYPE_HEADER); //$NON-NLS-1$
ICFileType ts = new CFileType(FT_TEST_SOURCE, langIn, "Test Language Source", ICFileType.TYPE_SOURCE); //$NON-NLS-1$
ICFileType tu = new CFileType(FT_TEST_WHASAT, langIn, "Test Language Unknown", ICFileType.TYPE_UNKNOWN); //$NON-NLS-1$
// -- header
@ -602,9 +601,9 @@ public class ResolverTests extends TestCase {
// File type associations
ICFileTypeAssociation tha = new CFileTypeAssociation("*.aest", th);
ICFileTypeAssociation tsa = new CFileTypeAssociation("*.test", th);
ICFileTypeAssociation tua = new CFileTypeAssociation("*.zest", th);
ICFileTypeAssociation tha = new CFileTypeAssociation("*.aest", th); //$NON-NLS-1$
ICFileTypeAssociation tsa = new CFileTypeAssociation("*.test", th); //$NON-NLS-1$
ICFileTypeAssociation tua = new CFileTypeAssociation("*.zest", th); //$NON-NLS-1$
// -- header
@ -614,7 +613,7 @@ public class ResolverTests extends TestCase {
result = workspaceResolver.addAssociation(tha);
assertTrue(result);
ICFileType thaOut = workspaceResolver.getFileType("file.aest");
ICFileType thaOut = workspaceResolver.getFileType("file.aest"); //$NON-NLS-1$
assertNotNull(thaOut);
assertEquals(tha.getType(), thaOut);
@ -626,7 +625,7 @@ public class ResolverTests extends TestCase {
result = workspaceResolver.addAssociation(tsa);
assertTrue(result);
ICFileType tsaOut = workspaceResolver.getFileType("file.test");
ICFileType tsaOut = workspaceResolver.getFileType("file.test"); //$NON-NLS-1$
assertNotNull(tsaOut);
assertEquals(tsa.getType(), tsaOut);
@ -639,7 +638,7 @@ public class ResolverTests extends TestCase {
result = workspaceResolver.addAssociation(tua);
assertTrue(result);
ICFileType tuaOut = workspaceResolver.getFileType("file.zest");
ICFileType tuaOut = workspaceResolver.getFileType("file.zest"); //$NON-NLS-1$
assertNotNull(tuaOut);
assertEquals(tua.getType(), tuaOut);
}
@ -698,30 +697,28 @@ public class ResolverTests extends TestCase {
}
class TestModelListener implements IResolverChangeListener {
private ResolverChangeEvent fEvent;
private ResolverChangeEvent[] fEvents;
public TestModelListener() {
model.addResolverChangeListener(this);
}
public void resolverChanged(ResolverChangeEvent event) {
fEvent = event;
public void resolverChanged(ResolverChangeEvent[] events) {
fEvents = events;
model.removeResolverChangeListener(this);
this.notifyAll();
}
public ResolverChangeEvent getEvent() {
return fEvent;
public ResolverChangeEvent[] getEvents() {
return fEvents;
}
}
public final void testChangeNotifications() {
ResolverModel rawModel = ((ResolverModel) model);
ResolverChangeEvent event = null;
ICLanguage lang = new CLanguage(LANG_TEST, "Test Language");
ICFileType type = new CFileType("?", model.getLanguageById("?"), "?", ICFileType.TYPE_UNKNOWN);
ResolverChangeEvent[] events = null;
ICLanguage lang = new CLanguage(LANG_TEST, "Test Language"); //$NON-NLS-1$
ICFileType type = new CFileType("?", model.getLanguageById("?"), "?", ICFileType.TYPE_UNKNOWN); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
TestModelListener listener = null;
ResolverDelta[] deltas = null;
// Add language
// Add language
try {
listener = new TestModelListener();
synchronized (listener) {
@ -732,23 +729,20 @@ public class ResolverTests extends TestCase {
assertTrue(e.getMessage(), false);
}
assertNotNull(listener.getEvent());
event = listener.getEvent();
deltas = event.getDeltas();
events = listener.getEvents();
assertNotNull(events);
assertNull(event.getResolver());
assertEquals(1, deltas.length);
assertEquals(ResolverDelta.ELEMENT_LANGUAGE, deltas[0].getElementType());
assertEquals(ResolverDelta.EVENT_ADD, deltas[0].getEventType());
assertNotNull(deltas[0].getElement());
assertNull(deltas[0].getAssociation());
assertNotNull(deltas[0].getLanguage());
assertNull(deltas[0].getFileType());
assertNull(deltas[0].getProject());
assertEquals(1, events.length);
assertNotNull(events[0].getContainer());
assertEquals(ResolverChangeEvent.ELEMENT_LANGUAGE, events[0].getElementType());
assertEquals(ResolverChangeEvent.EVENT_ADD, events[0].getEventType());
assertNotNull(events[0].getElement());
//assertNull(deltas[0].getAssociation());
assertNotNull(events[0].getElement());
//assertNull(deltas[0].getFileType());
//assertNull(deltas[0].getProject());
// Repeated addition should not result in a change event
try {
listener = new TestModelListener();
synchronized (listener) {
@ -759,10 +753,9 @@ public class ResolverTests extends TestCase {
assertTrue(e.getMessage(), false);
}
assertNull(listener.getEvent());
assertNull(listener.getEvents());
// Remove language
try {
listener = new TestModelListener();
synchronized (listener) {
@ -773,23 +766,20 @@ public class ResolverTests extends TestCase {
assertTrue(e.getMessage(), false);
}
assertNotNull(listener.getEvent());
event = listener.getEvent();
deltas = event.getDeltas();
events = listener.getEvents();
assertNotNull(events);
assertNull(event.getResolver());
assertEquals(1, deltas.length);
assertEquals(ResolverDelta.ELEMENT_LANGUAGE, deltas[0].getElementType());
assertEquals(ResolverDelta.EVENT_REMOVE, deltas[0].getEventType());
assertNotNull(deltas[0].getElement());
assertNull(deltas[0].getAssociation());
assertNotNull(deltas[0].getLanguage());
assertNull(deltas[0].getFileType());
assertNull(deltas[0].getProject());
assertEquals(1, events.length);
assertNotNull(events[0].getContainer());
assertEquals(ResolverChangeEvent.ELEMENT_LANGUAGE, events[0].getElementType());
assertEquals(ResolverChangeEvent.EVENT_REMOVE, events[0].getEventType());
assertNotNull(events[0].getElement());
//assertNull(deltas[0].getAssociation());
//assertNotNull(deltas[0].getLanguage());
//assertNull(deltas[0].getFileType());
//assertNull(deltas[0].getProject());
// Repeated removal should not result in a change event
try {
listener = new TestModelListener();
synchronized (listener) {
@ -800,10 +790,9 @@ public class ResolverTests extends TestCase {
assertTrue(e.getMessage(), false);
}
assertNull(listener.getEvent());
assertNull(listener.getEvents());
// Add file type
try {
listener = new TestModelListener();
synchronized (listener) {
@ -814,23 +803,21 @@ public class ResolverTests extends TestCase {
assertTrue(e.getMessage(), false);
}
assertNotNull(listener.getEvent());
events = listener.getEvents();
assertNotNull(events);
event = listener.getEvent();
deltas = event.getDeltas();
assertNull(event.getResolver());
assertEquals(1, deltas.length);
assertEquals(ResolverDelta.ELEMENT_FILETYPE, deltas[0].getElementType());
assertEquals(ResolverDelta.EVENT_ADD, deltas[0].getEventType());
assertNotNull(deltas[0].getElement());
assertNull(deltas[0].getAssociation());
assertNull(deltas[0].getLanguage());
assertNotNull(deltas[0].getFileType());
assertNull(deltas[0].getProject());
assertEquals(1, events.length);
assertNotNull(events[0].getContainer());
assertEquals(ResolverChangeEvent.ELEMENT_FILETYPE, events[0].getElementType());
assertEquals(ResolverChangeEvent.EVENT_ADD, events[0].getEventType());
assertNotNull(events[0].getElement());
//assertNull(deltas[0].getAssociation());
//assertNull(deltas[0].getLanguage());
//assertNotNull(deltas[0].getFileType());
//assertNull(deltas[0].getProject());
// Repeated addition should not result in a change event
try {
listener = new TestModelListener();
synchronized (listener) {
@ -841,10 +828,9 @@ public class ResolverTests extends TestCase {
assertTrue(e.getMessage(), false);
}
assertNull(listener.getEvent());
assertNull(listener.getEvents());
// Remove file type
try {
listener = new TestModelListener();
synchronized (listener) {
@ -855,23 +841,21 @@ public class ResolverTests extends TestCase {
assertTrue(e.getMessage(), false);
}
assertNotNull(listener.getEvent());
events = listener.getEvents();
assertNotNull(events);
event = listener.getEvent();
deltas = event.getDeltas();
assertNull(event.getResolver());
assertEquals(1, deltas.length);
assertEquals(ResolverDelta.ELEMENT_FILETYPE, deltas[0].getElementType());
assertEquals(ResolverDelta.EVENT_REMOVE, deltas[0].getEventType());
assertNotNull(deltas[0].getElement());
assertNull(deltas[0].getAssociation());
assertNull(deltas[0].getLanguage());
assertNotNull(deltas[0].getFileType());
assertNull(deltas[0].getProject());
assertEquals(1, events.length);
assertNotNull(events[0].getContainer());
assertEquals(ResolverChangeEvent.ELEMENT_FILETYPE, events[0].getElementType());
assertEquals(ResolverChangeEvent.EVENT_REMOVE, events[0].getEventType());
assertNotNull(events[0].getElement());
//assertNull(deltas[0].getAssociation());
//assertNull(deltas[0].getLanguage());
//assertNotNull(deltas[0].getFileType());
//assertNull(deltas[0].getProject());
// Repeated removal should not result in a change event
try {
listener = new TestModelListener();
synchronized (listener) {
@ -882,10 +866,9 @@ public class ResolverTests extends TestCase {
assertTrue(e.getMessage(), false);
}
assertNull(listener.getEvent());
assertNull(listener.getEvents());
// Test setting workspace resolver
ICFileTypeResolver testResolver = createResolver();
try {
@ -898,23 +881,20 @@ public class ResolverTests extends TestCase {
assertTrue(e.getMessage(), false);
}
assertNotNull(listener.getEvent());
event = listener.getEvent();
deltas = event.getDeltas();
assertNotNull(event.getResolver());
assertTrue(deltas.length > 1);
assertEquals(ResolverDelta.ELEMENT_WORKSPACE, deltas[0].getElementType());
assertEquals(ResolverDelta.EVENT_SET, deltas[0].getEventType());
assertNull(deltas[0].getElement());
assertNull(deltas[0].getAssociation());
assertNull(deltas[0].getLanguage());
assertNull(deltas[0].getFileType());
assertNull(deltas[0].getProject());
events = listener.getEvents();
assertNotNull(events);
assertTrue(events.length > 1);
assertNotNull(events[0].getContainer());
assertEquals(ResolverChangeEvent.ELEMENT_RESOLVER, events[0].getElementType());
assertEquals(ResolverChangeEvent.EVENT_SET, events[0].getEventType());
assertNotNull(events[0].getElement());
//assertNull(deltas[0].getAssociation());
//assertNull(deltas[0].getLanguage());
//assertNull(deltas[0].getFileType());
//assertNull(deltas[0].getProject());
// Test resetting workspace resolver
try {
listener = new TestModelListener();
synchronized (listener) {
@ -925,23 +905,21 @@ public class ResolverTests extends TestCase {
assertTrue(e.getMessage(), false);
}
assertNotNull(listener.getEvent());
events = listener.getEvents();
assertNotNull(events);
event = listener.getEvent();
deltas = event.getDeltas();
assertNotNull(event.getResolver());
assertTrue(deltas.length > 1);
assertEquals(ResolverDelta.ELEMENT_WORKSPACE, deltas[0].getElementType());
assertEquals(ResolverDelta.EVENT_SET, deltas[0].getEventType());
assertNull(deltas[0].getElement());
assertNull(deltas[0].getAssociation());
assertNull(deltas[0].getLanguage());
assertNull(deltas[0].getFileType());
assertNull(deltas[0].getProject());
assertTrue(events.length > 1);
assertNotNull(events[0].getContainer());
assertEquals(ResolverChangeEvent.ELEMENT_RESOLVER, events[0].getElementType());
assertEquals(ResolverChangeEvent.EVENT_SET, events[0].getEventType());
assertNotNull(events[0].getElement());
//assertNull(deltas[0].getAssociation());
//assertNull(deltas[0].getLanguage());
//assertNull(deltas[0].getFileType());
//assertNull(deltas[0].getProject());
// Test setting project resolver
try {
listener = new TestModelListener();
synchronized (listener) {
@ -952,23 +930,20 @@ public class ResolverTests extends TestCase {
assertTrue(e.getMessage(), false);
}
assertNotNull(listener.getEvent());
event = listener.getEvent();
deltas = event.getDeltas();
events = listener.getEvents();
assertNotNull(events);
assertNotNull(event.getResolver());
assertTrue(deltas.length > 1);
assertEquals(ResolverDelta.ELEMENT_PROJECT, deltas[0].getElementType());
assertEquals(ResolverDelta.EVENT_SET, deltas[0].getEventType());
assertNotNull(deltas[0].getElement());
assertNull(deltas[0].getAssociation());
assertNull(deltas[0].getLanguage());
assertNull(deltas[0].getFileType());
assertNotNull(deltas[0].getProject());
assertTrue(events.length > 1);
assertNotNull(events[0].getContainer());
assertEquals(ResolverChangeEvent.ELEMENT_RESOLVER, events[0].getElementType());
assertEquals(ResolverChangeEvent.EVENT_SET, events[0].getEventType());
assertNotNull(events[0].getElement());
//assertNull(deltas[0].getAssociation());
//assertNull(deltas[0].getLanguage());
//assertNull(deltas[0].getFileType());
//assertNotNull(deltas[0].getProject());
// Test resetting project resolver
try {
listener = new TestModelListener();
synchronized (listener) {
@ -979,20 +954,18 @@ public class ResolverTests extends TestCase {
assertTrue(e.getMessage(), false);
}
assertNotNull(listener.getEvent());
events = listener.getEvents();
assertNotNull(events);
event = listener.getEvent();
deltas = event.getDeltas();
assertNotNull(event.getResolver());
assertTrue(deltas.length > 1);
assertEquals(ResolverDelta.ELEMENT_PROJECT, deltas[0].getElementType());
assertEquals(ResolverDelta.EVENT_SET, deltas[0].getEventType());
assertNotNull(deltas[0].getElement());
assertNull(deltas[0].getAssociation());
assertNull(deltas[0].getLanguage());
assertNull(deltas[0].getFileType());
assertNotNull(deltas[0].getProject());
assertTrue(events.length > 1);
assertNotNull(events[0].getContainer());
assertEquals(ResolverChangeEvent.ELEMENT_RESOLVER, events[0].getElementType());
assertEquals(ResolverChangeEvent.EVENT_SET, events[0].getEventType());
assertNotNull(events[0].getElement());
//assertNull(deltas[0].getAssociation());
//assertNull(deltas[0].getLanguage());
//assertNull(deltas[0].getFileType());
//assertNotNull(deltas[0].getProject());
}
}

9
core/org.eclipse.cdt.core/ChangeLog
View file

@ -1,3 +1,12 @@
2004-08-15 Alain Magloire
First draft, work in progress.
Removing ResolveDelta to make the ResolverChange processing easier.
* src/org/eclipse/cdt/core/filetype/IResolverChangeListener
* src/org/eclipse/cdt/core/filetype/ResolverChangeEvent.java
* src/org/eclipse/cdt/core/internal/filetype/CFiletTypeResolver.java
* src/org/eclipse/cdt/core/internal/filetype/ResolverModel.java
2004-08-13 Chris Wiebe
Extra functionality in type cache to support new class wizard

2
core/org.eclipse.cdt.core/model/org/eclipse/cdt/internal/core/model/CModelManager.java
View file

@ -737,7 +737,7 @@ public class CModelManager implements IResourceChangeListener, ICDescriptorListe
/* (non-Javadoc)
* @see org.eclipse.cdt.core.filetype.IResolverChangeListener#resolverChanged(org.eclipse.cdt.core.filetype.ResolverChangeEvent)
*/
public void resolverChanged(ResolverChangeEvent event) {
public void resolverChanged(ResolverChangeEvent[] events) {
// TODO Auto-generated method stub
// boolean isProjectSpecific = false;
// ICElement element = null;

2
core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/filetype/IResolverChangeListener.java
View file

@ -15,5 +15,5 @@ package org.eclipse.cdt.core.filetype;
* individual resolver.
*/
public interface IResolverChangeListener {
public void resolverChanged(ResolverChangeEvent event);
public void resolverChanged(ResolverChangeEvent[] event);
}

154
core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/filetype/ResolverChangeEvent.java
View file

@ -10,69 +10,127 @@
***********************************************************************/
package org.eclipse.cdt.core.filetype;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.EventObject;
public class ResolverChangeEvent {
private ICFileTypeResolver fResolver;
private List fDeltas = new ArrayList();
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IProject;
public class ResolverChangeEvent extends EventObject {
public static final int EVENT_ADD = 0x10;
public static final int EVENT_REMOVE = 0x20;
public static final int EVENT_SET = 0x40;
public static final int EVENT_MASK = 0xF0;
public static final int ELEMENT_LANGUAGE = 0x01;
public static final int ELEMENT_FILETYPE = 0x02;
public static final int ELEMENT_ASSOCIATION = 0x04;
public static final int ELEMENT_RESOLVER = 0x08;
public static final int ELEMENT_MASK = 0x0F;
private Object fElement;
private int fEventType;
/**
* Create a new resolver change event. The event is empty
* of any change deltas, and references the provided file
* type resolver.
* Create a new change event.
*
* @param resolver file type resolver this event applies to
*/
public ResolverChangeEvent(ICFileTypeResolver resolver) {
fResolver = resolver;
}
/**
* @return resolver affected by this change
*/
public ICFileTypeResolver getResolver() {
return fResolver;
public ResolverChangeEvent(IContainer container, int eventType, Object element) {
super(container);
fEventType = eventType;
fElement = element;
}
/**
* @return number of resolver deltas involved in this change
*/
public int getDeltaCount() {
return fDeltas.size();
}
/**
* @return ResolverDelta[] for this change
*/
public ResolverDelta[] getDeltas() {
return (ResolverDelta[]) fDeltas.toArray(new ResolverDelta[fDeltas.size()]);
public IContainer getContainer() {
return (IContainer)getSource();
}
/**
* Add a new delta to the list of deltas.
*
* @param delta instance of ResolverDelta to add to the list.
*/
public void addDelta(ResolverDelta delta) {
fDeltas.add(delta);
public int getEventType() {
return fEventType & EVENT_MASK;
}
public Object getElement() {
return fElement;
}
public int getElementType() {
if (fElement instanceof ICLanguage) {
return ELEMENT_LANGUAGE;
} else if (fElement instanceof ICFileType) {
return ELEMENT_FILETYPE;
} else if (fElement instanceof ICFileTypeAssociation) {
return ELEMENT_ASSOCIATION;
} else if (fElement instanceof ICFileTypeResolver) {
return ELEMENT_RESOLVER;
}
return 0;
}
public String toString() {
StringBuffer buf = new StringBuffer();
buf.append("ResolverChangeEvent [");
buf.append(fDeltas.size());
buf.append(" delta(s)]");
for (Iterator iter = fDeltas.iterator(); iter.hasNext();) {
ResolverDelta element = (ResolverDelta) iter.next();
buf.append("\n ");
buf.append(element.toString());
buf.append("ResolverChangeEvent ["); //$NON-NLS-1$
IContainer container = getContainer();
if (container instanceof IProject) {
buf.append("For project "); //$NON-NLS-1$
buf.append(container.getName());
} else {
buf.append("For workspace"); //$NON-NLS-1$
}
buf.append(' ');
switch (getEventType()) {
case EVENT_ADD:
buf.append("add"); //$NON-NLS-1$
break;
case EVENT_REMOVE:
buf.append("remove"); //$NON-NLS-1$
break;
case EVENT_SET:
buf.append("set"); //$NON-NLS-1$
break;
default:
buf.append("?unknown event?"); //$NON-NLS-1$
break;
}
buf.append(' ');
switch (getElementType()) {
case ELEMENT_LANGUAGE:
{
ICLanguage lang = (ICLanguage)getElement();
buf.append("language "); //$NON-NLS-1$
buf.append(lang.getName());
break;
}
case ELEMENT_FILETYPE:
{
ICFileType fileType = (ICFileType)getElement();
buf.append("filetype "); //$NON-NLS-1$
buf.append(fileType.getName());
break;
}
case ELEMENT_ASSOCIATION:
{
ICFileTypeAssociation association = (ICFileTypeAssociation)getElement();
buf.append("assoc "); //$NON-NLS-1$
buf.append(association.getPattern());
break;
}
case ELEMENT_RESOLVER:
{
ICFileTypeResolver resolver = (ICFileTypeResolver)getElement();
buf.append("resolver "); //$NON-NLS-1$
break;
}
default:
buf.append("?unknown source?"); //$NON-NLS-1$
break;
}
buf.append(']');
return buf.toString();
}
}

124
core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/filetype/ResolverDelta.java
View file

@ -1,124 +0,0 @@
/**********************************************************************
* Copyright (c) 2004 TimeSys Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Common Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/cpl-v10.html
*
* Contributors:
* TimeSys Corporation - Initial API and implementation
***********************************************************************/
package org.eclipse.cdt.core.filetype;
import org.eclipse.core.resources.IProject;
public class ResolverDelta {
public static final int EVENT_ADD = 0x10;
public static final int EVENT_REMOVE = 0x20;
public static final int EVENT_SET = 0x40;
public static final int EVENT_MASK = 0xF0;
public static final int ELEMENT_LANGUAGE = 0x01;
public static final int ELEMENT_FILETYPE = 0x02;
public static final int ELEMENT_ASSOCIATION = 0x04;
public static final int ELEMENT_PROJECT = 0x08;
public static final int ELEMENT_WORKSPACE = 0x0F;
public static final int ELEMENT_MASK = 0x0F;
private Object fElement;
private int fEvent;
public ResolverDelta(int event, int source, Object element) {
fElement = element;
fEvent = event | source;
}
public ResolverDelta(ICLanguage lang, int event) {
this(event, ELEMENT_LANGUAGE, lang);
}
public ResolverDelta(ICFileType type, int event) {
this(event, ELEMENT_FILETYPE, type);
}
public ResolverDelta(ICFileTypeAssociation assoc, int event) {
this(event, ELEMENT_ASSOCIATION, assoc);
}
public Object getElement() {
return fElement;
}
public int getElementType() {
return fEvent & ELEMENT_MASK;
}
public int getEventType() {
return fEvent & EVENT_MASK;
}
public ICLanguage getLanguage() {
return ((fElement instanceof ICLanguage) ? ((ICLanguage) fElement) : null);
}
public ICFileType getFileType() {
return ((fElement instanceof ICFileType) ? ((ICFileType) fElement) : null);
}
public ICFileTypeAssociation getAssociation() {
return ((fElement instanceof ICFileTypeAssociation) ? ((ICFileTypeAssociation) fElement) : null);
}
public IProject getProject() {
return ((fElement instanceof IProject) ? ((IProject) fElement) : null);
}
public int getEvent() {
return fEvent;
}
public String toString() {
StringBuffer buf = new StringBuffer();
switch (getEventType()) {
case EVENT_ADD:
buf.append("add");
break;
case EVENT_REMOVE:
buf.append("remove");
break;
case EVENT_SET:
buf.append("set");
break;
default:
buf.append("?unknown event?");
break;
}
buf.append(" ");
switch (getElementType()) {
case ELEMENT_LANGUAGE:
buf.append("language ");
buf.append(null != getLanguage() ? getLanguage().getName() : "?");
break;
case ELEMENT_FILETYPE:
buf.append("filetype ");
buf.append(null != getFileType() ? getFileType().getName() : "?");
break;
case ELEMENT_ASSOCIATION:
buf.append("assoc ");
buf.append(null != getAssociation() ? getAssociation().getPattern() : "?");
break;
case ELEMENT_PROJECT:
buf.append("resolver for project ");
buf.append(null != getProject() ? getProject().getName() : "?");
break;
case ELEMENT_WORKSPACE:
buf.append("resolver for workspace");
break;
default:
buf.append("?unknown source?");
break;
}
return buf.toString();
}
}

17
core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/internal/filetype/CFileTypeResolver.java
View file

@ -18,12 +18,21 @@ import java.util.List;
import org.eclipse.cdt.core.filetype.ICFileType;
import org.eclipse.cdt.core.filetype.ICFileTypeAssociation;
import org.eclipse.cdt.core.filetype.ICFileTypeResolver;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.ResourcesPlugin;
public class CFileTypeResolver implements ICFileTypeResolver {
protected IContainer fContainer;
// The association list holds a list of known file associations.
protected List fAssocList = new ArrayList();
public CFileTypeResolver() {
this(ResourcesPlugin.getWorkspace().getRoot());
}
public CFileTypeResolver(IContainer container) {
fContainer = container;
}
public ICFileTypeAssociation[] getFileTypeAssociations() {
@ -65,9 +74,9 @@ public class CFileTypeResolver implements ICFileTypeResolver {
boolean removed = doRemoveAssociations(remove);
return (added || removed);
}
public ICFileTypeResolver createWorkingCopy() {
CFileTypeResolver copy = new CFileTypeResolver();
CFileTypeResolver copy = new CFileTypeResolver(fContainer);
copy.fAssocList.addAll(fAssocList);
return copy;
}
@ -109,6 +118,6 @@ public class CFileTypeResolver implements ICFileTypeResolver {
}
private static void debugLog(String message) {
System.out.println("CDT Resolver: " + message);
System.out.println("CDT Resolver: " + message); //$NON-NLS-1$
}
}

195
core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/internal/filetype/ResolverModel.java
View file

@ -38,8 +38,9 @@ import org.eclipse.cdt.core.filetype.ICLanguage;
import org.eclipse.cdt.core.filetype.IResolverChangeListener;
import org.eclipse.cdt.core.filetype.IResolverModel;
import org.eclipse.cdt.core.filetype.ResolverChangeEvent;
import org.eclipse.cdt.core.filetype.ResolverDelta;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
@ -65,7 +66,7 @@ public class ResolverModel implements IResolverModel {
/**
* Name used to describe an unknown language or file type
*/
public static final String NAME_UNKNOWN = "Unknown";
public static final String NAME_UNKNOWN = "Unknown"; //$NON-NLS-1$
/**
* Default language, returned when no other language matches a language id.
@ -230,10 +231,13 @@ public class ResolverModel implements IResolverModel {
* @return true if the language is added, false otherwise
*/
public boolean addLanguage(ICLanguage lang) {
ResolverChangeEvent event = new ResolverChangeEvent(null);
boolean result = addLanguage(lang, event);
IContainer root = ResourcesPlugin.getWorkspace().getRoot();
List list = new ArrayList(1);
boolean result = addLanguage(root, list, lang);
if (true == result) {
fireEvent(event);
ResolverChangeEvent[] events = new ResolverChangeEvent[list.size()];
list.toArray(events);
fireEvent(events);
}
return result;
}
@ -250,10 +254,13 @@ public class ResolverModel implements IResolverModel {
* @return true if the file type is added, false otherwise
*/
public boolean addFileType(ICFileType type) {
ResolverChangeEvent event = new ResolverChangeEvent(null);
boolean result = addFileType(type, event);
IContainer root = ResourcesPlugin.getWorkspace().getRoot();
List list = new ArrayList(1);
boolean result = addFileType(root, list, type);
if (true == result) {
fireEvent(event);
ResolverChangeEvent[] events = new ResolverChangeEvent[list.size()];
list.toArray(events);
fireEvent(events);
}
return result;
}
@ -266,10 +273,13 @@ public class ResolverModel implements IResolverModel {
* @return true if the language is removed, false otherwise
*/
public boolean removeLanguage(ICLanguage lang) {
ResolverChangeEvent event = new ResolverChangeEvent(null);
boolean result = removeLanguage(lang, event);
IContainer root = ResourcesPlugin.getWorkspace().getRoot();
List list = new ArrayList(1);
boolean result = removeLanguage(root, list, lang);
if (true == result) {
fireEvent(event);
ResolverChangeEvent[] events = new ResolverChangeEvent[list.size()];
list.toArray(events);
fireEvent(events);
}
return result;
}
@ -282,10 +292,13 @@ public class ResolverModel implements IResolverModel {
* @return true if the file type is removed, false otherwise
*/
public boolean removeFileType(ICFileType type) {
ResolverChangeEvent event = new ResolverChangeEvent(null);
boolean result = removeFileType(type, event);
IContainer root = ResourcesPlugin.getWorkspace().getRoot();
List list = new ArrayList(1);
boolean result = removeFileType(root, list, type);
if (true == result) {
fireEvent(event);
ResolverChangeEvent[] events = new ResolverChangeEvent[list.size()];
list.toArray(events);
fireEvent(events);
}
return result;
}
@ -311,43 +324,46 @@ public class ResolverModel implements IResolverModel {
}
private static void debugLog(String message) {
System.out.println("CDT Resolver: " + message);
System.out.println("CDT Resolver: " + message); //$NON-NLS-1$
}
//----------------------------------------------------------------------
// Registry change event handling
//----------------------------------------------------------------------
private boolean addLanguage(ICLanguage lang, ResolverChangeEvent event) {
private boolean addLanguage(IContainer container, List list, ICLanguage lang) {
boolean added = false;
if (!fLangMap.containsValue(lang)) {
fLangMap.put(lang.getId(), lang);
if (null != event) {
event.addDelta(new ResolverDelta(lang, ResolverDelta.EVENT_ADD));
if (null != list) {
ResolverChangeEvent event = new ResolverChangeEvent(container, ResolverChangeEvent.EVENT_ADD, lang);
list.add(event);
}
added = true;
}
return added;
}
private boolean addFileType(ICFileType type, ResolverChangeEvent event) {
private boolean addFileType(IContainer container, List list, ICFileType type) {
boolean added = false;
if (!fTypeMap.containsValue(type)) {
fTypeMap.put(type.getId(), type);
if (null != event) {
event.addDelta(new ResolverDelta(type, ResolverDelta.EVENT_ADD));
if (null != list) {
ResolverChangeEvent event = new ResolverChangeEvent(container, ResolverChangeEvent.EVENT_ADD, type);
list.add(event);
}
added = true;
}
return added;
}
private boolean removeLanguage(ICLanguage lang, ResolverChangeEvent event) {
private boolean removeLanguage(IContainer container, List list, ICLanguage lang) {
boolean removed = (null != fLangMap.remove(lang.getId()));
if (removed) {
if (null != event) {
event.addDelta(new ResolverDelta(lang, ResolverDelta.EVENT_REMOVE));
if (null != list) {
ResolverChangeEvent event = new ResolverChangeEvent(container, ResolverChangeEvent.EVENT_REMOVE, lang);
list.add(event);
}
ArrayList removeList = new ArrayList();
for (Iterator iter = fTypeMap.values().iterator(); iter.hasNext();) {
@ -357,17 +373,18 @@ public class ResolverModel implements IResolverModel {
}
}
for (Iterator iter = removeList.iterator(); iter.hasNext();) {
removeFileType((ICFileType) iter.next(), event);
removeFileType(container, list, (ICFileType) iter.next());
}
}
return removed;
}
private boolean removeFileType(ICFileType type, ResolverChangeEvent event) {
private boolean removeFileType(IContainer container, List list, ICFileType type) {
boolean removed = (null != fTypeMap.remove(type.getId()));
if (removed) {
if (null != event) {
event.addDelta(new ResolverDelta(type, ResolverDelta.EVENT_REMOVE));
if (null != list) {
ResolverChangeEvent event = new ResolverChangeEvent(container, ResolverChangeEvent.EVENT_REMOVE, type);
list.add(event);
}
// TODO: must remove any associations based on this file type as well
// Unforuntately, at this point, that means iterating over the contents
@ -376,19 +393,25 @@ public class ResolverModel implements IResolverModel {
return removed;
}
private void fireEvent(final ResolverChangeEvent event) {
final IResolverChangeListener[] listeners;
private void fireEvent(final ResolverChangeEvent[] events) {
synchronized (fListeners) {
if (isDebugging()) {
debugLog(event.toString());
}
if (fListeners.isEmpty()) {
return;
}
listeners = (IResolverChangeListener[]) fListeners.toArray(new IResolverChangeListener[fListeners.size()]);
if (events == null || events.length == 0) {
return;
}
if (isDebugging()) {
for (int i = 0; i < events.length; i++) {
debugLog(events[i].toString());
}
}
if (fListeners.isEmpty()) {
return;
}
final IResolverChangeListener[] listeners;
listeners = (IResolverChangeListener[]) fListeners.toArray(new IResolverChangeListener[fListeners.size()]);
for (int i = 0; i < listeners.length; i++) {
final int index = i;
Platform.run(new ISafeRunnable() {
@ -398,22 +421,27 @@ public class ResolverModel implements IResolverModel {
CCorePlugin.log(status);
}
public void run() throws Exception {
listeners[index].resolverChanged(event);
listeners[index].resolverChanged(events);
}
});
}
}
private void fireResolverChangeEvent(IProject project, ICFileTypeResolver oldResolver) {
IContainer container = project;
ICFileTypeResolver newResolver = getResolver(project);
ResolverChangeEvent event = new ResolverChangeEvent(newResolver);
int element = ResolverDelta.ELEMENT_WORKSPACE;
if (null != project) {
element = ResolverDelta.ELEMENT_PROJECT;
}
//ResolverChangeEvent event = new ResolverChangeEvent(newResolver);
//int element = ResolverDelta.ELEMENT_WORKSPACE;
//if (null != project) {
// element = ResolverDelta.ELEMENT_PROJECT;
//}
//event.addDelta(new ResolverDelta(ResolverDelta.EVENT_SET, element, project));
event.addDelta(new ResolverDelta(ResolverDelta.EVENT_SET, element, project));
List list = new ArrayList();
if (container == null) {
container = ResourcesPlugin.getWorkspace().getRoot();
}
list.add(new ResolverChangeEvent(container, ResolverChangeEvent.EVENT_SET, newResolver));
if ((null != oldResolver) && (null != newResolver)) {
ICFileTypeAssociation[] oldAssoc = oldResolver.getFileTypeAssociations();
@ -421,18 +449,21 @@ public class ResolverModel implements IResolverModel {
for (int i = 0; i < oldAssoc.length; i++) {
if (Arrays.binarySearch(newAssoc, oldAssoc[i], ICFileTypeAssociation.Comparator) < 0) {
event.addDelta(new ResolverDelta(oldAssoc[i], ResolverDelta.EVENT_REMOVE));
//event.addDelta(new ResolverDelta(oldAssoc[i], ResolverDelta.EVENT_REMOVE));
list.add(new ResolverChangeEvent(container, ResolverChangeEvent.EVENT_REMOVE, oldAssoc[i]));
}
}
for (int i = 0; i < newAssoc.length; i++) {
if (Arrays.binarySearch(oldAssoc, newAssoc[i], ICFileTypeAssociation.Comparator) < 0) {
event.addDelta(new ResolverDelta(newAssoc[i], ResolverDelta.EVENT_ADD));
//event.addDelta(new ResolverDelta(newAssoc[i], ResolverDelta.EVENT_ADD));
list.add(new ResolverChangeEvent(container, ResolverChangeEvent.EVENT_ADD, newAssoc[i]));
}
}
}
fireEvent(event);
ResolverChangeEvent[] events = new ResolverChangeEvent[list.size()];
list.toArray(events);
fireEvent(events);
}
private void initRegistryChangeListener() {
@ -443,18 +474,20 @@ public class ResolverModel implements IResolverModel {
}, CCorePlugin.PLUGIN_ID);
}
private void handleRegistryChanged(IRegistryChangeEvent event) {
protected void handleRegistryChanged(IRegistryChangeEvent event) {
IExtensionDelta[] deltas = null;
ResolverChangeEvent modelEvent = new ResolverChangeEvent(null);
//ResolverChangeEvent modelEvent = new ResolverChangeEvent(null);
List list = new ArrayList();
IContainer container = ResourcesPlugin.getWorkspace().getRoot();
deltas = event.getExtensionDeltas(CCorePlugin.PLUGIN_ID, EXTENSION_LANG);
for (int i = 0; i < deltas.length; i++) {
processLanguageExtension(modelEvent, deltas[i].getExtension(), IExtensionDelta.ADDED == deltas[i].getKind());
processLanguageExtension(container, list, deltas[i].getExtension(), IExtensionDelta.ADDED == deltas[i].getKind());
}
deltas = event.getExtensionDeltas(CCorePlugin.PLUGIN_ID, EXTENSION_TYPE);
for (int i = 0; i < deltas.length; i++) {
processTypeExtension(modelEvent, deltas[i].getExtension(), IExtensionDelta.ADDED == deltas[i].getKind());
processTypeExtension(container, list, deltas[i].getExtension(), IExtensionDelta.ADDED == deltas[i].getKind());
}
deltas = event.getExtensionDeltas(CCorePlugin.PLUGIN_ID, EXTENSION_ASSOC);
@ -462,8 +495,11 @@ public class ResolverModel implements IResolverModel {
fDefaultResolver = loadDefaultResolver();
fWkspResolver = loadWorkspaceResolver();
}
fireEvent(modelEvent);
if (!list.isEmpty()) {
ResolverChangeEvent[] events = new ResolverChangeEvent[list.size()];
list.toArray(events);
fireEvent(events);
}
}
//----------------------------------------------------------------------
@ -476,16 +512,22 @@ public class ResolverModel implements IResolverModel {
private void loadDeclaredLanguages() {
IExtensionPoint point = getExtensionPoint(EXTENSION_LANG);
IExtension[] extensions = point.getExtensions();
ResolverChangeEvent event = new ResolverChangeEvent(null);
//ResolverChangeEvent event = new ResolverChangeEvent(null);
IContainer root = ResourcesPlugin.getWorkspace().getRoot();
List list = new ArrayList();
for (int i = 0; i < extensions.length; i++) {
processLanguageExtension(event, extensions[i], true);
processLanguageExtension(root, list, extensions[i], true);
}
// Shouldn't have anything listening here, but generating
// the events helps maintain internal consistency w/logging
fireEvent(event);
if (!list.isEmpty()) {
ResolverChangeEvent[] events = new ResolverChangeEvent[list.size()];
list.toArray(events);
fireEvent(events);
}
}
/**
@ -494,19 +536,24 @@ public class ResolverModel implements IResolverModel {
private void loadDeclaredTypes() {
IExtensionPoint point = getExtensionPoint(EXTENSION_TYPE);
IExtension[] extensions = point.getExtensions();
ResolverChangeEvent event = new ResolverChangeEvent(null);
//ResolverChangeEvent event = new ResolverChangeEvent(null);
IContainer root = ResourcesPlugin.getWorkspace().getRoot();
List list = new ArrayList();
for (int i = 0; i < extensions.length; i++) {
processTypeExtension(event, extensions[i], true);
processTypeExtension(root, list, extensions[i], true);
}
// Shouldn't have anything listening here, but generating
// the events helps maintain internal consistency w/logging
fireEvent(event);
if (!list.isEmpty()) {
ResolverChangeEvent[] events = new ResolverChangeEvent[list.size()];
list.toArray(events);
fireEvent(events);
}
}
private void processLanguageExtension(ResolverChangeEvent event, IExtension extension, boolean add) {
private void processLanguageExtension(IContainer container, List list, IExtension extension, boolean add) {
IConfigurationElement[] elements = extension.getConfigurationElements();
for (int i = 0; i < elements.length; i++) {
String id = elements[i].getAttribute(ATTR_ID);
@ -515,9 +562,9 @@ public class ResolverModel implements IResolverModel {
try {
ICLanguage element = new CLanguage(id, name);
if (add) {
addLanguage(element, event);
addLanguage(container, list, element);
} else {
removeLanguage(element, event);
removeLanguage(container, list, element);
}
} catch (IllegalArgumentException e) {
CCorePlugin.log(e);
@ -525,7 +572,7 @@ public class ResolverModel implements IResolverModel {
}
}
private void processTypeExtension(ResolverChangeEvent event, IExtension extension, boolean add) {
private void processTypeExtension(IContainer container, List list, IExtension extension, boolean add) {
IConfigurationElement[] elements = extension.getConfigurationElements();
for (int i = 0; i < elements.length; i++) {
String id = elements[i].getAttribute(ATTR_ID);
@ -536,9 +583,9 @@ public class ResolverModel implements IResolverModel {
try {
ICFileType element = new CFileType(id, getLanguageById(lang), name, parseType(type));
if (add) {
addFileType(element, event);
addFileType(container, list, element);
} else {
removeFileType(element, event);
removeFileType(container, list, element);
}
} catch (IllegalArgumentException e) {
CCorePlugin.log(e);
@ -576,7 +623,7 @@ public class ResolverModel implements IResolverModel {
*/
private ICFileTypeResolver loadDefaultResolver() {
List assoc = new ArrayList();
ICFileTypeResolver resolver = new CFileTypeResolver();
ICFileTypeResolver resolver = new CFileTypeResolver(ResourcesPlugin.getWorkspace().getRoot());
IExtensionPoint point = getExtensionPoint(EXTENSION_ASSOC);
IExtension[] extensions = point.getExtensions();
IConfigurationElement[] elements = null;
@ -608,7 +655,7 @@ public class ResolverModel implements IResolverModel {
List assocs = new ArrayList();
String attr = element.getAttribute(ATTR_PATTERN);
if (null != attr) {
String[] item = attr.split(",");
String[] item = attr.split(","); //$NON-NLS-1$
for (int i = 0; i < item.length; i++) {
try {
assocs.add(createAssocation(item[i].trim(), typeRef));
@ -683,7 +730,7 @@ public class ResolverModel implements IResolverModel {
Properties props = new Properties();
FileInputStream in = null;
resolver = new CFileTypeResolver();
resolver = new CFileTypeResolver(ResourcesPlugin.getWorkspace().getRoot());
try {
in = new FileInputStream(file);
@ -781,7 +828,7 @@ public class ResolverModel implements IResolverModel {
private ICFileTypeResolver loadProjectResolver(IProject project) {
List assocs = new ArrayList();
ICFileTypeResolver resolver = new CFileTypeResolver();
ICFileTypeResolver resolver = new CFileTypeResolver(project);
Element data = getProjectData(project, false);
Node child = ((null != data) ? data.getFirstChild() : null);

6
core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/preferences/CFileTypesPreferenceBlock.java
View file

@ -320,7 +320,7 @@ public class CFileTypesPreferenceBlock {
return changed;
}
private void handleSelectionChanged() {
protected void handleSelectionChanged() {
IStructuredSelection sel = getSelection();
fBtnRemove.setEnabled(!sel.isEmpty());
}
@ -329,7 +329,7 @@ public class CFileTypesPreferenceBlock {
return CCorePlugin.getDefault().getResolverModel();
}
private void handleAdd() {
protected void handleAdd() {
ICFileTypeAssociation assoc = null;
CFileTypeDialog dlg = new CFileTypeDialog(fBtnNew.getParent().getShell());
@ -345,7 +345,7 @@ public class CFileTypesPreferenceBlock {
}
}
private void handleRemove() {
protected void handleRemove() {
IStructuredSelection sel = getSelection();
if ((null != sel) && (!sel.isEmpty())) {
for (Iterator iter = sel.iterator(); iter.hasNext();) {