mirrors/cdt
1
0
Fork 0
mirror of https://github.com/eclipse-cdt/cdt synced 2025-08-09 09:15:38 +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

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

142
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; package org.eclipse.cdt.core.filetype;
import java.util.ArrayList; import java.util.EventObject;
import java.util.Iterator;
import java.util.List;
public class ResolverChangeEvent { import org.eclipse.core.resources.IContainer;
private ICFileTypeResolver fResolver; import org.eclipse.core.resources.IProject;
private List fDeltas = new ArrayList();
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 * Create a new change event.
* of any change deltas, and references the provided file
* type resolver.
* *
* @param resolver file type resolver this event applies to * @param resolver file type resolver this event applies to
*/ */
public ResolverChangeEvent(ICFileTypeResolver resolver) { public ResolverChangeEvent(IContainer container, int eventType, Object element) {
fResolver = resolver; super(container);
fEventType = eventType;
fElement = element;
} }
/** public IContainer getContainer() {
* @return resolver affected by this change return (IContainer)getSource();
*/
public ICFileTypeResolver getResolver() {
return fResolver;
} }
/** public int getEventType() {
* @return number of resolver deltas involved in this change return fEventType & EVENT_MASK;
*/
public int getDeltaCount() {
return fDeltas.size();
} }
/** public Object getElement() {
* @return ResolverDelta[] for this change return fElement;
*/
public ResolverDelta[] getDeltas() {
return (ResolverDelta[]) fDeltas.toArray(new ResolverDelta[fDeltas.size()]);
} }
/** public int getElementType() {
* Add a new delta to the list of deltas. if (fElement instanceof ICLanguage) {
* return ELEMENT_LANGUAGE;
* @param delta instance of ResolverDelta to add to the list. } else if (fElement instanceof ICFileType) {
*/ return ELEMENT_FILETYPE;
public void addDelta(ResolverDelta delta) { } else if (fElement instanceof ICFileTypeAssociation) {
fDeltas.add(delta); return ELEMENT_ASSOCIATION;
} else if (fElement instanceof ICFileTypeResolver) {
return ELEMENT_RESOLVER;
} }
return 0;
}
public String toString() { public String toString() {
StringBuffer buf = new StringBuffer(); StringBuffer buf = new StringBuffer();
buf.append("ResolverChangeEvent ["); //$NON-NLS-1$
buf.append("ResolverChangeEvent ["); IContainer container = getContainer();
buf.append(fDeltas.size()); if (container instanceof IProject) {
buf.append(" delta(s)]"); buf.append("For project "); //$NON-NLS-1$
buf.append(container.getName());
for (Iterator iter = fDeltas.iterator(); iter.hasNext();) { } else {
ResolverDelta element = (ResolverDelta) iter.next(); buf.append("For workspace"); //$NON-NLS-1$
buf.append("\n ");
buf.append(element.toString());
} }
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(); 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();
}
}

13
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.ICFileType;
import org.eclipse.cdt.core.filetype.ICFileTypeAssociation; import org.eclipse.cdt.core.filetype.ICFileTypeAssociation;
import org.eclipse.cdt.core.filetype.ICFileTypeResolver; import org.eclipse.cdt.core.filetype.ICFileTypeResolver;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.ResourcesPlugin;
public class CFileTypeResolver implements ICFileTypeResolver { public class CFileTypeResolver implements ICFileTypeResolver {
protected IContainer fContainer;
// The association list holds a list of known file associations. // The association list holds a list of known file associations.
protected List fAssocList = new ArrayList(); protected List fAssocList = new ArrayList();
public CFileTypeResolver() { public CFileTypeResolver() {
this(ResourcesPlugin.getWorkspace().getRoot());
}
public CFileTypeResolver(IContainer container) {
fContainer = container;
} }
public ICFileTypeAssociation[] getFileTypeAssociations() { public ICFileTypeAssociation[] getFileTypeAssociations() {
@ -67,7 +76,7 @@ public class CFileTypeResolver implements ICFileTypeResolver {
} }
public ICFileTypeResolver createWorkingCopy() { public ICFileTypeResolver createWorkingCopy() {
CFileTypeResolver copy = new CFileTypeResolver(); CFileTypeResolver copy = new CFileTypeResolver(fContainer);
copy.fAssocList.addAll(fAssocList); copy.fAssocList.addAll(fAssocList);
return copy; return copy;
} }
@ -109,6 +118,6 @@ public class CFileTypeResolver implements ICFileTypeResolver {
} }
private static void debugLog(String message) { private static void debugLog(String message) {
System.out.println("CDT Resolver: " + message); System.out.println("CDT Resolver: " + message); //$NON-NLS-1$
} }
} }

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