| /******************************************************************************* |
| * Copyright (c) 2000, 2017 IBM Corporation and others. |
| * |
| * This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.team.internal.core; |
| |
| import java.io.DataInputStream; |
| import java.io.EOFException; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.IOException; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.util.TreeMap; |
| |
| import org.eclipse.core.resources.IStorage; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.core.runtime.content.IContentType; |
| import org.eclipse.core.runtime.content.IContentTypeManager; |
| import org.eclipse.team.core.IFileContentManager; |
| import org.eclipse.team.core.IStringMapping; |
| import org.eclipse.team.core.Team; |
| |
| /** |
| * TODO: implement extension point |
| */ |
| public class FileContentManager implements IFileContentManager { |
| |
| private static final String PREF_TEAM_EXTENSION_TYPES= "file_types"; //$NON-NLS-1$ |
| private static final String PREF_TEAM_FILENAME_TYPES= "cvs_mode_for_file_without_extensions"; //$NON-NLS-1$ |
| |
| private static class StringMapping implements IStringMapping { |
| |
| private final String fString; |
| private final int fType; |
| |
| public StringMapping(String string, int type) { |
| fString= string; |
| fType= type; |
| } |
| |
| @Override |
| public String getString() { |
| return fString; |
| } |
| |
| @Override |
| public int getType() { |
| return fType; |
| } |
| } |
| |
| private static class UserExtensionMappings extends UserStringMappings { |
| |
| public UserExtensionMappings(String key) { |
| super(key); |
| } |
| |
| @Override |
| protected Map<String, Integer> loadMappingsFromPreferences() { |
| final Map<String, Integer> result= super.loadMappingsFromPreferences(); |
| if (loadMappingsFromOldWorkspace(result)) { |
| TeamPlugin.getPlugin().savePluginPreferences(); |
| } |
| return result; |
| } |
| |
| /** |
| * If the workspace is an old 2.0 one, read the old file and delete it. |
| * |
| * @param A map where the new mappings should be added. |
| * |
| * @return true if the workspace was a 2.0 one and the old mappings have |
| * been added to the map, false otherwise. |
| * |
| */ |
| private boolean loadMappingsFromOldWorkspace(Map<String, Integer> map) { |
| // File name of the persisted file type information |
| String STATE_FILE = ".fileTypes"; //$NON-NLS-1$ |
| IPath pluginStateLocation = TeamPlugin.getPlugin().getStateLocation().append(STATE_FILE); |
| File f = pluginStateLocation.toFile(); |
| |
| if (!f.exists()) |
| return false; |
| |
| try { |
| DataInputStream input = new DataInputStream(new FileInputStream(f)); |
| try { |
| map.putAll(readOldFormatExtensionMappings(input)); |
| } finally { |
| input.close(); |
| f.delete(); |
| } |
| } catch (IOException ex) { |
| TeamPlugin.log(IStatus.ERROR, ex.getMessage(), ex); |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Read the saved file type state from the given input stream. |
| * |
| * @param input the input stream to read the saved state from |
| * @throws IOException if an I/O problem occurs |
| */ |
| private Map<String, Integer> readOldFormatExtensionMappings(DataInputStream input) throws IOException { |
| final Map<String, Integer> result= new TreeMap<>(); |
| int numberOfMappings = 0; |
| try { |
| numberOfMappings = input.readInt(); |
| } catch (EOFException e) { |
| // Ignore the exception, it will occur if there are no |
| // patterns stored in the state file. |
| return Collections.emptyMap(); |
| } |
| for (int i = 0; i < numberOfMappings; i++) { |
| final String extension = input.readUTF(); |
| final int type = input.readInt(); |
| result.put(extension, Integer.valueOf(type)); |
| } |
| return result; |
| } |
| } |
| |
| private final UserStringMappings fUserExtensionMappings, fUserNameMappings; |
| private PluginStringMappings fPluginExtensionMappings;//, fPluginNameMappings; |
| private IContentType textContentType; |
| |
| public FileContentManager() { |
| fUserExtensionMappings= new UserExtensionMappings(PREF_TEAM_EXTENSION_TYPES); |
| fUserNameMappings= new UserStringMappings(PREF_TEAM_FILENAME_TYPES); |
| fPluginExtensionMappings= new PluginStringMappings(TeamPlugin.FILE_TYPES_EXTENSION, "extension"); //$NON-NLS-1$ |
| } |
| |
| @Override |
| public int getTypeForName(String filename) { |
| final int userType= fUserNameMappings.getType(filename); |
| // final int pluginType= fPluginNameMappings.getType(filename); |
| // return userType != Team.UNKNOWN ? userType : pluginType; |
| return userType; |
| } |
| |
| @Override |
| public int getTypeForExtension(String extension) { |
| final int userType= fUserExtensionMappings.getType(extension); |
| final int pluginType= fPluginExtensionMappings.getType(extension); |
| return userType != Team.UNKNOWN ? userType : pluginType; |
| } |
| |
| @Override |
| public void addNameMappings(String[] names, int [] types) { |
| fUserNameMappings.addStringMappings(names, types); |
| } |
| |
| @Override |
| public void addExtensionMappings(String[] extensions, int [] types) { |
| fUserExtensionMappings.addStringMappings(extensions, types); |
| } |
| |
| @Override |
| public void setNameMappings(String[] names, int [] types) { |
| fUserNameMappings.setStringMappings(names, types); |
| } |
| |
| @Override |
| public void setExtensionMappings(String[] extensions, int [] types) { |
| fUserExtensionMappings.setStringMappings(extensions, types); |
| } |
| |
| @Override |
| public IStringMapping[] getNameMappings() { |
| return getMappings(fUserNameMappings, null);//fPluginNameMappings); |
| } |
| |
| @Override |
| public IStringMapping[] getExtensionMappings() { |
| return getMappings(fUserExtensionMappings, fPluginExtensionMappings); |
| } |
| |
| @Override |
| public int getType(IStorage storage) { |
| int type; |
| |
| final String name= storage.getName(); |
| if (name != null && (type= getTypeForName(name)) != Team.UNKNOWN) |
| return type; |
| |
| final String extension= getFileExtension(name); |
| if (extension != null && (type= getTypeForExtension(extension)) != Team.UNKNOWN) |
| return type; |
| |
| IContentType contentType = Platform.getContentTypeManager().findContentTypeFor(name); |
| if (contentType != null) { |
| IContentType textType = getTextContentType(); |
| if (contentType.isKindOf(textType)) { |
| return Team.TEXT; |
| } |
| } |
| |
| return Team.UNKNOWN; |
| } |
| |
| private IContentType getTextContentType() { |
| if (textContentType == null) |
| textContentType = Platform.getContentTypeManager().getContentType(IContentTypeManager.CT_TEXT); |
| return textContentType; |
| } |
| |
| @Override |
| public IStringMapping[] getDefaultNameMappings() { |
| // TODO: There is currently no extension point for this |
| return new IStringMapping[0];//getStringMappings(fPluginNameMappings.referenceMap()); |
| } |
| |
| @Override |
| public IStringMapping[] getDefaultExtensionMappings() { |
| return getStringMappings(fPluginExtensionMappings.referenceMap()); |
| } |
| |
| @Override |
| public boolean isKnownExtension(String extension) { |
| return fUserExtensionMappings.referenceMap().containsKey(extension) |
| || fPluginExtensionMappings.referenceMap().containsKey(extension); |
| } |
| |
| @Override |
| public boolean isKnownFilename(String filename) { |
| return fUserNameMappings.referenceMap().containsKey(filename); |
| // || fPluginNameMappings.referenceMap().containsKey(filename); |
| } |
| |
| private static String getFileExtension(String name) { |
| if (name == null) |
| return null; |
| int index = name.lastIndexOf('.'); |
| if (index == -1) |
| return null; |
| if (index == (name.length() - 1)) |
| return ""; //$NON-NLS-1$ |
| return name.substring(index + 1); |
| } |
| |
| private static IStringMapping [] getStringMappings(Map map) { |
| final IStringMapping [] result= new IStringMapping [map.size()]; |
| int index= 0; |
| for (Object element : map.entrySet()) { |
| final Map.Entry entry= (Map.Entry)element; |
| result[index++]= new StringMapping((String)entry.getKey(), ((Integer)entry.getValue()).intValue()); |
| } |
| return result; |
| } |
| |
| private IStringMapping [] getMappings(UserStringMappings userMappings, PluginStringMappings pluginMappings) { |
| final Map<String, Integer> mappings= new HashMap<>(); |
| if (pluginMappings != null) |
| mappings.putAll(pluginMappings.referenceMap()); |
| mappings.putAll(userMappings.referenceMap()); |
| return getStringMappings(mappings); |
| } |
| } |