CharsetDetector provides a facility for detecting the\n * charset or encoding of character data in an unknown format.\n * The input data can either be from an input stream or an array of bytes.\n * The result of the detection operation is a list of possibly matching\n * charsets, or, for simple use, you can just ask for a Java Reader that\n * will will work over the input data.\n * \n * Character set detection is at best an imprecise operation. The detection\n * process will attempt to identify the charset that best matches the characteristics\n * of the byte data, but the process is partly statistical in nature, and\n * the results can not be guaranteed to always be correct.\n *
\n * For best accuracy in charset detection, the input data should be primarily\n * in a single language, and a minimum of a few hundred bytes worth of plain text\n * in the language are needed. The detection process will attempt to\n * ignore html or xml style markup that could otherwise obscure the content.\n * stable ICU 3.4\n */\npublic class CharsetDetector {\n\n// Question: Should we have getters corresponding to the setters for input text\n// and declared encoding?\n\n// A thought: If we were to create our own type of Java Reader, we could defer\n// figuring out an actual charset for data that starts out with too much English\n// only ASCII until the user actually read through to something that didn't look\n// like 7 bit English. If nothing else ever appeared, we would never need to\n// actually choose the \"real\" charset. All assuming that the application just\n// wants the data, and doesn't care about a char set name.\n\n /**\n * Constructor\n * \n */\n public CharsetDetector() {\n }\n\n /**\n * Set the declared encoding for charset detection.\n * The declared encoding of an input text is an encoding obtained\n * from an http header or xml declaration or similar source that\n * can be provided as additional information to the charset detector.\n * A match between a declared encoding and a possible detected encoding\n * will raise the quality of that detected encoding by a small delta,\n * and will also appear as a \"reason\" for the match.\n *
\n * A declared encoding that is incompatible with the input data being\n * analyzed will not be added to the list of possible encodings.\n * \n * @param encoding The declared encoding\n * @return this\n *\n */\n public CharsetDetector setDeclaredEncoding(String encoding) {\n fDeclaredEncoding = encoding;\n return this;\n }\n \n /**\n * Set the input text (byte) data whose charset is to be detected.\n * \n * @param in the input text of unknown encoding\n * \n * @return This CharsetDetector\n *\n */\n public CharsetDetector setText(byte [] in) {\n fRawInput = in;\n fRawLength = in.length;\n \n return this;\n }\n \n private static final int kBufSize = 8000;\n\n /**\n * Set the input text (byte) data whose charset is to be detected.\n *
\n * The input stream that supplies the character data must have markSupported()\n * == true; the charset detection process will read a small amount of data,\n * then return the stream to its original position via\n * the InputStream.reset() operation. The exact amount that will\n * be read depends on the characteristics of the data itself.\n *\n * @param in the input text of unknown encoding\n * \n * @return This CharsetDetector\n *\n\t * @throws IOException if an I/O error occurs.\n *\n */\n public CharsetDetector setText(InputStream in) throws IOException {\n fInputStream = in;\n fInputStream.mark(kBufSize);\n fRawInput = new byte[kBufSize]; // Always make a new buffer because the\n // previous one may have come from the caller,\n // in which case we can't touch it.\n fRawLength = 0;\n int remainingLength = kBufSize;\n while (remainingLength > 0 ) {\n // read() may give data in smallish chunks, esp. for remote sources. Hence, this loop.\n int bytesRead = fInputStream.read(fRawInput, fRawLength, remainingLength);\n if (bytesRead <= 0) {\n break;\n }\n fRawLength += bytesRead;\n remainingLength -= bytesRead;\n }\n fInputStream.reset();\n \n return this;\n }\n\n \n /**\n * Return the charset that best matches the supplied input data.\n * Note though, that because the detection \n * only looks at the start of the input data,\n * there is a possibility that the returned charset will fail to handle\n * the full set of input data.\n *
\n * Raise an exception if \n *
null if there are no matches.\n *\n */\n public CharsetMatch detect() {\n// TODO: A better implementation would be to copy the detect loop from\n// detectAll(), and cut it short as soon as a match with a high confidence\n// is found. This is something to be done later, after things are otherwise\n// working.\n CharsetMatch[] matches = detectAll();\n \n if (matches == null || matches.length == 0) {\n return null;\n }\n \n return matches[0];\n }\n \n /**\n * Return an array of all charsets that appear to be plausible\n * matches with the input data. The array is ordered with the\n * best quality match first.\n * \n * Raise an exception if \n *
\n * This is a convenience method that is equivalent to\n * this.setDeclaredEncoding(declaredEncoding).setText(in).detect().getReader();\n *
\n * For the input stream that supplies the character data, markSupported()\n * must be true; the charset detection will read a small amount of data,\n * then return the stream to its original position via\n * the InputStream.reset() operation. The exact amount that will\n * be read depends on the characteristics of the data itself.\n *
\n * Raise an exception if no charsets appear to match the input data.\n * \n * @param in The source of the byte data in the unknown charset.\n *\n * @param declaredEncoding A declared encoding for the data, if available,\n * or null or an empty string if none is available.\n *\n\t * @return Reader to access the converted input data\n *\n */\n public Reader getReader(InputStream in, String declaredEncoding) {\n fDeclaredEncoding = declaredEncoding;\n \n try {\n setText(in);\n \n CharsetMatch match = detect();\n \n if (match == null) {\n return null;\n }\n return match.getReader();\n } catch (IOException e) {\n return null;\n }\n }\n\n /**\n * Autodetect the charset of an inputStream, and return a String\n * containing the converted input data.\n *
\n * This is a convenience method that is equivalent to\n * this.setDeclaredEncoding(declaredEncoding).setText(in).detect().getString();\n *
\n * Raise an exception if no charsets appear to match the input data.\n * \n * @param in The source of the byte data in the unknown charset.\n *\n * @param declaredEncoding A declared encoding for the data, if available,\n * or null or an empty string if none is available.\n *\n\t * @return a String containing the converted input data\n *\n */\n public String getString(byte[] in, String declaredEncoding) {\n fDeclaredEncoding = declaredEncoding;\n \n try {\n setText(in);\n \n CharsetMatch match = detect();\n \n if (match == null) {\n return null;\n }\n \n return match.getString(-1);\n } catch (IOException e) {\n return null;\n }\n }\n\n \n /**\n * Get the names of all charsets supported by CharsetDetector class.\n *
\n * Note: Multiple different charset encodings in a same family may use\n * a single shared name in this implementation. For example, this method returns\n * an array including \"ISO-8859-1\" (ISO Latin 1), but not including \"windows-1252\"\n * (Windows Latin 1). However, actual detection result could be \"windows-1252\"\n * when the input data matches Latin 1 code points with any points only available\n * in \"windows-1252\".\n *\n * @return an array of the names of all charsets supported by\n * \n * Instances of this class are created only by CharsetDetectors.\n * \n * Note: this class has a natural ordering that is inconsistent with equals.\n * The natural ordering is based on the match confidence value.\n *\n * stable ICU 3.4\n */\npublic class CharsetMatch implements Comparable \n * CAUTION: if the source of the byte data was an InputStream, a Reader\n * can be created for only one matching char set using this method. If more \n * than one charset needs to be tried, the caller will need to reset\n * the InputStream and create InputStreamReaders itself, based on the charset name.\n *\n * @return the Reader for the Unicode character data.\n *\n */\n public Reader getReader() {\n InputStream inputStream = fInputStream;\n \n if (inputStream == null) {\n inputStream = new ByteArrayInputStream(fRawInput, 0, fRawLength);\n }\n \n try {\n inputStream.reset();\n return new InputStreamReader(inputStream, getName());\n } catch (IOException e) {\n return null;\n }\n }\n\n /**\n * reate a Java String from Unicode character data corresponding\n * to the original byte data supplied to the Charset detect operation.\n *\n * @return a String created from the converted input data.\n *\n * @throws IOException if an IO error occurs.\n *\n */\n public String getString() throws IOException {\n return getString(-1);\n\n }\n\n /**\n * create a Java String from Unicode character data corresponding\n * to the original byte data supplied to the Charset detect operation.\n * The length of the returned string is limited to the specified size;\n * the string will be trunctated to this length if necessary. A limit value of\n * zero or less is ignored, and treated as no limit.\n *\n * @param maxLength The maximium length of the String to be created when the\n * source of the data is an input stream, or -1 for\n * unlimited length.\n * @return a String created from the converted input data.\n *\n * @throws IOException if an IO error occurs.\n *\n */\n String getString(int maxLength) throws IOException {\n String result;\n if (fInputStream != null) {\n StringBuilder sb = new StringBuilder();\n char[] buffer = new char[1024];\n Reader reader = getReader();\n int max = maxLength < 0? Integer.MAX_VALUE : maxLength;\n int bytesRead;\n \n while ((bytesRead = reader.read(buffer, 0, Math.min(max, 1024))) >= 0) {\n sb.append(buffer, 0, bytesRead);\n max -= bytesRead;\n }\n \n reader.close();\n \n return sb.toString();\n } else {\n String name = getName();\n /*\n * getName() may return a name with a suffix 'rtl' or 'ltr'. This cannot\n * be used to open a charset (e.g. IBM424_rtl). The ending '_rtl' or 'ltr'\n * should be stripped off before creating the string.\n */\n int startSuffix = !name.contains(\"_rtl\") ? name.indexOf(\"_ltr\") : name.indexOf(\"_rtl\");\n if (startSuffix > 0) {\n name = name.substring(0, startSuffix);\n }\n result = new String(fRawInput, name);\n }\n return result;\n\n }\n \n /**\n * Get an indication of the confidence in the charset detected.\n * Confidence values range from 0-100, with larger numbers indicating\n * a better match of the input data to the characteristics of the charset.\n * @return the confidence in the charset match\n */\n public int getConfidence() {\n return fConfidence;\n }\n\n /**\n * Get the name of the detected charset. \n * The name will be one that can be used with other APIs on the\n * platform that accept charset names. It is the \"Canonical name\"\n * as defined by the class java.nio.charset.Charset; for\n * charsets that are registered with the IANA charset registry,\n * this is the MIME-preferred registered name.\n *\n * @see java.nio.charset.Charset\n * @see java.io.InputStreamReader\n *\n * @return The name of the charset.\n *\n */\n public String getName() {\n return fCharsetName;\n }\n \n /**\n * Get the ISO code for the language of the detected charset. \n *\n * @return The ISO code for the language or \n * This folder is:\n * \n * If the default preferences folder doesn't exist, this method will create it.\n *\n * @return the path to the default trolCommander preferences folder.\n */\n public static AbstractFile getDefaultPreferencesFolder() {\n return FileFactory.getFile(getDefaultPreferencesFolderPath());\n }\n\n /**\n * Returns the path to the default muCommander preferences folder.\n * \n * This folder is:\n * \n * If the default preferences folder doesn't exist, this method will create it.\n *\n * @return the path to the default trolCommander preferences folder.\n */\n public static String getDefaultPreferencesFolderPath() {\n File folder;\n\n // Mac OS X specific folder (~/Library/Preferences/trolCommander)\n if (OsFamily.MAC_OS_X.isCurrent()) {\n folder = new File(System.getProperty(\"user.home\") + \"/Library/Preferences/trolCommander\");\n // For all other platforms, use generic folder (~/.trolcommander)\n } else {\n folder = new File(System.getProperty(\"user.home\"), \"/.trolcommander\");\n }\n\n // Makes sure the folder exists.\n if (!folder.exists()) {\n if (!folder.mkdir()) {\n LOGGER.warn(\"Could not create preference folder: {}\", folder.getAbsolutePath());\n }\n }\n return folder.getAbsolutePath();\n }\n\n /**\n * Returns the path to the folder that contains all the user's data.\n * \n * All modules that save user data to a file should do so in a file located in\n * the folder returned by this method.\n * \n * The value returned by this method can be set through {@link #setPreferencesFolder(File)}.\n * Otherwise, the {@link #getDefaultPreferencesFolder() default preference folder} will be\n * used.\n *\n * @return the path to the user's preference folder.\n * @see #setPreferencesFolder(AbstractFile)\n */\n public static AbstractFile getPreferencesFolder() {\n // If the preferences folder has been set, use it.\n if (prefFolder != null) {\n return prefFolder;\n }\n return getDefaultPreferencesFolder();\n }\n\n /**\n * Sets the path to the folder in which trolCommander will look for its preferences.\n * \n * If \n * If \n * If \r\n * This class is used to start muCommander. It will analyse command line\r\n * arguments, initialize the whole software and start the main window.\r\n *\r\n * @author Maxence Bernard, Nicolas Rinaudo, Oleg Trifonov\r\n */\r\npublic class TrolCommander {\r\n\tprivate static Logger logger;\r\n\r\n /** true while the application is launching, false after it has finished launching */\r\n private static boolean isLaunching = true;\r\n /** Launch lock. */\r\n private static final Object LAUNCH_LOCK = new Object();\r\n\r\n\r\n /**\r\n * Prevents initialization of the Note: the items list is refreshed each time the menu is selected. In other words, a new instance of AdbMenu\n * does not have to be created in order to see new devices.\n *\n * Created on 28/12/15.\n * @author Oleg Trifonov\n */\npublic abstract class AndroidMenu extends JMenu implements MenuListener {\n\n /**\n * Creates a new instance of \n * Two types of {@link CredentialsMapping} are used:\n * The returned credentials will match the given URL's scheme and host, but the path may differ so there is\n * no guarantee that the credentials will successfully authenticate the location.\n *\n * The best match (credentials with the 'closest' path to the provided location's path) is returned at the first\n * position ([0]), if there is at least one matching credentials instance. The returned array can be empty\n * (zero length) but never null.\n * \n * @param location the location to be compared against known credentials instances, both volatile and persistent\n * @return an array of CredentialsMapping matching the given URL's scheme and host, best match at the first position\n */\n public static CredentialsMapping[] getMatchingCredentials(FileURL location) {\n // Retrieve matches\n List Depending on value returned by {@link CredentialsMapping#isPersistent()}, the credentials will either be stored\n * in the volatile credentials list or the persistent one. Any existing credentials mapped to the same realm\n * will be replaced by the provided ones.\n *\n * This method should be called when new credentials have been entered by the user, after they have been validated\n * by the application (i.e. access was granted to the location).\n *\n * @param credentialsMapping credentials to be added to the list of known credentials\n */\n public static void addCredentials(CredentialsMapping credentialsMapping) {\n\n // Do not add if the credentials are empty\n if (credentialsMapping.getCredentials().isEmpty()) {\n return;\n }\n\n boolean persist = credentialsMapping.isPersistent();\n\n getLogger().trace(\"called, realm=\"+ credentialsMapping.getRealm()+\" isPersistent=\"+ credentialsMapping.isPersistent());\n getLogger().trace(\"before, persistentCredentials=\"+ persistentCredentialMappings);\n getLogger().trace(\"before, volatileCredentials=\"+ volatileCredentialMappings);\n\n if (persist) {\n replaceListElement(persistentCredentialMappings, credentialsMapping);\n volatileCredentialMappings.remove(credentialsMapping);\n } else {\n replaceListElement(volatileCredentialMappings, credentialsMapping);\n persistentCredentialMappings.removeElement(credentialsMapping);\n }\n\n getLogger().trace(\"after, persistentCredentials=\"+ persistentCredentialMappings);\n getLogger().trace(\"after, volatileCredentials=\"+ volatileCredentialMappings);\n }\n\n\n /**\n * Use the credentials and realm properties of the specified Any credentials contained by the Credentials are first looked for using {@link #getMatchingCredentials(com.mucommander.commons.file.FileURL)}.\n * If there is no match, guest credentials are retrieved from the URL and used (if any).\n *\n * @param location the FileURL to authenticate\n */\n private static void authenticateImplicit(FileURL location) {\n getLogger().trace(\"called, fileURL=\"+ location +\" containsCredentials=\"+ location.containsCredentials());\n\n CredentialsMapping[] creds = getMatchingCredentials(location);\n if (creds.length > 0) {\n authenticate(location, creds[0]);\n } else {\n Credentials guestCredentials = location.getGuestCredentials();\n if(guestCredentials!=null) {\n authenticate(location, new CredentialsMapping(guestCredentials, location.getRealm(), false));\n }\n }\n }\n\n\n /**\n * Looks for credentials matching the specified location in the given credentials Vector and adds them to the given\n * matches Vector.\n *\n * @param location the location to find matching credentials for\n * @param credentials the Vector containing the CredentialsMapping instances to compare to the given location\n * @param matches the Vector where matching CredentialsMapping instances will be added\n */\n private static void findMatches(FileURL location, List \n * The path of each matching CredentialsMapping' location is compared to the provided location's path: the more\n * folder parts match, the better. If both paths are equal, then the CredentialsMapping index is returned (perfect match).\n *\n * @param location the location to be compared against CredentialsMapping matches\n * @param matches CredentialsMapping instances matching the given location\n * @return the CredentialsMapping instance that best matches the given location, -1 if the given matches Vector is empty.\n */\n private static int getBestMatchIndex(FileURL location, List \n * The returned Vector instance is the one actually used by CredentialsManager, so use it with caution.\n *\n * @return the list of known volatile {@link CredentialsMapping}.\n */\n public static List \n * Any changes made to the Vector will be detected and will yield to writing the credentials file when\n * {@link #writeCredentials(boolean)} is called with false.\n *\n * @return the list of known persistent {@link CredentialsMapping}.\n */\n public static AlteredVector \n * Note: the returned {@link FileURL} does not contain any credentials.\n *\n * @return the location associated with the credentials.\n */\n public FileURL getRealm() {\n return realm;\n }\n\n /**\n * Returns \r\n * Note: the version attribute was introduced in muCommander 0.8.4.\r\n *\r\n * @return the muCommander version that was used to write the credentials file, Use {@link #getServices()} to get a list of currently available Bonjour services.\n *\n * @author Maxence Bernard\n * @see BonjourMenu\n */\npublic class BonjourDirectory implements ServiceListener {\n\tprivate static Logger logger;\n\t\n /** Singleton instance held to prevent garbage collection and also used for synchronization */\n private final static BonjourDirectory instance = new BonjourDirectory();\n /** Does all the hard work */\n private static JmDNS jmDNS;\n /** List of discovered and currently active Bonjour services */\n private static final List Note: the items list is refreshed each time the menu is selected. In other words, a new instance of BonjourMenu\n * does not have to be created in order to see new Bonjour services.\n *\n * @author Maxence Bernard\n */\npublic abstract class BonjourMenu extends JMenu implements MenuListener {\n\n /**\n * Creates a new instance of Bookmarks are simple name/location pairs:\n * \r\n * It monitors any changes made to the bookmarks and when changes are made, fires change events to registered\r\n * listeners.\r\n *\r\n * @author Maxence Bernard, Nicolas Rinaudo\r\n */\r\npublic class BookmarkManager implements VectorChangeListener {\r\n /** Whether we're currently loading the bookmarks or not. */\r\n private static boolean isLoading = false;\r\n\r\n /** Bookmarks file location */\r\n private static AbstractFile bookmarksFile;\r\n\r\n /** Default bookmarks file name */\r\n private static final String DEFAULT_BOOKMARKS_FILE_NAME = \"bookmarks.xml\";\r\n\r\n /** Bookmark instances */\r\n private static final AlteredVector \r\n * If it hasn't been changed through a call to {@link #setBookmarksFile(String)},\r\n * this method will return the default, system dependant bookmarks file.\r\n *\r\n * @return the path to the bookmark file.\r\n * @see #setBookmarksFile(String)\r\n * @throws IOException if there was a problem locating the default bookmarks file.\r\n */\r\n private static synchronized AbstractFile getBookmarksFile() throws IOException {\r\n if (bookmarksFile == null) {\r\n return PlatformManager.getPreferencesFolder().getChild(DEFAULT_BOOKMARKS_FILE_NAME);\r\n }\r\n return bookmarksFile;\r\n }\r\n\r\n /**\r\n * Sets the path to the bookmarks file.\r\n * \r\n * This is a convenience method and is strictly equivalent to calling \r\n * This is a convenience method and is strictly equivalent to calling Important: the returned Vector should not directly be used to\r\n * add or remove bookmarks, doing so won't trigger any event to registered bookmark listeners.\r\n * However, it is safe to modify bookmarks individually, events will be properly fired.\r\n * @return an {@link AlteredVector} that contains all bookmarks.\r\n */\r\n public static synchronized AlteredVector Listeners are stored as weak references so {@link #removeBookmarkListener(BookmarkListener)}\r\n * doesn't need to be called for listeners to be garbage collected when they're not used anymore.\r\n *\r\n * @param listener the BookmarkListener to add to the list of registered listeners.\r\n * @see #removeBookmarkListener(BookmarkListener)\r\n */\r\n public static void addBookmarkListener(BookmarkListener listener) {\r\n synchronized(listeners) {\r\n listeners.put(listener, null);\r\n }\r\n }\r\n\r\n /**\r\n * Removes the specified BookmarkListener from the list of registered listeners.\r\n *\r\n * @param listener the BookmarkListener to remove from the list of registered listeners.\r\n * @see #addBookmarkListener(BookmarkListener)\r\n */\r\n private static void removeBookmarkListener(BookmarkListener listener) {\r\n synchronized(listeners) {\r\n listeners.remove(listener);\r\n }\r\n }\r\n\r\n /**\r\n * Notifies all the registered bookmark listeners of a bookmark change. This can be :\r\n * If true is specified, any subsequent calls to fireBookmarksChanged will be ignored, until this method is\r\n * called again with false.\r\n * @param b whether to fire events.\r\n */\r\n public static synchronized void setFireEvents(boolean b) {\r\n if (b) {\r\n // Fire a bookmarks changed event if bookmarks were modified during event pause\r\n if (!fireEvents && lastBookmarkChangeTime >= lastEventPauseTime) {\r\n fireEvents = true;\r\n fireBookmarksChanged();\r\n }\r\n } else {\r\n // Remember pause start time\r\n if (fireEvents) {\r\n fireEvents = false;\r\n lastEventPauseTime = System.currentTimeMillis();\r\n }\r\n }\r\n }\r\n\r\n /////////////////////////////////////////\r\n // VectorChangeListener implementation //\r\n /////////////////////////////////////////\r\n\r\n public void elementsAdded(int startIndex, int nbAdded) {\r\n fireBookmarksChanged();\r\n }\r\n\r\n public void elementsRemoved(int startIndex, int nbRemoved) {\r\n fireBookmarksChanged();\r\n }\r\n\r\n public void elementChanged(int index) {\r\n fireBookmarksChanged();\r\n }\r\n\r\n\r\n\r\n // - Bookmark loading ------------------------------------------------------\r\n // -------------------------------------------------------------------------\r\n private static class Loader implements BookmarkBuilder {\r\n public void startBookmarks() {\r\n\r\n }\r\n\r\n public void endBookmarks() {\r\n\r\n }\r\n\r\n public void addBookmark(String name, String location, String parent) {\r\n BookmarkManager.addBookmark(new Bookmark(name, location, parent));\r\n }\r\n }\r\n}\r\n"
},
{
"path": "src/main/java/com/mucommander/bookmark/BookmarkParser.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see \n * Note: the version attribute was introduced in muCommander 0.8.4.\n *\n * @return the muCommander version that was used to write the bookmarks file, Disclaimer: this obviously is weak encryption at most, the key used being static and public, and XOR\n * encryption being easy to crack. This doesn't aim or pretend to be anything more than a way to scramble text\n * without requiring a master password in the application.\n *\n * @author Maxence Bernard\n */\npublic class XORCipher {\n\n\n /** Long enough key (256 bytes) to avoid having too much redundancy in small text strings. */\n private final static int[] NOT_SO_PRIVATE_KEY = {\n 161, 220, 156, 76, 177, 174, 56, 37, 98, 93, 224, 19, 160, 95, 69, 140,\n 91, 138, 33, 114, 248, 57, 179, 17, 54, 172, 249, 58, 26, 181, 167, 231,\n 241, 185, 218, 174, 37, 102, 100, 26, 16, 214, 119, 29, 118, 151, 135, 175,\n 245, 247, 160, 188, 77, 173, 109, 255, 73, 44, 186, 211, 117, 236, 204, 58,\n 246, 210, 128, 33, 234, 218, 82, 188, 78, 229, 180, 108, 247, 200, 3, 142,\n 206, 45, 165, 111, 96, 72, 76, 81, 238, 186, 240, 167, 185, 152, 68, 228,\n 87, 142, 145, 7, 74, 12, 106, 94, 15, 218, 155, 71, 87, 136, 58, 40,\n 246, 94, 7, 89, 29, 0, 78, 204, 70, 220, 240, 127, 59, 184, 109, 106\n };\n\n\n /**\n * Cyphers the given byte array using XOR symmetrical encryption with a static hard-coded key.\n *\n * @param b the byte array to encrypt/decrypt\n * @return the encrypted/decrypted byte array\n */\n private static byte[] xor(byte[] b) {\n int len = b.length;\n int keyLen = NOT_SO_PRIVATE_KEY.length;\n\n byte[] result = new byte[len];\n for (int i = 0; i < len; i++) {\n result[i] = (byte) (b[i] ^ NOT_SO_PRIVATE_KEY[i % keyLen]);\n }\n\n return result;\n }\n\n /**\n * Encrypts the given String using XOR cipher followed by Base64 encoding. The returned String will only contain\n * alphanumeric characters.\n *\n * @param s the String to encrypt\n * @return an XOR-Base64 encrypted String\n */\n public static String encryptXORBase64(String s) {\n // TODO:\n // Important: String.getBytes() returns bytes in the platform's default encoding, which might vary across\n // platforms. This may potentially cause problems when decrypting a string on a different platform from the one\n // which served to encrypt it.\n // It is however too late to change as it could prevent existing encrypted strings (credentials file) from being\n // loaded after the application is updated.\n return Base64Encoder.encode(xor(s.getBytes()));\n }\n\n\n /**\n * Decrypts the given XOR-Base64 encrypted String and throws an IOException if the given String is not properly\n * Base64-encoded.\n *\n * @param s a XOR-Base64 encrypted String\n * @return the decrypted String\n * @throws IOException if the given String is not properly Base64-encoded\n */\n public static String decryptXORBase64(String s) throws IOException {\n // TODO:\n // Important: new String() creates a string using the platform's default encoding, which might vary across\n // platforms. This may potentially cause problems when decrypting a string on a different platform from the one\n // which served to encrypt it.\n // It is however too late to change as it could prevent existing encrypted strings (credentials file) from being\n // loaded after the application is updated.\n return new String(xor(Base64Decoder.decodeAsBytes(s)));\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/bookmark/file/BookmarkFile.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see \n * Some methods need to have access to the underlying file. This, however, requires\n * resolving the path which can be time consuming. Using this method ensures that the\n * path is only resolved if necessary, and at most once.\n *\n * @return the \n * A bookmark is said to exist if and only if it is known to the {@link com.mucommander.bookmark.BookmarkManager}.\n *\n * @return \n// * Deleting a bookmark means unregistering it from the {@link com.mucommander.bookmark.BookmarkManager}.\n// *\n// */\n// @Override\n// public void delete() {\n// BookmarkManager.removeBookmark(bookmark);\n// }\n\n @Override\n @UnsupportedFileOperation\n public void delete() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.DELETE);\n }\n\n\n\n // - Bookmark duplication --------------------------------------------------\n // -------------------------------------------------------------------------\n\n /**\n * Tries to copy the bookmark to the specified destination.\n * \n * If the specified destination is an instance of \n * Note that this method will remove any previous bookmark of the same name.\n *\n * @param name name of the new bookmark.\n * @param location location of the new bookmark.\n */\n public void addBookmark(String name, String location, String parent) {\n // Creates the new bookmark and checks for conflicts.\n Bookmark newBookmark = new Bookmark(name, location, parent);\n // Old bookmark of the same name, if any.\n Bookmark oldBookmark = BookmarkManager.getBookmark(name);\n if (oldBookmark != null) {\n BookmarkManager.removeBookmark(oldBookmark);\n }\n // Adds the new bookmark.\n BookmarkManager.addBookmark(newBookmark);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/bookmark/file/BookmarkProtocolProvider.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see The only area this implementation is slow at, is checking for and removing expired elements which\n * requires traversing all values and An LRU (Least Recently Used) cache can contain a fixed number of items (the capacity). When capacity is reached,\r\n * the least recently used is removed. Each object retrieved with the {@link #get(Object) get()} method\r\n * makes the requested item the most recently used one. Similarly, each object inserted using the \r\n * {@link #add(Object, Object) add()} method makes the added item the most recently used one.\r\n *\r\n * This LRUCache provides an optional feature : the ability to assign a time-to-live for each or part of the\r\n * items added. When the time-to-live of an item expires, the item is automatically removed from the cache and won't\r\n * be returned by the {@link #get(Object) get()} method anymore.\r\n *\r\n * Implementation note: checking for expired items can be an expensive operation so it doesn't have\r\n * to be done as soon as the item has expired, the expired items can live a bit longer in the cache if necessary.\r\n * This method will return If the cache's capacity has been reached (cache is full):\r\n * \n * Will return the default, system dependant bookmarks file.\n *\n * @return the path to the bookmark file.\n * @throws java.io.IOException if there was a problem locating the default history file.\n */\n public static synchronized AbstractFile getHistoryFile(Type type) throws IOException {\n return PlatformManager.getPreferencesFolder().getChild(type.fileName);\n }\n\n\n public void clear() {\n history.clear();\n instance = null;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/cache/WindowsStorage.java",
"content": "/*\n * This file is part of trolCommander, http://www.trolsoft.ru/en/soft/trolcommander\n * Copyright (C) 2013-2016 Oleg Trifonov\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see \n * Will return the default, system dependant bookmarks file.\n *\n * @return the path to the bookmark file.\n * @throws java.io.IOException if there was a problem locating the default history file.\n */\n private static synchronized AbstractFile getHistoryFile() throws IOException {\n return PlatformManager.getPreferencesFolder().getChild(STORAGE_FILE_NAME);\n }\n\n\n public void clear() {\n if (records != null) {\n records.clear();\n }\n records = null;\n instance = null;\n }\n\n}\n"
},
{
"path": "src/main/java/com/mucommander/cache/package.html",
"content": " \n * Association file parsing is done through the {@link #read(InputStream,AssociationBuilder) read} method, which is\n * the only way to interact with this class.\n * \n * Note that while this class knows how to read the content of an association XML file, its role is not to interpret it. This\n * is done by instances of {@link AssociationBuilder}.\n *\n * @see AssociationsXmlConstants\n * @see AssociationBuilder\n * @see AssociationWriter\n * @author Nicolas Rinaudo\n */\npublic class AssociationReader extends DefaultHandler implements AssociationsXmlConstants {\n /** Where to send building messages. */\n private final AssociationBuilder builder;\n private boolean isInAssociation;\n\n\n\n /**\n * Creates a new command reader.\n * @param b where to send custom command events.\n */\n private AssociationReader(AssociationBuilder b) {\n builder = b;\n }\n\n\n /**\n * Parses the content of the specified input stream.\n * \n * This method will go through the specified input stream and notify the builder of any new association declaration it\n * encounters. Note that parsing is done in a very lenient fashion, and perfectly invalid XML files might not raise\n * an exception. This is not a flaw in the parser, and both allows muCommander to be error resilient and the associations\n * file format to be extended without having to rewrite most of this code.\n * \n * Note that even if an error occurs, both of the builder's {@link AssociationBuilder#startBuilding()} and\n * {@link AssociationBuilder#endBuilding()} methods will still be called. Parsing will stop at the first error\n * however, so while the builder is guaranteed to receive correct messages, it might not receive all declared\n * associations.\n *\n * @param in where to read association data from.\n * @param b where to send building events to.\n * @throws IOException if any IO error occurs.\n * @throws CommandException if any parse error occurs\n * @see #read(InputStream,AssociationBuilder)\n */\n public static void read(InputStream in, AssociationBuilder b) throws IOException, CommandException {\n b.startBuilding();\n try {\n SAXParserFactory.newInstance().newSAXParser().parse(in, new AssociationReader(b));\n } catch(ParserConfigurationException | SAXException e) {\n throw new CommandException(e);\n } finally {\n b.endBuilding();\n }\n }\n\n\n /**\n * This method is public as an implementation side effect and should not be called directly.\n */\n @Override\n public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {\n String buffer;\n\n try {\n if (!isInAssociation) {\n if (qName.equals(ELEMENT_ASSOCIATION)) {\n // Makes sure the required attributes are present.\n if ((buffer = attributes.getValue(ATTRIBUTE_COMMAND)) == null) {\n return;\n }\n\n isInAssociation = true;\n builder.startAssociation(buffer);\n }\n } else {\n switch (qName) {\n case ELEMENT_MASK:\n String caseSensitive;\n\n if ((buffer = attributes.getValue(ATTRIBUTE_VALUE)) == null) {\n return;\n }\n if ((caseSensitive = attributes.getValue(ATTRIBUTE_CASE_SENSITIVE)) != null) {\n builder.setMask(buffer, caseSensitive.equals(VALUE_TRUE));\n } else {\n builder.setMask(buffer, true);\n }\n break;\n case ELEMENT_IS_HIDDEN:\n if ((buffer = attributes.getValue(ATTRIBUTE_VALUE)) == null) {\n return;\n }\n builder.setIsHidden(buffer.equals(VALUE_TRUE));\n break;\n case ELEMENT_IS_SYMLINK:\n if ((buffer = attributes.getValue(ATTRIBUTE_VALUE)) == null) {\n return;\n }\n builder.setIsSymlink(buffer.equals(VALUE_TRUE));\n break;\n case ELEMENT_IS_READABLE:\n if ((buffer = attributes.getValue(ATTRIBUTE_VALUE)) == null) {\n return;\n }\n builder.setIsReadable(buffer.equals(VALUE_TRUE));\n break;\n case ELEMENT_IS_WRITABLE:\n if ((buffer = attributes.getValue(ATTRIBUTE_VALUE)) == null) {\n return;\n }\n builder.setIsWritable(buffer.equals(VALUE_TRUE));\n break;\n case ELEMENT_IS_EXECUTABLE:\n if ((buffer = attributes.getValue(ATTRIBUTE_VALUE)) == null) {\n return;\n }\n builder.setIsExecutable(buffer.equals(VALUE_TRUE));\n break;\n }\n }\n } catch(CommandException e) {\n throw new SAXException(e);\n }\n }\n\n /**\n * This method is public as an implementation side effect, but should not be called directly.\n */\n @Override\n public void endElement(String uri, String localName, String qName) throws SAXException {\n if (qName.equals(ELEMENT_ASSOCIATION) && isInAssociation) {\n try {\n builder.endAssociation();\n } catch(CommandException e) {\n throw new SAXException(e);\n }\n isInAssociation = false;\n }\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/command/AssociationWriter.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see \n * \n * This interface is only meant as a convenient way of sharing the XML\n * file format between the {@link AssociationWriter} and {@link AssociationReader}. It will be removed\n * at bytecode optimisation time.\n * \n * Associations XML files must match the following DTD:\n * \n * A command is composed of three elements:\n * \n * The basic command syntax is fairly simple:\n * \n * It's also possible to include keywords in a command:\n * \n * Once a \n * A command's executable tokens are typically meant to be used with {@link com.mucommander.process.ProcessRunner#execute(String[], AbstractFile)}\n * in order to generate instances of {@link com.mucommander.process.AbstractProcess}.\n *\n * @author Nicolas Rinaudo\n * @see CommandManager\n * @see com.mucommander.process.ProcessRunner\n * @see com.mucommander.process.AbstractProcess\n */\npublic class Command implements Comparable \n * This is a convenience constructor and is strictly equivalent to calling\n * \n * This is a convenience constructor and is strictly equivalent to calling\n * \n * Returns true if command contains keywords referencing selected file, e.g. $f,$n,$p,$e,$b.\n * Returns false otherwise, e.g. $j, $xyz, etc.\n *\n * @return whether this command contains keywords referencing selected file.\n */\n public synchronized boolean hasSelectedFileKeyword() {\n String[] tokens = getTokens();\n for (String token : tokens) {\n if (token.length() >= 2 && token.charAt(0) == KEYWORD_HEADER) {\n char ch2 = token.charAt(1);\n if (ch2 == KEYWORD_PATH || ch2 == KEYWORD_NAME || ch2 == KEYWORD_EXTENSION || ch2 == KEYWORD_NAME_WITHOUT_EXTENSION ||\n ch2 == KEYWORD_PARENT) {\n return true;\n }\n }\n }\n // No token with file referencing keyword found\n return false;\n }\n\n /**\n * Returns \n * If it hasn't been set, returns this command's alias.\n *\n * @return the command's display name.\n */\n public synchronized String getDisplayName() {\n return displayName != null ? displayName : alias;\n }\n\n /**\n * Returns \n * Different classes, such as {@link CommandManager} or {@link CommandReader}, know how to\n * generate a list of commands - from instances loaded in memory or from a file, for example.\n * Implementing \n * Instances of \n * A (fairly useless) implementation might look like:\n * \r\n * This is a convenience method and is strictly equivalent to calling\r\n * \r\n * This is a convenience method and is stricly equivalent to calling\r\n * \r\n * This method guarantees that the builder's {@link CommandBuilder#startBuilding() startBuilding()} and\r\n * {@link CommandBuilder#endBuilding() endBuilding()} methods will both be called even if an error occurs.\r\n * If that happens however, it is entirely possible that not all commands will be passed to\r\n * the builder.\r\n *\r\n * @param builder object that will receive commands list building messages.\r\n * @param type if not null then build only commands with specified type\r\n * @throws CommandException if anything goes wrong.\r\n */\r\n public static void buildCommands(CommandBuilder builder, CommandType type) throws CommandException {\r\n builder.startBuilding();\r\n\r\n try {\r\n \t// Goes through all the registered commands.\r\n \tfor (Command command : commands()) {\r\n if (type == null || command.getType() == type) {\r\n builder.addCommand(command);\r\n }\r\n }\r\n } finally {\r\n builder.endBuilding();\r\n }\r\n }\r\n\r\n\r\n\r\n // - Associations building -------------------------------------------------\r\n // -------------------------------------------------------------------------\r\n private static void buildFilter(FileFilter filter, AssociationBuilder builder) throws CommandException {\r\n // Filter on the file type.\r\n if (filter instanceof AttributeFileFilter) {\r\n AttributeFileFilter attributeFilter = (AttributeFileFilter)filter;\r\n\r\n switch (attributeFilter.getAttribute()) {\r\n case HIDDEN:\r\n builder.setIsHidden(!attributeFilter.isInverted());\r\n break;\r\n\r\n case SYMLINK:\r\n builder.setIsSymlink(!attributeFilter.isInverted());\r\n break;\r\n }\r\n } else if (filter instanceof PermissionsFileFilter) {\r\n PermissionsFileFilter permissionFilter = (PermissionsFileFilter)filter;\r\n\r\n switch(permissionFilter.getPermission()) {\r\n case PermissionTypes.READ_PERMISSION:\r\n builder.setIsReadable(permissionFilter.getFilter());\r\n break;\r\n\r\n case PermissionTypes.WRITE_PERMISSION:\r\n builder.setIsWritable(permissionFilter.getFilter());\r\n break;\r\n\r\n case PermissionTypes.EXECUTE_PERMISSION:\r\n builder.setIsExecutable(permissionFilter.getFilter());\r\n break;\r\n }\r\n } else if (filter instanceof RegexpFilenameFilter) {\r\n RegexpFilenameFilter regexpFilter = (RegexpFilenameFilter)filter;\r\n\r\n builder.setMask(regexpFilter.getRegularExpression(), regexpFilter.isCaseSensitive());\r\n }\r\n }\r\n\r\n /**\r\n * Passes all known file associations to the specified builder.\r\n * \r\n * This method guarantees that the builder's {@link AssociationBuilder#startBuilding() startBuilding()} and\r\n * {@link AssociationBuilder#endBuilding() endBuilding()} methods will both be called even if an error occurs.\r\n * If that happens however, it is entirely possible that not all associations will be passed to\r\n * the builder.\r\n *\r\n * @param builder object that will receive association list building messages.\r\n * @throws CommandException if anything goes wrong.\r\n */\r\n public static void buildAssociations(AssociationBuilder builder) throws CommandException {\r\n builder.startBuilding();\r\n\r\n // Goes through all the registered associations.\r\n try {\r\n for (CommandAssociation current : associations) {\r\n builder.startAssociation(current.getCommand().getAlias());\r\n\r\n FileFilter filter = current.getFilter();\r\n if (filter instanceof ChainedFileFilter) {\r\n Iterator \r\n * This method cannot guarantee the file's existence, and it's up to the caller\r\n * to deal with the fact that the user might not actually have created custom\r\n * associations.\r\n * \r\n * This method's return value can be modified through {@link #setAssociationFile(String)}.\r\n * If this wasn't called, the default path will be used: {@link #DEFAULT_ASSOCIATION_FILE_NAME}\r\n * in the {@link com.mucommander.PlatformManager#getPreferencesFolder() preferences} folder.\r\n *\r\n * @return the path to the custom associations XML file.\r\n * @see #setAssociationFile(String)\r\n * @see #loadAssociations()\r\n * @see #writeAssociations()\r\n * @throws IOException if there was an error locating the default commands file.\r\n */\r\n public static AbstractFile getAssociationFile() throws IOException {\r\n if (associationFile == null) {\r\n return PlatformManager.getPreferencesFolder().getChild(DEFAULT_ASSOCIATION_FILE_NAME);\r\n }\r\n return associationFile;\r\n }\r\n\r\n /**\r\n * Sets the path to the custom associations file.\r\n * \r\n * This is a convenience method and is strictly equivalent to calling \r\n * This is a convenience method and is strictly equivalent to calling \r\n * The command files will be loaded as a backed-up file (see {@link BackupInputStream}).\r\n * Its format is described {@link AssociationsXmlConstants here}.\r\n *\r\n * @throws IOException if an IO error occurs.\r\n * @throws CommandException thrown when errors occur while building custom commands\r\n * @see #writeAssociations()\r\n * @see #getAssociationFile()\r\n * @see #setAssociationFile(String)\r\n */\r\n public static void loadAssociations() throws IOException, CommandException {\r\n AbstractFile file = getAssociationFile();\r\n getLogger().debug(\"Loading associations from file: \" + file.getAbsolutePath());\r\n\r\n // Tries to load the associations file.\r\n // Associations are not considered to be modified by this. \r\n //InputStream in = null;\r\n try (InputStream in = new BackupInputStream(file)) {\r\n AssociationReader.read(in, new AssociationFactory());\r\n } finally {\r\n wereAssociationsModified = false;\r\n }\r\n }\r\n\r\n /**,\r\n * Writes all registered associations to the custom associations file.\r\n * \r\n * Data will be written to the path returned by {@link #getAssociationFile()}. Note, however,\r\n * that this method will not actually do anything if the association list hasn't been modified\r\n * since the last time it was saved.\r\n * \r\n * The association files will be saved as a backed-up file (see {@link BackupOutputStream}).\r\n * Its format is described {@link AssociationsXmlConstants here}.\r\n *\r\n * @throws IOException if an I/O error occurs.\r\n * @throws CommandException if an error occurs.\r\n * @see #loadAssociations()\r\n * @see #getAssociationFile()\r\n * @see #setAssociationFile(String)\r\n */\r\n public static void writeAssociations() throws CommandException, IOException {\r\n // Do not save the associations if they were not modified.\r\n if (!wereAssociationsModified) {\r\n getLogger().debug(\"Custom file associations not modified, skip saving.\");\r\n return;\r\n }\r\n getLogger().debug(\"Writing associations to file: \" + getAssociationFile());\r\n\r\n // Writes the associations.\r\n try (BackupOutputStream out = new BackupOutputStream(getAssociationFile())) {\r\n buildAssociations(new AssociationWriter(out));\r\n wereAssociationsModified = false;\r\n }\r\n }\r\n\r\n\r\n\r\n // - Commands reading/writing ----------------------------------------------\r\n // -------------------------------------------------------------------------\r\n /**\r\n * Returns the path to the custom commands XML file.\r\n * \r\n * This method cannot guarantee the file's existence, and it's up to the caller\r\n * to deal with the fact that the user might not actually have created custom\r\n * commands.\r\n * \r\n * This method's return value can be modified through {@link #setCommandFile(String)}.\r\n * If this wasn't called, the default path will be used: {@link #DEFAULT_COMMANDS_FILE_NAME}\r\n * in the {@link com.mucommander.PlatformManager#getPreferencesFolder() preferences} folder.\r\n *\r\n * @return the path to the custom commands XML file.\r\n * @see #setCommandFile(String)\r\n * @see #loadCommands()\r\n * @see #writeCommands()\r\n * @throws IOException if there was some error locating the default commands file.\r\n */\r\n public static AbstractFile getCommandFile() throws IOException {\r\n if (commandsFile == null) {\r\n return PlatformManager.getPreferencesFolder().getChild(DEFAULT_COMMANDS_FILE_NAME);\r\n }\r\n return commandsFile;\r\n }\r\n\r\n /**\r\n * Sets the path to the custom commands file.\r\n * \r\n * This is a convenience method and is strictly equivalent to calling \r\n * This is a convenience method and is strictly equivalent to calling \r\n * Data will be written to the path returned by {@link #getCommandFile()}. Note, however,\r\n * that this method will not actually do anything if the command list hasn't been modified\r\n * since the last time it was saved.\r\n * \r\n * The command files will be saved as a backed-up file (see {@link BackupOutputStream}).\r\n * Its format is described {@link CommandsXmlConstants here}.\r\n *\r\n * @throws IOException if an I/O error occurs.\r\n * @throws CommandException if an error occurs.\r\n * @see #loadCommands()\r\n * @see #getCommandFile()\r\n * @see #setCommandFile(String)\r\n */\r\n public static void writeCommands() throws IOException, CommandException {\r\n // Only saves the command if they were modified since the last time they were written.\r\n if (!wereCommandsModified) {\r\n getLogger().debug(\"Custom commands not modified, skip saving.\");\r\n return;\r\n }\r\n getLogger().debug(\"Writing custom commands to file: \" + getCommandFile());\r\n\r\n // Writes the commands.\r\n try (BackupOutputStream out = new BackupOutputStream(getCommandFile())) {\r\n buildCommands(new CommandWriter(out), CommandType.NORMAL_COMMAND);\r\n wereCommandsModified = false;\r\n }\r\n }\r\n\r\n /**\r\n * Loads the custom commands XML File.\r\n * \r\n * The command files will be loaded as a backed-up file (see {@link BackupInputStream}).\r\n * Its format is described {@link CommandsXmlConstants here}.\r\n *\r\n * @throws IOException if an I/O error occurs.\r\n * @see #writeCommands()\r\n * @see #getCommandFile()\r\n * @see #setCommandFile(String)\r\n */\r\n public static void loadCommands() throws IOException, CommandException {\r\n AbstractFile file = getCommandFile();\r\n getLogger().debug(\"Loading custom commands from: \" + file.getAbsolutePath());\r\n\r\n // Tries to load the commands file.\r\n // Commands are not considered to be modified by this.\r\n try (InputStream in = new BackupInputStream(file)) {\r\n CommandReader.read(in, new CommandManager());\r\n } finally {\r\n wereCommandsModified = false;\r\n }\r\n }\r\n\r\n /*\r\n private static void registerDefaultCommand(String alias, String command, String display) {\r\n if(getCommandForAlias(alias) == null) {\r\n if(command != null) {\r\n // try {registerCommand(CommandParser.getCommand(alias, command, Command.SYSTEM_COMMAND, display));}\r\n try {registerCommand(new Command(alias, command, Command.SYSTEM_COMMAND, display));}\r\n catch(Exception e) {AppLogger.fine(\"Failed to register \" + command + \": \" + e.getMessage());}\r\n }\r\n }\r\n }\r\n */\r\n\r\n\r\n // - Unused methods --------------------------------------------------------\r\n // -------------------------------------------------------------------------\r\n /**\r\n * This method is public as an implementation side effect and must not be called directly.\r\n */\r\n public void startBuilding() {}\r\n\r\n /**\r\n * This method is public as an implementation side effect and must not be called directly.\r\n */\r\n public void endBuilding() {}\r\n\r\n\r\n public static List \n * Command file parsing is done through the {@link #read(InputStream,CommandBuilder) read} method, which is\n * the only way to interact with this class.\n * \n * Note that while this class knows how to read the content of a command XML file, its role is not to interpret it. This\n * is done by instances of {@link CommandBuilder}.\n *\n * @see CommandsXmlConstants\n * @see CommandBuilder\n * @see CommandWriter\n * @author Nicolas Rinaudo\n */\npublic class CommandReader extends DefaultHandler implements CommandsXmlConstants {\n /** Where to send building messages. */\n private final CommandBuilder builder;\n\n\n /**\n * Creates a new command reader.\n * @param b where to send custom command events.\n */\n private CommandReader(CommandBuilder b) {\n builder = b;\n }\n\n\n\n /**\n * Parses the content of the specified input stream.\n * \n * This method will go through the specified input stream and notify the builder of any new command declaration it\n * encounters. Note that parsing is done in a very lenient fashion, and perfectly invalid XML files might not raise\n * an exception. This is not a flaw in the parser, and both allows muCommander to be error resilient and the commands\n * file format to be extended without having to rewrite most of this code.\n * \n * Note that even if an error occurs, both of the builder's {@link CommandBuilder#startBuilding()} and\n * {@link CommandBuilder#endBuilding()} methods will still be called. Parsing will stop at the first error\n * however, so while the builder is guaranteed to receive correct messages, it might not receive all declared\n * commands.\n *\n * @param in where to read command data from.\n * @param b where to send building events to.\n * @throws IOException thrown if any error occurs.\n */\n public static void read(InputStream in, CommandBuilder b) throws CommandException, IOException {\n b.startBuilding();\n try {\n SAXParserFactory.newInstance().newSAXParser().parse(in, new CommandReader(b));\n } catch(ParserConfigurationException | SAXException e) {\n throw new CommandException(e);\n } finally {\n b.endBuilding();\n }\n }\n\n\n\n /**\n * This method is public as an implementation side effect and should not be called directly.\n */\n @Override\n public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {\n // New custom command declaration.\n if (qName.equals(ELEMENT_COMMAND)) {\n String alias = attributes.getValue(ATTRIBUTE_ALIAS);\n String command = attributes.getValue(ATTRIBUTE_VALUE);\n String fileMask = attributes.getValue(ATTRIBUTE_FILEMASK);\n\n // Makes sure the required attributes are there.\n if (alias != null && command != null) {\n \tCommandType type = CommandType.parseCommandType(attributes.getValue(ATTRIBUTE_TYPE));\n \tString display = attributes.getValue(ATTRIBUTE_DISPLAY);\n\n \t// Creates the command and passes it to the builder.\n \ttry {\n builder.addCommand(new Command(alias, command, type, display, fileMask));\n } catch (CommandException e) {\n throw new SAXException(e);\n }\n }\n }\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/command/CommandType.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see \n * Note that this method is not strict in the arguments it receives:\n * \n * \r\n * This interface is only meant as a convenient way of sharing the XML\r\n * file format between the {@link com.mucommander.command.CommandWriter}\r\n * and {@link CommandReader}. It will be removed at bytecode optimisation time.\r\n * \r\n * Commands XML files must match the following DTD:\r\n * \n * Events are triggered when:\n * It is however not aware of modifications that are made to the contained objects themselves.\n *\n * @author Maxence Bernard\n */\npublic class AlteredVector Listeners are stored as weak references so {@link #removeVectorChangeListener(VectorChangeListener)}\n * doesn't need to be called for listeners to be garbage collected when they're not used anymore.\n *\n * @param listener the VectorChangeListener to add to the list of registered listeners.\n * @see #removeVectorChangeListener(VectorChangeListener)\n */\n public void addVectorChangeListener(VectorChangeListener listener) {\n listeners.put(listener, null);\n }\n\n /**\n * Removes the specified VectorChangeListener from the list of registered listeners.\n *\n * @param listener the VectorChangeListener to remove from the list of registered listeners.\n * @see #addVectorChangeListener(VectorChangeListener)\n */\n public void removeVectorChangeListener(VectorChangeListener listener) {\n listeners.remove(listener);\n }\n\n\n /**\n * This method is called when one or more elements has been added to this AlteredVector to notify listeners.\n *\n * @param startIndex index at which the first element has been added\n * @param nbAdded number of elements added\n */\n private void fireElementsAddedEvent(int startIndex, int nbAdded) {\n for (VectorChangeListener listener : listeners.keySet()) {\n listener.elementsAdded(startIndex, nbAdded);\n }\n }\n\n /**\n * This method is called when one or more elements has been removed from this AlteredVector to notify listeners.\n *\n * @param startIndex index at which the first element has been removed\n * @param nbRemoved number of elements removed\n */\n private void fireElementsRemovedEvent(int startIndex, int nbRemoved) {\n for (VectorChangeListener listener : listeners.keySet()) {\n listener.elementsRemoved(startIndex, nbRemoved);\n }\n }\n\n /**\n * This method is called when an element has been changed in this AlteredVector to notify listeners.\n *\n * @param index index of the element that has been changed\n */\n private void fireElementChangedEvent(int index) {\n for (VectorChangeListener listener : listeners.keySet()) {\n listener.elementChanged(index);\n }\n }\n\n\n @Override\n public void setElementAt(E o, int i) {\n super.setElementAt(o, i);\n\n fireElementChangedEvent(i);\n }\n\n @Override\n public E set(int i, E o) {\n o = super.set(i, o);\n\n fireElementChangedEvent(i);\n\n return o;\n }\n\n @Override\n public void insertElementAt(E o, int i) {\n super.insertElementAt(o, i);\n\n fireElementsAddedEvent(i, 1);\n }\n\n @Override\n public void add(int i, E o) {\n insertElementAt(o, i);\n\n fireElementsAddedEvent(i, 1);\n }\n\n @Override\n public void addElement(E o) {\n super.addElement(o);\n\n fireElementsAddedEvent(size()-1, 1);\n }\n\n @Override\n public boolean add(E o) {\n addElement(o);\n\n fireElementsAddedEvent(size()-1, 1);\n\n return true;\n }\n\n @Override\n public boolean addAll(Collection collection) {\n int sizeBefore = size();\n\n boolean b = super.addAll(collection);\n\n fireElementsAddedEvent(sizeBefore, size()-sizeBefore);\n\n return b;\n }\n\n @Override\n public boolean addAll(int i, Collection collection) {\n int sizeBefore = size();\n\n boolean b = super.addAll(i, collection);\n\n fireElementsAddedEvent(i, size()-sizeBefore);\n\n return b;\n }\n\n @Override\n public void removeElementAt(int i) {\n super.removeElementAt(i);\n\n fireElementsRemovedEvent(i, 1);\n }\n\n @Override\n public E remove(int i) {\n E o = super.remove(i);\n\n fireElementsRemovedEvent(i, 1);\n\n return o;\n }\n\n @Override\n public boolean removeElement(Object o) {\n int index = indexOf(o);\n\n if(index==-1)\n return false;\n\n removeElementAt(index);\n\n return true;\n }\n\n @Override\n public boolean remove(Object o) {\n return removeElement(o);\n }\n\n @Override\n public void removeAllElements() {\n int sizeBefore = size();\n\n super.removeAllElements();\n\n fireElementsRemovedEvent(0, sizeBefore);\n }\n\n @Override\n public void clear() {\n removeAllElements();\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/collections/Enumerator.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see Those classes need to be registered as listeners to receive those events, this can be done by calling\n * {@link AlteredVector#addVectorChangeListener(VectorChangeListener)}.\n *\n * @author Maxence Bernard\n */\npublic interface VectorChangeListener {\n\n /**\n * This method is called when one or more elements has been added to the AlteredVector.\n *\n * @param startIndex index at which the first element has been added\n * @param nbAdded number of elements added\n */\n void elementsAdded(int startIndex, int nbAdded);\n\n /**\n * This method is called when one or more elements has been removed from the AlteredVector.\n *\n * @param startIndex index at which the first element has been removed\n * @param nbRemoved number of elements removed\n */\n void elementsRemoved(int startIndex, int nbRemoved);\n\n /**\n * This method is called when an element has been changed in the AlteredVector.\n *\n * @param index index of the element that has been changed\n */\n void elementChanged(int index);\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/BufferedConfigurationExplorer.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see \n * This behaves exactly as a {@link ConfigurationExplorer}, but keeps track of its own path. This is meant\n * for instances of {@link Configuration} to prune empty branches.\n *\n * @author Nicolas Rinaudo\n */\nclass BufferedConfigurationExplorer extends ConfigurationExplorer {\n /** Sections that have been passed through. */\n private final Stack \n * A \n * Configuration variable names follow the same convention as Java System properties: a serie of strings\n * separated by periods. By convention, all but the last string are called configuration sections, while\n * the last one is the variable's name. When we refer to a variable's fully qualified name, we're talking\n * about the whole period-separated name. \n * While the \n * By default, configuration data is assumed to be in the standard muCommander file format (described in\n * {@link XmlConfigurationReader}). However, application writers can modify that to any format they want\n * through the {@link #setReaderFactory(ConfigurationReaderFactory) setReaderFactory} and\n * {@link #setWriterFactory(ConfigurationWriterFactory) setWriterFactory} methods.\n *\n * \n * While \n * Classes that need to monitor the state of the configuration in order, for example, to react to changes\n * dynamically rather than wait for an application reboot can implement the {@link ConfigurationListener}\n * interface and register themselves through\n * {@link #addConfigurationListener(ConfigurationListener) addConfigurationListener}. This guarantees that they\n * will receive configuration events whenever a modification occurs. \n * The resulting instance will use default {@link XmlConfigurationReader readers} and\n * {@link XmlConfigurationWriter writers}.\n * \n * Note that until the {@link #setSource(ConfigurationSource) setSource} method has been\n * invoked, calls to read or write methods without a stream parameter will fail.\n */\n public Configuration() {\n }\n\n /**\n * Creates a new instance of \n * The resulting instance will use the default {@link XmlConfigurationReader readers} and\n * {@link XmlConfigurationWriter writers}.\n *\n * @param source where the resulting instance will look for its configuration data.\n */\n public Configuration(ConfigurationSource source) {\n setSource(source);\n }\n\n /**\n * Creates a new instance of \n * Note that until the {@link #setSource(ConfigurationSource) setSource} method has been\n * invoked, calls to read or write methods without a stream parameter will fail.\n *\n * @param reader factory for configuration readers.\n * @param writer factory for configuration writers.\n */\n public Configuration(ConfigurationReaderFactory reader, ConfigurationWriterFactory writer) {\n setReaderFactory(reader);\n setWriterFactory(writer);\n }\n\n /**\n * Creates a new instance of \n * In order to reset the configuration to its default reader factory, application writers can call this method\n * with a \n * By default, this method will return an {@link XmlConfigurationReader XML reader} factory.\n * This can be modified by calling {@link #setReaderFactory(ConfigurationReaderFactory) setReaderFactory}.\n *\n * @return the factory that is being used to create reader instances.\n * @see #setReaderFactory(ConfigurationReaderFactory)\n */\n private ConfigurationReaderFactory getReaderFactory() {\n synchronized(readerLock) {\n if (readerFactory == null) {\n return XmlConfigurationReader.FACTORY;\n }\n return readerFactory;\n }\n }\n\n\n /**\n * Sets the factory that will be used to create writer instances.\n * \n * In order to reset the configuration to its default writer factory, application writers can call\n * this method will a \n * By default, this method will return an {@link XmlConfigurationWriter} factory. However, this\n * can be modified by calling {@link #setWriterFactory(ConfigurationWriterFactory) setWriterFactory}.\n *\n * @return the factory that is being used to create writer instances.\n * @see #setWriterFactory(ConfigurationWriterFactory)\n */\n private ConfigurationWriterFactory getWriterFactory() {\n synchronized(writerLock) {\n if (writerFactory == null) {\n return XmlConfigurationWriter.FACTORY;\n }\n return writerFactory;\n }\n }\n\n\n /**\n * Loads configuration from the specified input stream, using the specified configuration reader.\n * @param in where to read the configuration from.\n * @param reader reader that will be used to interpret the content of \n * This method will use the configuration reader set by {@link #setReaderFactory(ConfigurationReaderFactory)} if any,\n * or an {@link XmlConfigurationReader} instance if not.\n *\n * @param in where to read the configuration from.\n * @throws ConfigurationException if a configuration error occurs.\n * @throws ConfigurationFormatException if a syntax error occurs in the configuration data.\n * @throws ConfigurationStructureException if the configuration data doesn't describe a valid configuration tree.\n * @throws ReaderConfigurationException if the {@link ConfigurationReaderFactory} isn't properly configured.\n * @throws IOException if an I/O error occurs.\n * @see #read()\n * @see #read(ConfigurationReader)\n * @see #read(Reader,ConfigurationReader)\n * @deprecated Application developers should use {@link #read(Reader)} instead. This method assumes the specified\n * {@link InputStream} to be \n * This method will use the configuration reader set by {@link #setReaderFactory(ConfigurationReaderFactory)} if any,\n * or an {@link XmlConfigurationReader} instance if not.\n *\n * @param in where to read the configuration from.\n * @throws ConfigurationException if a configuration error occurs.\n * @throws ConfigurationFormatException if a syntax error occurs in the configuration data.\n * @throws ConfigurationStructureException if the configuration data doesn't describe a valid configuration tree.\n * @throws ReaderConfigurationException if the {@link ConfigurationReaderFactory} isn't properly configured.\n * @throws IOException if an I/O error occurs.\n * @see #read()\n * @see #read(ConfigurationReader)\n * @see #read(Reader,ConfigurationReader)\n */\n public void read(Reader in) throws ConfigurationException, IOException {\n read(in, getReaderFactory().getReaderInstance());\n }\n\n /**\n * Loads configuration using the specified configuration reader.\n * \n * This method will use the input stream provided by {@link #setSource(ConfigurationSource)} if any, or\n * fail otherwise.\n *\n * @param reader reader that will be used to interpret the content of \n * If a reader has been specified through {@link #setReaderFactory(ConfigurationReaderFactory)}, it\n * will be used to analyse the configuration. Otherwise, an {@link XmlConfigurationReader}\n * instance will be used.\n *\n * \n * If a configuration source has been specified through {@link #setSource(ConfigurationSource)}, it will be\n * used. Otherwise, this method will fail.\n *\n * @throws IOException if an I/O error occurs.\n * @throws ConfigurationException if a configuration error occurs.\n * @throws SourceConfigurationException if no {@link ConfigurationSource} hasn't been set.\n * @throws ConfigurationFormatException if a syntax error occurs in the configuration data.\n * @throws ConfigurationStructureException if the configuration data doesn't describe a valid configuration tree.\n * @throws ReaderConfigurationException if the {@link ConfigurationReaderFactory} isn't properly configured.\n * @see #write()\n * @see #read(InputStream)\n * @see #read(ConfigurationReader)\n * @see #read(Reader,ConfigurationReader)\n */\n public void read() throws ConfigurationException, IOException {\n read(getReaderFactory().getReaderInstance());\n }\n\n /**\n * Writes the configuration to the specified {@link Writer}.\n * \n * This method will use {@link #getWriterFactory()} to create instances of configuration writer.\n *\n * @param out where to write the configuration to.\n * @throws ConfigurationException if any error occurs.\n * @throws ConfigurationFormatException if a syntax error occurs in the configuration data.\n * @throws ConfigurationStructureException if the configuration data doesn't describe a valid configuration tree.\n * @throws WriterConfigurationException if the {@link ConfigurationWriterFactory} isn't properly configured.\n * @see #read(InputStream)\n * @see #write()\n */\n public void write(Writer out) throws ConfigurationException {\n write(getWriterFactory().getWriterInstance(out));\n }\n\n /**\n * Writes the configuration.\n * \n * If a configuration source was specified through {@link #setSource(ConfigurationSource)}, it will be used\n * to open an output stream. Otherwise, this method will fail.\n *\n * @throws ConfigurationException if any error occurs.\n * @throws SourceConfigurationException if no {@link ConfigurationSource} has been set.\n * @throws ConfigurationFormatException if a syntax error occurs in the configuration data.\n * @throws ConfigurationStructureException if the configuration data doesn't describe a valid configuration tree.\n * @throws IOException if any I/O error occurs.\n * @see #read(ConfigurationReader)\n * @see #write()\n */\n public void write() throws IOException, ConfigurationException {\n ConfigurationSource source = getSource(); // Configuration source.\n\n // Makes sure the source has been set.\n if (source == null) {\n throw new SourceConfigurationException(\"No configuration source has been set\");\n }\n\n try (Writer out = source.getWriter()) {\n write(out);\n }\n }\n\n /**\n * Writes the configuration data to the specified builder.\n * @param builder object that will receive configuration building messages.\n * @throws ConfigurationException if any error occurs while going through the configuration tree.\n */\n public void write(ConfigurationBuilder builder) throws ConfigurationException {\n builder.startConfiguration();\n build(builder, root);\n builder.endConfiguration();\n }\n\n\n /**\n * Recursively explores the specified section and invokes the specified builder's callback methods.\n * @param builder object that will receive building events.\n * @param root section to explore.\n * @throws ConfigurationException if any error occurs.\n */\n private synchronized void build(ConfigurationBuilder builder, ConfigurationSection root) throws ConfigurationException {\n // Explores the section's variables.\n Set \n * At the end of this call, \n * This method might trigger as many as two {@link ConfigurationEvent events}:\n * \n * This method will return \n * If the value of the specified variable is actually modified, an {@link ConfigurationEvent event} will be passed\n * to all LISTENERS.\n *\n * @param name fully qualified name of the variable to set.\n * @param value new value for the variable.\n * @return \n * This method will return \n * If the value of the specified variable is actually modified, an {@link ConfigurationEvent event} will be passed\n * to all LISTENERS.\n *\n * @param name fully qualified name of the variable to set.\n * @param value new value for the variable.\n * @return \n * This method will return \n * If the value of the specified variable is actually modified, an {@link ConfigurationEvent event} will be passed to all\n * LISTENERS.\n *\n * @param name fully qualified name of the variable to set.\n * @param value new value for the variable.\n * @param separator string used to separate each element of the list.\n * @return \n * This method will return \n * If the value of the specified variable is actually modified, an {@link ConfigurationEvent event} will be passed\n * to all LISTENERS.\n *\n * @param name fully qualified name of the variable to set.\n * @param value new value for the variable.\n * @return \n * This method will return \n * If the value of the specified variable is actually modified, an {@link ConfigurationEvent event} will be passed\n * to all LISTENERS.\n *\n * @param name fully qualified name of the variable to set.\n * @param value new value for the variable.\n * @return \n * This method will return \n * If the value of the specified variable is actually modified, an {@link ConfigurationEvent event} will be passed\n * to all LISTENERS.\n *\n * @param name fully qualified name of the variable to set.\n * @param value new value for the variable.\n * @return \n * This method will return \n * If the value of the specified variable is actually modified, an {@link ConfigurationEvent event} will be passed\n * to all LISTENERS.\n *\n * @param name fully qualified name of the variable to set.\n * @param value new value for the variable.\n * @return \n * If the variable was set, a configuration {@link ConfigurationEvent event} will be passed to\n * all registered LISTENERS.\n *\n * @param name name of the variable to remove.\n * @return the variable's old value, or \n * If the variable was set, a configuration {@link ConfigurationEvent event} will be passed to\n * all registered LISTENERS.\n *\n * @param name name of the variable to remove.\n * @param separator character used to split the variable's value into a list.\n * @return the variable's old value, or \n * If the variable was set, a configuration {@link ConfigurationEvent event} will be passed to\n * all registered LISTENERS.\n *\n * @param name name of the variable to remove.\n * @return the variable's old value, or \n * If the variable was set, a configuration {@link ConfigurationEvent event} will be passed to\n * all registered LISTENERS.\n *\n * @param name name of the variable to remove.\n * @return the variable's old value, or \n * If the variable was set, a configuration {@link ConfigurationEvent event} will be passed to\n * all registered LISTENERS.\n *\n * @param name name of the variable to remove.\n * @return the variable's old value, or \n * If the variable was set, a configuration {@link ConfigurationEvent event} will be passed to\n * all registered LISTENERS.\n *\n * @param name name of the variable to remove.\n * @return the variable's old value, or \n * If the variable was set, a configuration {@link ConfigurationEvent event} will be passed to\n * all registered LISTENERS.\n *\n * @param name name of the variable to remove.\n * @return the variable's old value, or \n * If the variable isn't set, this method will set it to \n * If the variable isn't set, this method will set it to \n * If the variable isn't set, this method will set it to \n * If the variable isn't set, this method will set it to \n * If the variable isn't set, this method will set it to \n * If the variable isn't set, this method will set it to \n * If the variable isn't set, this method will set it to \n * If a class needs to be informed of the logical structure of a configuration instance,\n * it implements this interface and registers an instance with the {@link Configuration} using\n * its {@link Configuration#write(ConfigurationBuilder) build} method. The {@link Configuration}\n * uses the instance to report configuration related events such as the start of sections and\n * variable declarations.\n *\n * \n * The \n * This method will only be invoked once, before any other method in this interface.\n *\n * @throws ConfigurationException any Configuration error, possibly wrapping another exception.\n */\n void startConfiguration() throws ConfigurationException;\n\n /**\n * Receives notification at the end of the configuration.\n * \n * This method will be invoked at most once, and if it is, it will be the last one. If an\n * unrecoverable error happens, this method might never be called.\n *\n * @throws ConfigurationException any Configuration error, possibly wrapping another exception.\n */\n void endConfiguration() throws ConfigurationException;\n\n /**\n * Receives notification at the beginning of a section.\n * \n * This method will be invoked once at the beginning of every configuration section. Unless an\n * unrecoverable error happens, there will be an {@link #endSection(String) endSection} event for every\n * \n * This method will be invoked once at the end of every configuration section. There will be a\n * corresponding {@link #startSection(String) startSection} event for every \n * This method will be invoked once per variable found in a section. The declared variable\n * will always belong to the section defined in the last {@link #startSection(String) startSection}\n * event which hasn't yet been closed by an {@link #endSection(String) endSection} event. If there is\n * no such section, the variable belongs to the unnamed root section.\n *\n * @param name name of the new variable.\n * @param value value of the new variable.\n * @throws ConfigurationException any Configuration error, possibly wrapping another exception.\n */\n void addVariable(String name, String value) throws ConfigurationException;\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/ConfigurationEvent.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see \n * The event is passed to every {@link ConfigurationListener} object which registered to receive such events using the\n * {@link Configuration}'s {@link Configuration#addConfigurationListener(ConfigurationListener) addConfigurationListener} method.\n * Each such listener object gets this \n * The event will describe a modification of variable \n * \n * The returned value will be the variable's fully qualified name. If, for example, the\n * modified variable is \n * If the variable has been deleted, this method will return \n * If the variable has been deleted, this method will return 0.\n *\n * @return the new value for the modified variable.\n * @throws NumberFormatException if {@link #getValue()} cannot be cast as an integer.\n */\n public int getIntegerValue() throws NumberFormatException {\n return ConfigurationSection.getIntegerValue(value);\n }\n\n /**\n * Returns the new value for the modified variable cast as a float.\n * \n * If the variable has been deleted, this method will return 0.\n *\n * @return the new value for the modified variable.\n * @throws NumberFormatException if {@link #getValue()} cannot be cast as a float\n */\n public float getFloatValue() throws NumberFormatException {\n return ConfigurationSection.getFloatValue(value);\n }\n\n /**\n * Returns the new value for the modified variable cast as a boolean.\n * \n * If the variable has been deleted, this method will return \n * If the variable has been deleted, this method will return 0.\n *\n * @return the new value for the modified variable.\n * @throws NumberFormatException if {@link #getValue()} cannot be cast as a long.\n */\n public long getLongValue() throws NumberFormatException {\n return ConfigurationSection.getLongValue(value);\n }\n\n /**\n * Returns the new value for the modified variable cast as a double.\n * \n * If the variable has been deleted, this method will return 0.\n *\n * @return the new value for the modified variable.\n * @throws NumberFormatException if {@link #getValue()} cannot be cast as a double.\n */\n public double getDoubleValue() {\n return ConfigurationSection.getDoubleValue(value);\n }\n\n /**\n * Returns the new value for the modified variable cast as a {@link ValueList}.\n * \n * If the variable has been deleted, this method will return null.\n *\n * @param separator string used to tokenise the variable's value.\n * @return the new value for the modified variable.\n */\n public ValueList getListValue(String separator) {\n return ConfigurationSection.getListValue(value, separator);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/ConfigurationException.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see \n * This class can contain basic error information from either the \n * If the application needs to pass through other types of exceptions, it must wrap them in a\n * \n * The existing exception will be embedded in the new one, and its message will\n * become the default message for the \n * The existing exception will be embedded in the new one, but the new exception will have its own message.\n *\n * @param message the detail message.\n * @param cause the exception to be wrapped in a \n * Within the scope of the \n * This exception is mostly meant to be used by implementations of {@link ConfigurationReader},\n * as they're the ones who will analyse the syntax of a configuration stream.\n * \n * When applicable, instances of \n * Since \n * {@link #UNKNOWN_LOCATION} is a legal value for both \n * The existing exception will be embedded in the new one, and its message will\n * become the default message for the \n * The existing exception will be embedded in the new one, and its message will\n * become the default message for the \n * {@link #UNKNOWN_LOCATION} is a legal value for both \n * The existing exception will be embedded in the new one, but the new exception will have its own message.\n *\n * @param message the detail message.\n * @param cause the exception to be wrapped in a \n * The existing exception will be embedded in the new one, but the new exception will have its own message.\n * \n * {@link #UNKNOWN_LOCATION} is a legal value for both \n * By convention, the line at which an error occurs is equal to the number of line breaks encountered\n * before the problem, plus one. This means that a line number of \n * By convention, the column at which an error occurs is equal to the number of character encountered\n * after the last line break and before the problem, plus one. This means that a column number of\n * \n * Implementations of this interface can register themselves to a {@link Configuration configuration} instance through\n * its {@link Configuration#addConfigurationListener(ConfigurationListener) addConfigurationListener} method to be\n * notified of configuration changes.\n *\n * @author Nicolas Rinaudo\n */\npublic interface ConfigurationListener {\n /**\n * Invoked when the configuration changes.\n * @param event describes the configuration modification.\n */\n void configurationChanged(ConfigurationEvent event);\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/ConfigurationReader.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see \n * Application writers that need to implement a specific configuration format need to subclass this.\n * Reader implementations have the task of parsing an input stream for configuration data and invoking the\n * relevant callback methods of {@link ConfigurationBuilder}.\n * \n * The \n * In order for an implementation of \n * In addition, most readers will have an associated writer used to write configuration files in a\n * format that the reader will understand.\n *\n * @author Nicolas Rinaudo\n * @see ConfigurationReaderFactory\n */\npublic interface ConfigurationReader {\n /**\n * Reads configuration information from the specified input stream and invokes the specified builder's callback methods.\n * \n * When applicable, this method is expected to throw {@link ConfigurationFormatException format} exceptions rather\n * than {@link ConfigurationException configuration} exceptions. This will allow applications to report errors in a\n * way that is useful for users.\n *\n * @param in where to read the configuration information from.\n * @param builder where to send configuration messages to.\n * @throws IOException if an I/O error occurs.\n * @throws ConfigurationException if another type of error occurs, in which case that error must be returned by \n * A \n * If \n * Note that the order in which variable names are returned needs not be that in which they were added to the\n * section. Callers should not rely on the order being consistent over time.\n *\n * @return an iterator on the names of the variables that are defined in the section.\n */\n public Set \n * If \n * If \n * If \n * If \n * If \n * If \n * If a subsection with the specified name already exists, it will be returned.\n *\n * @param name name of the new section.\n * @return the subsection with the specified name.\n */\n public ConfigurationSection addSection(String name) {\n ConfigurationSection section = getSection(name);\n\n // The section already exists, returns it.\n if (section != null) {\n return section;\n }\n // Creates the new section.\n section = new ConfigurationSection();\n sections.put(name, section);\n return section;\n }\n\n /**\n * Deletes the specified section.\n * @param name name of the section to delete.\n * @return the section that was deleted if any, \n * Note that this method is very inefficient and should only be called when strictly necessary.\n *\n * @param section section to remove.\n * @return \n * Note that the order in which section names are returned needs not be that in which they were added to the\n * section. Callers should not rely on the order being consistent over time.\n *\n * @return an enumeration on all of this section's subsections' names.\n */\n public Set \n * This method is meant for {@link Configuration} instances to prune dead branches.\n *\n * @return \n * Application writers that need to retrieve configuration data from a non-standard source (over the network, from a\n * database, ...) need to subclass this.\n * \n * Implementations of this interface can be registered through {@link Configuration}'s\n * {@link Configuration#setSource(ConfigurationSource) setSource} method. Their purpose is\n * to provide the system with streams to a configuration source. This system allows applications\n * to retrieve their configuration information from non-standard sources, such as over the network,\n * in a database, ...\n * \n * The \n * Within the scope of the \n * This exception is mostly meant to be used by implementations of {@link ConfigurationBuilder},\n * as they have to analyse the structure of the configuration they're receiving events for.\n * \n * Since \n * The existing exception will be embedded in the new one, and its message will\n * become the default message for the \n * The existing exception will be embedded in the new one, but the new exception will have its own message.\n *\n * @param message the detail message.\n * @param cause the exception to be wrapped in a \n * A \n * The returned builder instance will serialize configuration events to the specified writer.\n *\n * @param out where to write the configuration data.\n * @return an instance of {@link ConfigurationBuilder}.\n * @throws WriterConfigurationException if the factory wasn't properly configured.\n */\n public abstract T getWriterInstance(Writer out) throws WriterConfigurationException;\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/DefaultConfigurationBuilder.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see \n * This class is available as a convenience for applications that need to explore the content\n * of a configuration tree. It provides no-op implementations for the methods defined in\n * {@link ConfigurationBuilder}, and application writers can override the ones that are of use\n * to them and ignore the others.\n *\n * @author Nicolas Rinaudo\n */\npublic class DefaultConfigurationBuilder implements ConfigurationBuilder {\n /**\n * Receive notification at the beginning of the configuration.\n * \n * By default, do nothing. Application writers may override this method in a subclass to take\n * specific actions at the beginning of a document (such as allocating the root node of a tree\n * or creating an output file).\n *\n */\n public void startConfiguration() {}\n\n /**\n * Receive notification at the end of the configuration.\n * \n * By default, do nothing. Application writers may override this method in a subclass to take\n * specific actions at the end of a document (such as finalising a tree or closing an output file).\n *\n */\n public void endConfiguration() {}\n\n /**\n * Receive notification at the beginning of a section.\n * \n * By default, do nothing. Application writers may override this method in a subclass to take\n * specific actions at the start of each element (such as allocating a new tree node or writing\n * output to a file).\n *\n * @param name name of the new section.\n */\n public void startSection(String name) {}\n\n /**\n * Receive notification at the end of a section.\n * \n * By default, do nothing. Application writers may override this method in a subclass to take\n * specific actions at the end of each element (such as finalising a tree node or writing output\n * to a file).\n *\n * @param name name of the finished section.\n */\n public void endSection(String name) {}\n\n /**\n * Receive notification of variable definition.\n * \n * By default, do nothing. Application writers may override this method to take specific actions for\n * each variable definition (such as adding a leaf to a tree node, or printing it to a file).\n *\n * @param name name of the new variable.\n * @param value value of the new variable.\n */\n public void addVariable(String name, String value) {}\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/FileConfigurationSource.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see \n * This exception is mostly meant to be used by implementations of {@link ConfigurationReaderFactory},\n * as they're the ones who will configure instances of {@link ConfigurationReader}.\n * \n * Since \n * The existing exception will be embedded in the new one, and its message will\n * become the default message for the \n * The existing exception will be embedded in the new one, but the new exception will have its own message.\n *\n * @param message the detail message.\n * @param cause the exception to be wrapped in a \n * This exception is meant to be thrown by {@link Configuration} whenever a method that requires a\n * {@link ConfigurationSource} to have been set is called.\n * \n * Since \n * The existing exception will be embedded in the new one, and its message will\n * become the default message for the \n * The existing exception will be embedded in the new one, but the new exception will have its own message.\n *\n * @param message the detail message.\n * @param cause the exception to be wrapped in a \n * Instances of this class can only be retrieved through {@link ValueList#valueIterator()}.\n *\n * @author Nicolas Rinaudo\n */\npublic class ValueIterator implements Iterator \n * Such values will simply be split using a \n * In addition to the regular \n * This exception is mostly meant to be used by implementations of writer,\n * as they're the ones who will configure instances of {@link ConfigurationBuilder}.\n * \n * Since \n * The existing exception will be embedded in the new one, and its message will\n * become the default message for the \n * The existing exception will be embedded in the new one, but the new exception will have its own message.\n *\n * @param message the detail message.\n * @param cause the exception to be wrapped in a \n * The format of XML files parsed by instances of \n * For example:\n * \n * Information on the XML file format can be found {@link XmlConfigurationReader here}.\n *\n * @author Nicolas Rinaudo\n */\npublic class XmlConfigurationWriter implements ConfigurationBuilder {\n /** Factory used to create instances of {@link XmlConfigurationWriter}. */\n public static final ConfigurationWriterFactory \n * Configuration data is stored as a set of variables organised in sections. A typical variable\n * name is: \n * Configuration data is stored in instances of {@link com.mucommander.commons.conf.Configuration}, which offers a set\n * of methods manipulate variables:\n * \n * The \n * The default configuration format is described in {@link com.mucommander.commons.conf.XmlConfigurationReader}.\n * Application writers who wish to change this can do so by:\n * \n * Classes that need to be notified when the configuration has changed can do so by:\n * \n * \n * This class is abstract (as the name implies) and implemented by two subclasses:\n * \n * The first time one of the Files returned by the Note that an instance of Important note: the given path's separator character must be '/' and the path must be relative to the\n * archive's root, i.e. not start with a leading '/', otherwise the entry will not be found.\n *\n * @param entryPath path to an entry within this archive\n * @return an AbstractFile that corresponds to the given entry path\n * @throws IOException if neither the entry nor its parent exist within the archive\n * @throws UnsupportedFileOperationException if {@link FileOperation#READ_FILE} operations are not supported by the\n * underlying file protocol.\n */\n public AbstractFile getArchiveEntryFile(String entryPath) throws IOException {\n // Make sure the entries tree is created and up-to-date\n checkEntriesTree();\n\n // Todo: check if that's really necessary / if there is a way to remove this\n entryPath = entryPath.replace(File.separatorChar, ArchiveEntry.SEPARATOR_CHAR);\n\n // Find the entry node corresponding to the given path\n DefaultMutableTreeNode entryNode = entryTreeRoot.findEntryNode(entryPath);\n\n if(entryNode==null) {\n int depth = ArchiveEntry.getDepth(entryPath);\n\n AbstractFile parentFile;\n if(depth==1)\n parentFile = this;\n else {\n String parentPath = entryPath;\n if(parentPath.endsWith(\"/\"))\n parentPath = parentPath.substring(0, parentPath.length()-1);\n\n parentPath = parentPath.substring(0, parentPath.lastIndexOf('/'));\n\n parentFile = getArchiveEntryFile(parentPath);\n if(parentFile==null) // neither the entry nor the parent exist\n throw new IOException();\n }\n\n return getArchiveEntryFile(new ArchiveEntry(entryPath, false, 0, 0, false), parentFile);\n }\n\n return getArchiveEntryFile(entryNode);\n }\n\n /**\n * Creates and returns an {@link AbstractFile} instance corresponding to the given entry node.\n * This method recurses to resolve the entry's parent file.\n *\n * @param entryNode tree node corresponding to the entry for which to return a file\n * @return an {@link AbstractFile} instance corresponding to the given entry node\n */\n private AbstractFile getArchiveEntryFile(DefaultMutableTreeNode entryNode) throws IOException {\n DefaultMutableTreeNode parentNode = (DefaultMutableTreeNode)entryNode.getParent();\n return getArchiveEntryFile(\n (ArchiveEntry)entryNode.getUserObject(),\n parentNode == entryTreeRoot ? this : getArchiveEntryFile(parentNode)\n );\n }\n\n\n /**\n * Returns an iterator of {@link ArchiveEntry} that iterates through all the entries of this archive.\n * Implementations of this method should as much as possible return entries in their \"natural order\", i.e. the order\n * in which they are stored in the archive.\n * \n * This method is called the first time one of the \n * This method is implemented by {@link com.mucommander.commons.file.AbstractROArchiveFile} and\n * {@link com.mucommander.commons.file.AbstractRWArchiveFile} to respectively return AbstractFile classes should never be instantiated directly. Instead, the {@link FileFactory} The returned It is important to note that this method is provided for interoperability purposes, for the sole purpose of\r\n * connecting to APIs that require a The returned name is the filename extracted from this file's This method should be overridden if a special processing (e.g. URL-decoding) needs to be applied to the\r\n * returned filename.\r\n *\r\n * @return this file's name\r\n */\r\n public String getName() {\r\n String name = fileURL.getFilename();\r\n // If filename is null, use host instead\r\n if (name == null) {\r\n name = fileURL.getHost();\r\n // If host is null, return an empty string\r\n if (name == null) {\r\n return \"\";\r\n }\r\n }\r\n\r\n return name;\r\n }\r\n\r\n\r\n /**\r\n * Returns this file's extension, \r\n * A filename has an extension if and only if: \r\n * This default implementation returns the string representation of this file's {@link #getURL() url}, without\r\n * the login and password parts. File implementations overriding this method should always return a path free of\r\n * any login and password, so that it can safely be displayed to the end user or stored, without risking to\r\n * compromise sensitive information.\r\n *\r\n *\r\n * @return the absolute path to this file\r\n */\r\n public String getAbsolutePath() {\r\n return getURL().toString(false);\r\n }\r\n\r\n\r\n /**\r\n * Returns the canonical path to this file, resolving any symbolic links or '..' and '.' occurrences.\r\n *\r\n * This implementation simply returns the value of {@link #getAbsolutePath()}, and thus should be overridden\r\n * if canonical path resolution is available.\r\n *\r\n * @return the canonical path to this file\r\n */\r\n public String getCanonicalPath() {\r\n return getAbsolutePath();\r\n }\r\n\r\n /**\r\n * Returns an This default implementation returns the default separator \"/\", this method should be overridden if the path\r\n * separator used by the file implementation is different.\r\n *\r\n * @return the path separator used by this file\r\n */\r\n public String getSeparator() {\r\n return DEFAULT_SEPARATOR;\r\n }\r\n\r\n\r\n /**\r\n * Returns This default implementation is solely based on the filename and returns \r\n * This default implementation returns the file whose URL has the same scheme as this one, same credentials (if any),\r\n * and a path equal to \r\n * This default implementation returns \r\n * The notion of volume may or may not have a meaning depending on the kind of filesystem. On local filesystems,\r\n * the notion of volume can be assimilated into that of mount point for UNIX-based OSes, or drive\r\n * for the Windows platform. Volumes may also have a meaning for certain network filesystems such as SMB, for which\r\n * shares can be considered as volumes. Filesystems that don't have a notion of volume should return the\r\n * {@link #getRoot() root folder}.\r\n * \r\n * This default implementation returns this file's {@link #getRoot() root folder}. This method should be overridden\r\n * if this is not adequate.\r\n *\r\n * @return the volume on which this file is located.\r\n */\r\n public AbstractFile getVolume() {\r\n return getRoot();\r\n }\r\n\r\n /**\r\n * Returns an This implementation starts by checking whether the {@link FileOperation#RANDOM_READ_FILE} operation is\r\n * supported or not.\r\n * If it is, a {@link #getRandomAccessInputStream() random input stream} to this file is retrieved and used to seek\r\n * to the specified offset. If it's not, a regular {@link #getInputStream() input stream} is retrieved, and\r\n * {@link java.io.InputStream#skip(long)} is used to position the stream to the specified offset, which on most\r\n * This method should be overridden by filesystems that do not offer a {@link #getOutputStream()}\r\n * implementation, but that can take an The Read and write operations are buffered, with a buffer of {@link #IO_BUFFER_SIZE} bytes. For performance\r\n * reasons, this buffer is provided by {@link BufferPool}. Thus, there is no need to surround the InputStream\r\n * with a {@link java.io.BufferedInputStream}.\r\n *\r\n * Copy progress can optionally be monitored by supplying a {@link com.mucommander.commons.io.CounterInputStream}.\r\n *\r\n * @param in the InputStream to read from\r\n * @param append if true, data written to the OutputStream will be appended to the end of this file. If false, any\r\n * existing data will be overwritten.\r\n * @param length length of the stream before EOF is reached, This method throws an {@link IOException} if the operation failed, for any of the following reasons:\r\n * If this file supports the {@link FileOperation#COPY_REMOTELY} file operation, an attempt to perform a\r\n * {@link #copyRemotelyTo(AbstractFile) remote copy} of the file to the destination is made. If the operation isn't\r\n * supported or wasn't successful, the file is copied manually, by transferring its contents to the destination \r\n * using {@link #copyRecursively(AbstractFile, AbstractFile)}. This method throws an {@link IOException} if the operation failed, for any of the following reasons:\r\n * If this file supports the {@link FileOperation#RENAME} file operation, an attempt to\r\n * {@link #renameTo(AbstractFile) rename} the file to the destination is made. If the operation isn't supported\r\n * or wasn't successful, the file is moved manually, by transferring its contents to the destination using\r\n * {@link #copyTo(AbstractFile)} and then deleting the source. This generic implementation simply creates a zero-byte file. {@link AbstractRWArchiveFile} implementations\r\n * may want to override this method so that it creates a valid archive with no entry. To illustrate, an empty Zip\r\n * file with proper headers is 22-byte long.\r\n *\r\n * @throws IOException if the file could not be created, either because it already exists or because of an I/O error\r\n * @throws UnsupportedFileOperationException if this method relies on a file operation that is not supported\r\n * or not implemented by the underlying filesystem.\r\n */\r\n public void mkfile() throws IOException {\r\n if (exists()) {\r\n throw new IOException();\r\n }\r\n\r\n if (isFileOperationSupported(FileOperation.WRITE_FILE)) {\r\n getOutputStream().close();\r\n } else {\r\n copyStream(new ByteArrayInputStream(new byte[]{}), false, 0);\r\n }\r\n }\r\n\r\n\r\n /**\r\n * Returns the children files that this file contains, filtering out files that do not match the specified FileFilter.\r\n * For this operation to be successful, this file must be 'browsable', i.e. {@link #isBrowsable()} must return\r\n * This default implementation filters out files *after* they have been created. This method\r\n * should be overridden if a more efficient implementation can be provided by subclasses.\r\n *\r\n * @param filter the FilenameFilter to be used to filter out files from the list, may be Implementation note: the default implementation of this method calls sequentially {@link #changePermission(int, int, boolean)},\r\n * for each permission and access (that's a total 9 calls). This may affect performance on filesystems which need\r\n * to perform an I/O request to change each permission individually. In that case, and if the filesystem allows\r\n * to change all permissions at once, this method should be overridden.\r\n *\r\n * @param permissions new permissions for this file\r\n * @throws IOException if the permissions couldn't be changed, either because of insufficient permissions or because\r\n * of an I/O error.\r\n * @throws UnsupportedFileOperationException if this method relies on a file operation that is not supported\r\n * or not implemented by the underlying filesystem.\r\n */\r\n public void changePermissions(int permissions) throws IOException {\r\n int bitShift = 0;\r\n\r\n PermissionBits mask = getChangeablePermissions();\r\n for (int a = OTHER_ACCESS; a <= USER_ACCESS; a++) {\r\n for (int p = EXECUTE_PERMISSION; p <= READ_PERMISSION; p = p<<1) {\r\n if (mask.getBitValue(a, p)) {\r\n changePermission(a, p, (permissions & (1 << bitShift)) != 0);\r\n }\r\n\r\n bitShift++;\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * Returns a string representation of this file's permissions.\r\n *\r\n * The first character is 'l' if this file is a symbolic link,'d' if it is a directory, '-' otherwise. Then\r\n * the string contains up to 3 character triplets, for each of the 'user', 'group' and 'other' access types, each\r\n * containing the following characters:\r\n * The first character triplet for 'user' access will always be added to the permissions. Then the 'group' and\r\n * 'other' triplets will only be added if at least one of the user permission bits is supported, as tested with\r\n * this file's permissions mask.\r\n * Here are a couple examples to illustrate:\r\n * \r\n * Note that even if A filename has an extension if and only if: Although {@link #getChild} can be used to retrieve a direct child file, this method should be favored because\r\n * it allows to use this file instance as the parent of the returned child file.\r\n *\r\n * @param filename the name of the child file to be created\r\n * @return an AbstractFile representing the requested direct child file, never null\r\n * @throws IOException in any of the cases listed above\r\n */\r\n public final AbstractFile getDirectChild(String filename) throws IOException {\r\n if (filename.contains(getSeparator())) {\r\n throw new IOException();\r\n }\r\n\r\n AbstractFile childFile = getChild(filename);\r\n\r\n // Use this file as the child's parent, it avoids creating a new AbstractFile instance when getParent() is called\r\n childFile.setParent(this);\r\n\r\n return childFile;\r\n }\r\n\r\n\r\n /**\r\n * Convenience method that creates a directory as a direct child of this directory.\r\n * This method will fail if this file is not a directory.\r\n *\r\n * @param name name of the directory to create\r\n * @throws IOException if the directory could not be created, either because the file already exists or for any\r\n * other reason.\r\n * @throws UnsupportedFileOperationException if this method relies on a file operation that is not supported\r\n * or not implemented by the underlying filesystem.\r\n */\r\n public final void mkdir(String name) throws IOException {\r\n getChild(name).mkdir();\r\n }\r\n\r\n\r\n /**\r\n * Creates this file as a directory and any parent directory that does not already exist. This method will fail\r\n * (throw an \r\n * Important note: the returned {@link AbstractArchiveFile}, if any, may not necessarily be an\r\n * archive, as specified by {@link #isArchive()}. This is the case for files that were resolved as\r\n * {@link AbstractArchiveFile} instances based on their path, but that do not yet exist or were created as\r\n * directories. On the contrary, an existing archive will necessarily return a non-null value.\r\n *\r\n * @return the parent {@link AbstractArchiveFile} that contains this file\r\n */\r\n public final AbstractArchiveFile getParentArchive() {\r\n if (hasAncestor(AbstractArchiveFile.class)) {\r\n return getAncestor(AbstractArchiveFile.class);\r\n } else if (hasAncestor(AbstractArchiveEntryFile.class)) {\r\n AbstractArchiveEntryFile ancestor = getAncestor(AbstractArchiveEntryFile.class);\r\n return ancestor != null ? ancestor.getArchiveFile() : null;\r\n }\r\n\r\n return null;\r\n }\r\n\r\n\r\n /**\r\n * Returns an icon representing this file, using the default {@link com.mucommander.commons.file.icon.FileIconProvider}\r\n * registered in {@link FileFactory}. The specified preferred resolution will be used as a hint, but the returned\r\n * icon may have different dimension; see {@link com.mucommander.commons.file.icon.FileIconProvider#getFileIcon(AbstractFile, java.awt.Dimension)}\r\n * for full details.\r\n * This method may return The checksum is returned as an hexadecimal string, such as \"6d75636f0a\". The length of this string depends on\r\n * the kind of algorithm.\r\n *\r\n * Note: this method does not reset the The checksum is returned as an hexadecimal string, such as \"6d75636f0a\". The length of this string depends on\r\n * the kind of Note: this method does not reset the A filename has an extension if and only if: \r\n * The returned extension (if any) is free of any extension separator character ( A filename has an extension if and only if: Important: this method does not close the \r\n * Unlike {@link #equalsCanonical(Object)}, this method is not allowed to perform I/O operations and block\r\n * the caller thread.\r\n *\r\n * @param o the object to compare against this instance\r\n * @return Returns It is noteworthy that this method uses It is also worth noting that hostnames are not resolved, which means this method does not consider\r\n * a hostname and its corresponding IP address as being equal.\r\n *\r\n * Unlike {@link #equals(Object)}, this method is allowed to perform I/O operations and block\r\n * the caller thread.\r\n *\r\n * @param o the object to compare against this instance\r\n * @return This {@link FileOperation#CHANGE_DATE file operation} may or may not be supported by the underlying filesystem\r\n * -- {@link #isFileOperationSupported(FileOperation)} can be called to find out if it is. If the operation isn't\r\n * supported, a {@link UnsupportedFileOperation} will be thrown when this method is called.\r\n *\r\n * @param lastModified last modified date, in milliseconds since the epoch (00:00:00 GMT, January 1, 1970)\r\n * @throws IOException if the date couldn't be changed, either because of insufficient permissions or because of\r\n * an I/O error.\r\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\r\n * or is not implemented.\r\n */\r\n public abstract void setLastModifiedDate(long lastModified) throws IOException;\r\n\r\n public abstract void changeReplication(short replication) throws IOException;\r\n /**\r\n * Returns this file's size in bytes, This method may return permissions for which none of the bits are supported, but may never return\r\n * This {@link FileOperation#CHANGE_PERMISSION file operation} may or may not be supported by the underlying filesystem\r\n * -- {@link #isFileOperationSupported(FileOperation)} can be called to find out if it is. If the operation isn't\r\n * supported, a {@link UnsupportedFileOperation} will be thrown when this method is called.\r\n *\r\n * @param access see {@link PermissionTypes} for allowed values\r\n * @param permission see {@link PermissionAccesses} for allowed values\r\n * @param enabled true to enable the flag, false to disable it\r\n * @throws IOException if the permission couldn't be changed, either because of insufficient permissions or because\r\n * of an I/O error.\r\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\r\n * or is not implemented.\r\n * @see #getChangeablePermissions()\r\n */\r\n public abstract void changePermission(int access, int permission, boolean enabled) throws IOException;\r\n\r\n /**\r\n * Returns information about the owner of this file. The kind of information that is returned is implementation-dependant.\r\n * It may typically be a username (e.g. 'bob') or a user ID (e.g. '501').\r\n * If the owner information is not available to the \r\n * An archive is a file container that can be {@link #isBrowsable() browsed}. Archive files may not be\r\n * {@link #isDirectory() directories}, and vice-versa.\r\n *\r\n * @return This {@link FileOperation#LIST_CHILDREN file operation} may or may not be supported by the underlying filesystem\r\n * -- {@link #isFileOperationSupported(FileOperation)} can be called to find out if it is. If the operation isn't\r\n * supported, a {@link UnsupportedFileOperation} will be thrown when this method is called.\r\n *\r\n * @return the children files that this file contains\r\n * @throws IOException if this operation is not possible (file is not browsable) or if an error occurred.\r\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\r\n * or is not implemented.\r\n */\r\n public abstract AbstractFile[] ls() throws IOException;\r\n\r\n /**\r\n * Creates this file as a directory. This method will fail (throw an This {@link FileOperation#CREATE_DIRECTORY file operation} may or may not be supported by the underlying filesystem\r\n * -- {@link #isFileOperationSupported(FileOperation)} can be called to find out if it is. If the operation isn't\r\n * supported, a {@link UnsupportedFileOperation} will be thrown when this method is called.\r\n *\r\n * @throws IOException if the directory could not be created, either because this file already exists or for any\r\n * other reason.\r\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\r\n * or is not implemented.\r\n */\r\n public abstract void mkdir() throws IOException;\r\n\r\n /**\r\n * Returns an This {@link FileOperation#READ_FILE file operation} may or may not be supported by the underlying filesystem\r\n * -- {@link #isFileOperationSupported(FileOperation)} can be called to find out if it is. If the operation isn't\r\n * supported, a {@link UnsupportedFileOperation} will be thrown when this method is called.\r\n *\r\n * @return an \r\n * This method may throw an This {@link FileOperation#WRITE_FILE file operation} may or may not be supported by the underlying filesystem\r\n * -- {@link #isFileOperationSupported(FileOperation)} can be called to find out if it is. If the operation isn't\r\n * supported, a {@link UnsupportedFileOperation} will be thrown when this method is called.\r\n *\r\n * @return an \r\n * This method may throw an This {@link FileOperation#APPEND_FILE file operation} may or may not be supported by the underlying filesystem\r\n * -- {@link #isFileOperationSupported(FileOperation)} can be called to find out if it is. If the operation isn't\r\n * supported, a {@link UnsupportedFileOperation} will be thrown when this method is called.\r\n *\r\n * @return an This {@link FileOperation#RANDOM_READ_FILE file operation} may or may not be supported by the underlying filesystem\r\n * -- {@link #isFileOperationSupported(FileOperation)} can be called to find out if it is. If the operation isn't\r\n * supported, a {@link UnsupportedFileOperation} will be thrown when this method is called.\r\n *\r\n * @return a This {@link FileOperation#RANDOM_WRITE_FILE file operation} may or may not be supported by the underlying filesystem\r\n * -- {@link #isFileOperationSupported(FileOperation)} can be called to find out if it is. If the operation isn't\r\n * supported, a {@link UnsupportedFileOperation} will be thrown when this method is called.\r\n *\r\n * @return a This {@link FileOperation#DELETE file operation} may or may not be supported by the underlying filesystem\r\n * -- {@link #isFileOperationSupported(FileOperation)} can be called to find out if it is. If the operation isn't\r\n * supported, a {@link UnsupportedFileOperation} will be thrown when this method is called.\r\n *\r\n * @throws IOException if this file does not exist or could not be deleted\r\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\r\n * or is not implemented.\r\n */\r\n public abstract void delete() throws IOException;\r\n\r\n /**\r\n * Renames this file to a specified destination file, overwriting the destination if it exists. If this file is a\r\n * directory, any file or directory it contains will also be moved.\r\n * After normal completion, this file will not exist anymore: {@link #exists()} will return This method throws an {@link IOException} if the operation failed, for any of the following reasons:\r\n * This {@link FileOperation#RENAME file operation} may or may not be supported by the underlying filesystem\r\n * -- {@link #isFileOperationSupported(FileOperation)} can be called to find out if it is. If the operation isn't\r\n * supported, a {@link UnsupportedFileOperation} will be thrown when this method is called.\r\n *\r\n * @param destFile file to rename this file to\r\n * @throws IOException in any of the error cases listed above\r\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\r\n * or is not implemented.\r\n */\r\n public abstract void renameTo(AbstractFile destFile) throws IOException;\r\n\r\n /**\r\n * Remotely copies this file to a specified destination file, overwriting the destination if it exists.\r\n * If this file is a directory, any file or directory it contains will also be copied.\r\n *\r\n * This method differs from {@link #copyTo(AbstractFile)} in that it performs a server-to-server copy of the\r\n * file(s), without having the file's contents go through to the local process. This operation should only be\r\n * implemented if it offers a performance advantage over a regular client-driven copy like\r\n * {@link #copyTo(AbstractFile)}, or if {@link FileOperation#WRITE_FILE} is not supported (output streams cannot be\r\n * retrieved) and thus a regular copy cannot succeed.\r\n *\r\n * This method throws an {@link IOException} if the operation failed, for any of the following reasons:\r\n * The behavior in the case of an error occurring in the midst of the transfer is unspecified: files that have\r\n * been copied (even partially) may or may not be left in the destination.\r\n *\r\n * @param destFile the destination file to copy this file to\r\n * @throws IOException in any of the error cases listed above\r\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\r\n * or is not implemented.\r\n */\r\n public abstract void copyRemotelyTo(AbstractFile destFile) throws IOException;\r\n\r\n /**\r\n * Returns the free space (in bytes) on the disk/volume where this file is, This {@link FileOperation#GET_FREE_SPACE file operation} may or may not be supported by the underlying filesystem\r\n * -- {@link #isFileOperationSupported(FileOperation)} can be called to find out if it is. If the operation isn't\r\n * supported, a {@link UnsupportedFileOperation} will be thrown when this method is called.\r\n *\r\n * @return the free space (in bytes) on the disk/volume where this file is, This {@link FileOperation#GET_TOTAL_SPACE file operation} may or may not be supported by the underlying filesystem\r\n * -- {@link #isFileOperationSupported(FileOperation)} can be called to find out if it is. If the operation isn't\r\n * supported, a {@link UnsupportedFileOperation} will be thrown when this method is called.\r\n *\r\n * @return the total space (in bytes) of the disk/volume where this file is\r\n * @throws IOException if an I/O error occurred\r\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\r\n * or is not implemented.\r\n */\r\n public abstract long getTotalSpace() throws IOException;\r\n\r\n /**\r\n * Returns the file Object of the underlying API providing access to the filesystem. The returned Object may expose\r\n * filesystem-specific functionality that are not available in If the implemented filesystem has no such Object, It's possible to modify this loader's classpath at runtime through the {@link #addFile(AbstractFile)} method.\n *\n * @author Nicolas Rinaudo\n */\npublic class AbstractFileClassLoader extends ClassLoader {\n\n private final static org.slf4j.Logger LOGGER = null;//org.slf4j.LoggerFactory.getLogger(AbstractFileClassLoader.class);\n\n\t\n /** All abstract files in which to look for classes and resources. */\n private final Vector \n * Note that the file will not be added if it's already in the classpath.\n *\n * @param file file to add the class loader's classpath.\n * @throws IllegalArgumentException if \n * This methods can be used to update the entry's date and permissions for instance.\n *\n * @param entry the entry to update in the archive\n * @throws IOException if the entry doesn't exist in the archive or if an I/O error occurs\n * @throws UnsupportedFileOperationException if {@link FileOperation#WRITE_FILE} operations are not supported by\n * the underlying file protocol.\n */\n public abstract void updateEntry(ArchiveEntry entry) throws IOException, UnsupportedFileOperationException;\n\n /**\n * Processes the archive file to leave it in an optimal form. This method should be called after a writable archive\n * has been modified (entries added or removed).\n *\n * The actual effect of this method on the archive file depends on the kind of archive. It may be implemented\n * as a no-op if there is no use for it.\n * To illustrate, in the case of a {@link com.mucommander.commons.file.impl.zip.ZipArchiveFile}, this method removes chunks\n * of free space that are left when entries are deleted.\n *\n * @throws IOException if an I/O error occurs\n * @throws UnsupportedFileOperationException if {@link FileOperation#WRITE_FILE} operations are not supported by \n * the underlying file protocol.\n */\n public abstract void optimizeArchive() throws IOException, UnsupportedFileOperationException;\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/ArchiveEntry.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see Important: the path of archive entries must use the '/' character as a path delimiter, and be relative\n * to the archive's root, i.e. must not start with a leading '/'.\n *\n * @author Maxence Bernard \n */\npublic class ArchiveEntry extends SimpleFileAttributes {\n\n public static final char SEPARATOR_CHAR = '/';\n private static final String SEPARATOR_STRING = String.valueOf(SEPARATOR_CHAR);\n\n /** Encapsulated entry object */\n private Object entryObject;\n\n /** Caches the computed hashcode */\n private int hashCode;\n\n\n /**\n * Creates a new ArchiveEntry with all attributes set to their default value.\n */\n public ArchiveEntry() {\n }\n\n /**\n * Creates a new ArchiveEntry using the values of the supplied attributes.\n *\n * @param path the entry's path with {@link #SEPARATOR_CHAR} as path delimiter\n * @param directory true if the entry is a directory\n * @param date the entry's date\n * @param size the entry's size\n * @param exists Important note: the given path's separator character must be '/' and the path must be relative to the\n * archive's root, i.e. not start with a leading '/', otherwise the entry will not be found. Trailing separators\n * are ignored when paths are compared, for example the path 'temp' will match the entry 'temp/'.\n *\n * @param entryPath the path to the entry to look up in this tree\n * @return the node that corresponds to the specified entry path\n */\n DefaultMutableTreeNode findEntryNode(String entryPath) {\n int entryDepth = ArchiveEntry.getDepth(entryPath);\n int slashPos = 0;\n DefaultMutableTreeNode currentNode = this;\n for (int d = 1; d <= entryDepth; d++) {\n String subPath = d == entryDepth ?\n entryPath :\n entryPath.substring(0, (slashPos = entryPath.indexOf('/', slashPos)+1));\n DefaultMutableTreeNode matchNode = getDefaultMutableTreeNode(currentNode, subPath);\n if (matchNode == null) {\n return null; // No node matching the provided path, return null\n }\n\n currentNode = matchNode;\n }\n\n return currentNode;\n }\n\n @Nullable\n private DefaultMutableTreeNode getDefaultMutableTreeNode(DefaultMutableTreeNode currentNode, String subPath) {\n int nbChildren = currentNode.getChildCount();\n for (int c = 0; c < nbChildren; c++) {\n DefaultMutableTreeNode childNode = (DefaultMutableTreeNode)currentNode.getChildAt(c);\n\n // Path comparison is 'trailing slash insensitive'\n if (PathUtils.pathEquals(((ArchiveEntry)childNode.getUserObject()).getPath(), subPath, \"/\")) {\n // Found the node, let's return it\n return childNode;\n }\n }\n return null;\n }\n\n private static Logger getLogger() {\n if (logger == null) {\n logger = LoggerFactory.getLogger(ArchiveEntryTree.class);\n }\n return logger;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/ArchiveFormatProvider.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see \n * For {@link AbstractArchiveFile} implementations to be automatically instantiated by {@link FileFactory},\n * this interface needs to be implemented and an instance registered with {@link FileFactory}.\n *\n * @author Nicolas Rinaudo, Maxence Bernard\n * @see AbstractArchiveFile\n * @see FileFactory\n */\npublic interface ArchiveFormatProvider {\n\n /**\n * Creates a new instance of \n * A typical implementation of {@link #authenticate(FileURL)} will look for {@link Credentials} matching the\n * specified URL and, if one set (or more) is found, call {@link FileURL#setCredentials(Credentials)} to set them.\n * Likewise, this method may also look for and set {@link FileURL#setProperty(String, String) URL properties},\n * that will be used by the corresponding {@link AbstractFile} during or after resolution.\n * \n * {@link #authenticate(FileURL)} should normally be called only for {@link FileURL} schemes that\n * {@link FileURL#getAuthenticationType() support authentication}. Implementations should however not rely on that and\n * handle non-authenticated URLs as a no-op.\n * \n * A default authenticator can be registered at {@link FileFactory#setDefaultAuthenticator(Authenticator)}.\n *\n * @see FileURL#getAuthenticationType()\n * @see FileFactory#setDefaultAuthenticator(Authenticator)\n * @see FileFactory#getFile(FileURL, AbstractFile, Authenticator, Object...)\n * @author Maxence Bernard\n */\npublic interface Authenticator {\n\n /**\n * Authenticates the specified {@link FileURL} instance.\n *\n * @param fileURL the file URL to authenticate\n */\n void authenticate(FileURL fileURL);\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/Credentials.java",
"content": "package com.mucommander.commons.file;\n\n/**\n * This class is a container for a login and password pair, used to authenticate a location on a filesystem.\n *\n * @see com.mucommander.commons.file.FileURL\n * @author Maxence Bernard\n */\npublic final class Credentials {\n\n private final String login;\n private final String password;\n\t\n /**\n * Creates a new instance with the supplied login and password.\n * Any provided null values will be replaced by empty strings.\n *\n * @param login the login part as a string\n * @param password the password part as a string\n */\n public Credentials(String login, String password) {\n this.login = login == null ? \"\" : login;\n this.password = password == null ? \"\" : password;\n }\n\n /**\n * Returns the login part. The returned login may be an empty string but never \n * Credentials are said to be empty if both login and password are empty strings.\n *\n * @return \n * Empty Credentials and \n * The {@link #getRealm(FileURL)} implementation returns a URL with the same scheme and host (if any) as the specified\n * URL, and a path set to This parser can not only parse URLs but also local absolute paths and UNC paths. Upon parsing, these paths are\n * turned into equivalent, fully qualified URLs.\n *\n * \n * Local absolute paths are turned into corresponding 'file' URLs. Local paths are system-dependent, their form and\n * path separator vary from one OS to the other. Only native paths are supported, i.e. Windows-style paths are supported\n * only when running on Windows (or OS/2), Unix-style paths only on an OS that uses them natively...\n * Here are a couple example of how local paths are parsed and turned into FileURL instances: \n * \n * Windows-style UNC paths such as This class should NOT be subclassed for proper AbstractFile implementations. It should only be used in certain\n * circumstances that require creating a quick AbstractFile implementation where only a few methods will be used.\n *\n * @author Maxence Bernard\n */\npublic class DummyFile extends AbstractFile {\n\n public DummyFile(FileURL url) {\n super(url);\n }\n\n /**\n * Implementation notes: always returns See the {@link MutableFileAttributes} for an extended interface that include file attribute setters.\n *\n * @see MutableFileAttributes\n * @see SimpleFileAttributes\n * @author Maxence Bernard\n */\npublic interface FileAttributes {\n\n /**\n * Returns the file's path, The format and separator character of the path are filesystem-dependent.\n *\n * @return the file's path, \n * In order to allow the \n * Built-in file protocols are:\n * \n * In order to allow the \n * Built-in file formats are:\n * \n * If a {@link ProtocolProvider} was already registered to the specified protocol, it will automatically be\n * unregistered.\n *\n * \n * The \n * After this call, the various {@link #getFile(String) getFile} methods will be able to resolve files using the\n * specified protocol.\n *\n * \n * Built-in file protocols are listed in {@link FileProtocols}.\n *\n * @param protocol identifier of the protocol to register.\n * @param provider object used to create instances of files using the specified protocol.\n * @return the previously registered protocol provider if any, All objects returned by the iterator's \n * To unregister the provider of a particular archive format without knowing the associated provider instance, use\n * {@link #getArchiveFormatProvider(String)} with a known archive filename to retrieve the provider instance.\n * For example, This method does not throw any IOException but returns This method does not throw any IOException but returns Specifying the file parent if an instance already exists allows to recycle the AbstractFile instance\n * instead of creating a new one when the parent file is requested.\n *\n * @param fileURL the file URL representing the file to be created\n * @param authenticator used to authenticate the specified location if its protocol\n * {@link FileURL#getAuthenticationType() is authenticated} and the location contains no credentials already.\n * If the value is The returned file may be a {@link LocalFile} or a {@link AbstractArchiveFile} if the extension corresponds\n * to a registered archive format.\n *\n * @param desiredFilename the desired filename for the temporary file. If a file with this name already exists\n * in the temp directory, the filename's prefix (name without extension) will be appended an ID, but the filename's\n * extension will always be preserved.\n * @param deleteOnExit if \n * Note that return {@link AbstractArchiveFile} instances may not actually be archives according to\n * {@link AbstractFile#isArchive()}. An {@link AbstractArchiveFile} instance that is not currently an archive \n * (either non-existent or a directory) will behave as a regular (non-archive) file. This allows file instances to\n * go from being an archive to not being an archive (and vice-versa), without having to re-resolve the file.\n */\n public static AbstractFile wrapArchive(AbstractFile file) throws IOException {\n String filename = file.getName();\n\n // Looks for an archive FilenameFilter that matches the given filename.\n // Comparing the filename against each and every archive extension has a cost, so we only perform the test if\n // the filename contains a dot '.' character, since most of the time this method is called with a filename that\n // doesn't match any of the filters.\n if (filename.indexOf('.') >= 0) {\n ArchiveFormatProvider provider = getArchiveFormatProvider(filename);\n if (provider != null) {\n return provider.getFile(file);\n }\n }\n\n return file;\n }\n\n /**\n * Same as wrapArchive(AbstractFile) but using the given extension rather than the file's extension.\n */\n public static AbstractFile wrapArchive(AbstractFile file, String extension) throws IOException {\n ArchiveFormatProvider provider = getArchiveFormatProvider(file.getBaseName() + extension);\n return provider != null ? provider.getFile(file) : file;\n }\n\n\n /**\n * Returns the default {@link com.mucommander.commons.file.icon.FileIconProvider} instance. The default provider class\n * (before {@link #setDefaultFileIconProvider(com.mucommander.commons.file.icon.FileIconProvider)} is called) is\n * platform-dependent and as such may vary across platforms.\n *\n * It is noteworthy that the provider returned by this method is used by {@link com.mucommander.commons.file.AbstractFile#getIcon()}\n * to create and return the icon.\n *\n * @return the default FileIconProvider implementation\n */\n public static FileIconProvider getDefaultFileIconProvider() {\n return defaultFileIconProvider;\n }\n\n /**\n * Sets the default {@link com.mucommander.commons.file.icon.FileIconProvider} implementation.\n *\n * It is noteworthy that the provider returned by this method is used by {@link com.mucommander.commons.file.AbstractFile#getIcon()}\n * to create and return the icon.\n *\n * @param fip the new value for the default FileIconProvider\n */\n public static void setDefaultFileIconProvider(FileIconProvider fip) {\n defaultFileIconProvider = fip;\n }\n\n /**\n * Returns the default {@link Authenticator} that is used for authenticating {@link FileURL} instances prior\n * to resolving the corresponding file.\n *\n * @return the default {@link Authenticator} that is used for authenticating {@link FileURL} instances prior\n * to resolving the corresponding file\n * @see Authenticator\n */\n public static Authenticator getDefaultAuthenticator() {\n return defaultAuthenticator;\n }\n\n /**\n * Sets the default {@link Authenticator} that is used for authenticating {@link FileURL} instances prior\n * to resolving the corresponding file.\n *\n * @param authenticator the new default {@link Authenticator}\n * @see Authenticator\n */\n public static void setDefaultAuthenticator(Authenticator authenticator) {\n defaultAuthenticator = authenticator;\n }\n\n private static Logger getLogger() {\n if (logger == null) {\n logger = LoggerFactory.getLogger(FileFactory.class);\n }\n return logger;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/FileOperation.java",
"content": "package com.mucommander.commons.file;\n\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\nimport java.lang.reflect.Method;\n\n/**\n * @author Maxence Bernard\n * @see UnsupportedFileOperationException\n * @see AbstractFile\n */\npublic enum FileOperation {\n /**\n * Represents a 'read' operation, as specified by {@link AbstractFile#getInputStream()}.\n *\n * @see AbstractFile#getInputStream()\n **/\n READ_FILE,\n\n /**\n * Represents a 'random read' operation, as specified by {@link AbstractFile#getRandomAccessInputStream()}.\n *\n * @see AbstractFile#getRandomAccessInputStream()\n **/\n RANDOM_READ_FILE,\n\n /**\n * Represents a 'write' operation, as specified by {@link AbstractFile#getOutputStream()}.\n *\n * @see AbstractFile#getOutputStream()\n **/\n WRITE_FILE,\n\n /**\n * Represents an 'append' operation, as specified by {@link AbstractFile#getAppendOutputStream()}.\n *\n * @see AbstractFile#getAppendOutputStream()\n **/\n APPEND_FILE,\n\n /**\n * Represents a 'random write' operation, as specified by {@link AbstractFile#getRandomAccessOutputStream()}.\n *\n * @see AbstractFile#getRandomAccessOutputStream()\n **/\n RANDOM_WRITE_FILE,\n\n /**\n * Represents an 'mkdir' operation, as specified by {@link AbstractFile#mkdir()}.\n *\n * @see AbstractFile#mkdir()\n **/\n CREATE_DIRECTORY,\n\n /**\n * Represents an 'ls' operation, as specified by {@link AbstractFile#ls()}.\n *\n * @see AbstractFile#ls()\n **/\n LIST_CHILDREN,\n\n /**\n * Represents a 'delete' operation, as specified by {@link AbstractFile#delete()}.\n *\n * @see AbstractFile#delete()\n **/\n DELETE,\n\n /**\n * Represents a 'remove copy' operation, as specified by {@link AbstractFile#copyRemotelyTo(AbstractFile)}.\n */\n COPY_REMOTELY,\n\n /**\n * Represents a 'rename' operation, as specified by {@link AbstractFile#renameTo(AbstractFile)}.\n */\n RENAME,\n\n /**\n * Represents a 'change date' operation, as specified by {@link AbstractFile#setLastModifiedDate(long)}.\n *\n * @see AbstractFile#setLastModifiedDate(long)\n **/\n CHANGE_DATE,\n\n /**\n * Represents a 'change permission' operation, as specified by {@link AbstractFile#changePermission(int, int, boolean)}.\n */\n CHANGE_PERMISSION,\n\n /**\n * Represents a 'get free space' operation, as specified by {@link AbstractFile#getFreeSpace()}.\n */\n GET_FREE_SPACE,\n\n /**\n * Represents a 'change replication factor' operation, as specified by {@link AbstractFile#changeReplication(short)}}.\n */\n GET_BLOCKSIZE,\n\n /**\n * Represents a 'change replication factor' operation, as specified by {@link AbstractFile#changeReplication(short)}}.\n */\n GET_REPLICATION,\n\n /**\n * Represents a 'change replication factor' operation, as specified by {@link AbstractFile#changeReplication(short)}}.\n */\n CHANGE_REPLICATION,\n\n /**\n * Represents a 'get total space' operation, as specified by {@link AbstractFile#getTotalSpace()}.\n */\n GET_TOTAL_SPACE;\n\n private static final Logger LOGGER = LoggerFactory.getLogger(FileOperation.class);\n\n /**\n * Returns the {@link AbstractFile} method corresponding to this file operation.\n *\n * @param c the AbstractFile class for which to return a This interface also defines constants for commonly used file permissions.\n *\n * @see com.mucommander.commons.file.AbstractFile#getPermissions()\n * @author Maxence Bernard\n */\npublic interface FilePermissions extends PermissionBits {\n\n /** Empty file permissions: read/write/execute permissions cleared for user/group/other (0), none of the permission\n * bits are supported (mask is 0) */\n FilePermissions EMPTY_FILE_PERMISSIONS = new SimpleFilePermissions(0, 0);\n\n /** Default file permissions used by {@link AbstractFile#importPermissions(AbstractFile)} for permission bits that\n * are not available in the source: rw-r--r-- (644 octal). All the permission bits are marked as supported. */\n FilePermissions DEFAULT_FILE_PERMISSIONS = new SimpleFilePermissions(420, FULL_PERMISSION_BITS);\n\n /** Default directory permissions used by {@link AbstractFile#importPermissions(AbstractFile)} for permission bits that\n * are not available in the source: rwxr-xr-x (755 octal). All the permission bits are marked as supported. */\n FilePermissions DEFAULT_DIRECTORY_PERMISSIONS = new SimpleFilePermissions(493, FULL_PERMISSION_BITS);\n\n FilePermissions DEFAULT_EXECUTABLE_PERMISSIONS = new SimpleFilePermissions(493, FULL_PERMISSION_BITS);\n\n\n /**\n * Returns the mask that indicates which permission bits are significant and should be taken into account.\n * Permission bits that are unsupported have no meaning and their value should simply be ignored.\n *\n * @return the mask that indicates which permission bits are significant and should be taken into account.\n */\n PermissionBits getMask();\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/FileProtocols.java",
"content": "package com.mucommander.commons.file;\n\n/**\n * This interface contains a set of known protocol names, that can be found in {@link FileURL}. \n *\n * @author Maxence Bernard, Nicolas Rinaudo\n */\npublic interface FileProtocols {\n\n /** Protocol for local or locally mounted files. */\n String FILE = \"file\";\n\n /** Protocol for files served by an FTP server. */\n String FTP = \"ftp\";\n\n /** Protocol for files served by a web server using HTTP. */\n String HTTP = \"http\";\n\n /** Protocol for files served by an HDFS (Hadoop distributed filesystem) cluster. */\n String HDFS = \"hdfs\";\n\n /** Protocol for files served by a web server using HTTPS. */\n String HTTPS = \"https\";\n\n /** Protocol for files served by an NFS server. */\n String NFS = \"nfs\";\n\n /** Protocol for files served by an Amazon S3 (or protocol-compatible) server. */\n String S3 = \"s3\";\n\n /** Protocol for files served by an SFTP server (not to be confused with FTPS or SCP). */\n String SFTP = \"sftp\";\n\n /** Protocol for files served by an SMB/CIFS server. */\n String SMB = \"smb\";\n\n /** Protocol for files served by a web server using WebDAV/HTTP. */\n String WEBDAV = \"webdav\";\n\n /** Protocol for files served by a web server using WebDAV/HTTPS. */\n String WEBDAVS = \"webdavs\";\n \n /** Protocol for files served by a web server using vSphere. */\n String VSPHERE = \"vsphere\";\n\n /** Protocol for files on android devices. */\n String ADB = \"adb\";\n\n /** Protocol for avrdude programmer. */\n String AVR = \"avr\";\n\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/FileURL.java",
"content": "package com.mucommander.commons.file;\r\n\r\nimport com.mucommander.commons.file.compat.CompatURLStreamHandler;\r\nimport com.mucommander.commons.file.impl.local.LocalFile;\r\nimport com.mucommander.commons.file.util.PathUtils;\r\nimport com.mucommander.commons.runtime.OsFamily;\r\nimport com.mucommander.commons.util.StringUtils;\r\n\r\nimport java.io.UnsupportedEncodingException;\r\nimport java.net.MalformedURLException;\r\nimport java.net.URL;\r\nimport java.net.URLEncoder;\r\nimport java.nio.charset.StandardCharsets;\r\nimport java.util.HashMap;\r\nimport java.util.HashSet;\r\nimport java.util.Map;\r\nimport java.util.Set;\r\n\r\n/**\r\n * This class represents a Uniform Resource Locator (URL). The general format of a URL is as follows:\r\n * \r\n * FileURL cannot be instantiated directly, instances can be created using {@link #getFileURL(String)}.\r\n * Unlike the \r\n * In addition to standard URL features, FileURL gives access to scheme-specific attributes:\r\n * \r\n * In addition to providing those attributes, a SchemeHandler provides a {@link SchemeParser}\r\n * instance which takes care of the actual parsing of URLs of a particular scheme when {@link #getFileURL(String)} is\r\n * invoked. This allows for scheme-specific parsing, like for example for the query part which should only be parsed\r\n * and considered as a separate part for certain schemes such as HTTP.\r\n * \r\n * This class registers a number of handlers for the schemes/protocols supported by the muCommander file API.\r\n * Additional handlers can be registered dynamically using {@link #registerHandler(String, SchemeHandler)}. Likewise,\r\n * existing handlers can be unregistered or replaced at runtime using \r\n * A {@link #getDefaultHandler() default handler} is used for schemes that do not have a specific handler registered.\r\n * It provides default values for the above-mentioned attributes and provides a parser that parses those scheme URLs.\r\n * The default handler's parser is also used for parsing locations passed to {@link #getFileURL(String)} that do not\r\n * contain a scheme (i.e. without the leading \r\n * This class provides methods to attach properties to a FileURL instance. These properties are not part of the URL\r\n * itself and are absent from its string representation. They allow protocol-specific properties like connection\r\n * settings to be passed along, to {@link AbstractFile} instances in particular.\r\n *\r\n * \r\n * This class has the several limitations that are worth noting:\r\n * \r\n * Important: after calling this method, the scheme should also be changed to match the new handler --\r\n * changing the handler without changing the scheme to an appropriate one will result in inconsistent\r\n * scheme-specific attributes to be returned.\r\n *\r\n * @param handler the \r\n * Important: after calling this method, the handler should also be changed to match the new scheme --\r\n * changing the scheme without changing the handler to an appropriate one will result in inconsistent\r\n * scheme-specific attributes to be returned.\r\n *\r\n * @param scheme new scheme part of this URL.\r\n * @throws IllegalArgumentException if the specified is null or an empty string\r\n * @see #getScheme()\r\n */\r\n public void setScheme(String scheme) {\r\n if (scheme == null) {\r\n throw new IllegalArgumentException();\r\n }\r\n\r\n this.scheme = scheme;\r\n\r\n urlModified();\r\n }\r\n\r\n /**\r\n * Returns the host part of this URL, Some file protocols may not have a notion of standard port or even no use for the port part at all, for\r\n * example those that are not TCP or UDP based such as the local 'file' scheme.\r\n *\r\n * This method is just a shorthand for This method is just a shorthand for The returned credentials may or may be of any use for the scheme's file protocol depending on the value\r\n * returned by {@link #getAuthenticationType()}.\r\n *\r\n * @return the credentials contained by this URL, Credentials may or may not be of any use for the scheme's file protocol depending on the value\r\n * returned by {@link #getAuthenticationType()}.\r\n *\r\n * @param credentials the new login and password parts, replacing any existing credentials. If null is passed,\r\n * existing credentials will be discarded.\r\n * @see #getCredentials()\r\n */\r\n public void setCredentials(Credentials credentials) {\r\n // Empty credentials are equivalent to null credentials\r\n this.credentials = credentials == null || credentials.isEmpty() ? null : credentials;\r\n urlModified();\r\n }\r\n\r\n /**\r\n * Returns this scheme's guest credentials, \r\n * Guest credentials offer a way to authenticate a URL as a 'guest' on file protocols that require a set of\r\n * credentials to establish a connection. The returned credentials are provided with no guarantee that the filesystem\r\n * will actually accept them and allow the request/connection. The notion of 'guest' credentials may or may not\r\n * have a meaning depending on the underlying file protocol.\r\n *\r\n * This method is just a shorthand for This method is just a shorthand for \r\n * The returned FileURL will have the same handler, scheme, host, port, credentials and properties as this one.\r\n * The query part of the returned parent URL will always be Note: this method returns a new FileURL instance every time it is called, and all mutable fields of this FileURL\r\n * are cloned. Therefore, the returned URL can be safely modified without any risk of side effects.\r\n *\r\n * @return this URL's parent, Note: this method returns a new FileURL instance every time it is called. Therefore the returned FileURL can\r\n * safely be modified without any risk of side effects.\r\n\r\n * This method is just a shorthand for \r\n * There is no The returned It is important to note that this method is provided for interoperability purposes, for the sole purpose of\r\n * connecting to APIs that require a It is noteworthy that this method uses \r\n * Two \r\n * Credentials (login and password parts) are compared only if requested. The comparison for both the login and\r\n * password is case-sensitive. See the {@link SimpleFileAttributes} class for an implementation of this interface.\n *\n * @author Maxence Bernard\n * @see SimpleFileAttributes\n */\npublic interface MutableFileAttributes extends FileAttributes {\n\n /**\n * Sets the file's path.\n *\n * The format and separator character of the path are filesystem-dependent.\n *\n * @param path the file's path\n */\n void setPath(String path);\n\n /**\n * Sets whether the file exists physically on the underlying filesystem.\n *\n * @param exists Permission bits can be queried individually using {@link #getBitValue(int, int)} or be represented altogether\n * as a UNIX-style permission int, using {@link #getIntValue()}.\n *\n * Two implementations of this interface are provided:\n * \n * For {@link AbstractFile} implementations to be automatically instantiated by {@link FileFactory}, this interface\n * needs to be implemented and an instance registered with {@link FileFactory} and bound to a protocol identifier.\n *\n * @author Nicolas Rinaudo, Maxence Bernard\n * @see FileFactory\n * @see AbstractFile\n */\npublic interface ProtocolProvider {\n /**\n * Creates a new instance of \n * Throws a {@link UnsupportedFileOperationException} if the underlying file does not support the required\n * read and write {@link FileOperation file operations}. Throws an \n * Throws a {@link UnsupportedFileOperationException} if the underlying file does not support the required\n * read and write {@link FileOperation file operations}. Throws an \n * This method will create this entry as a regular file in the archive if it doesn't already exist, or replace\n * it if it already does.\n *\n * @throws IOException if an I/O error occurred\n */\n @Override\n public OutputStream getOutputStream() throws IOException {\n if (entry.exists()) {\n try {\n delete();\n } catch(IOException e) {\n // Go ahead and try to add the file anyway\n }\n }\n\n // Update the ArchiveEntry's size as data gets written to the OutputStream\n OutputStream out = new CounterOutputStream(((AbstractRWArchiveFile)archiveFile).addEntry(entry),\n new ByteCounter() {\n @Override\n public synchronized void add(long nbBytes) {\n entry.setSize(entry.getSize()+nbBytes);\n entry.setDate(System.currentTimeMillis());\n }\n });\n entry.setExists(true);\n\n return out;\n }\n\n @Override\n public void changePermissions(int permissions) throws IOException {\n if (!entry.exists()) {\n throw new IOException();\n }\n\n FilePermissions oldPermissions = entry.getPermissions();\n FilePermissions newPermissions = new SimpleFilePermissions(permissions, oldPermissions.getMask());\n entry.setPermissions(newPermissions);\n\n boolean success = updateEntryAttributes();\n if (!success) { // restore old permissions if attributes could not be updated\n entry.setPermissions(oldPermissions);\n }\n\n if (!success) {\n throw new IOException();\n }\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/SchemeHandler.java",
"content": "package com.mucommander.commons.file;\n\n/**\n * \n * In addition to providing those attributes, a SchemeHandler provides a {@link SchemeParser} instance which takes care\n * of the actual parsing of URLs of a particular scheme when {@link FileURL#getFileURL(String)} is invoked. This allows\n * for scheme-specific parsing, like for example for the query part which should only be parsed and considered as a\n * separate part for certain schemes such as HTTP.\n *\n * \n * This method returns a new FileURL instance every time it is called. Therefore, the returned URL can\n * safely be modified without any risk of side effects.\n *\n * @param location the location for which to return the authentication realm\n * @return the authentication realm of the specified url\n */\n FileURL getRealm(FileURL location);\n\n /**\n * Returns the scheme's guest credentials, \n * Guest credentials offer a way to authenticate a URL as a 'guest' on file protocols that require a set of\n * credentials to establish a connection. The returned credentials are provided with no guarantee that the filesystem\n * will actually accept them and allow the request/connection. The notion of 'guest' credentials may or may not\n * have a meaning depending on the underlying file protocol.\n *\n * @return the scheme's guest credentials, Some parts such as the query and fragment have a meaning only for certain schemes such as HTTP, other schemes\n * may simply ignore the corresponding query/fragment delimiters ('?' and '#' resp.) and include them in the\n * path part.\n *\n * @param url the URL to parse\n * @param fileURL the FileURL instance in which to set the different parsed parts\n * @throws MalformedURLException if the specified string is not a valid URL and cannot be parsed\n */\n void parse(String url, FileURL fileURL) throws MalformedURLException;\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/SevenZipArchiveFormatDetector.java",
"content": "/*\n * This file is part of trolCommander, http://www.trolsoft.ru/en/soft/trolcommander\n * Copyright (C) 2014-2026 Oleg Trifonov\n *\n * trolCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * trolCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see Attributes can also be manually updated using attribute setters. The {@link #updateExpirationDate()} method allows\n * to reset the expiration date and consider the attributes as 'fresh'.\n *\n * An initial value for the attributes 'time to live' is specified in the constructor and can later be changed using\n * {@link #setTtl(long)}. If the 'time to live' is set to -1, attributes are no longer automatically updated, this class\n * then simply acts as {@link com.mucommander.commons.file.SimpleFileAttributes}.\n *\n * @author Maxence Bernard\n */\npublic abstract class SyncedFileAttributes extends SimpleFileAttributes {\n\n /** The attributes' 'time to live', negative values disable automatic attributes updates */\n private long ttl;\n\n /** The attributes' expiration timestamp/date */\n private long expirationDate;\n\n /** True when attributes are being updated */\n private boolean isUpdating;\n\n\n /**\n * Creates a new SyncedFileAttributes using the specifies 'time to live' value.\n *\n * @param ttl the attributes' 'time to live', in milliseconds\n * @param updateAttributesNow if \n * This exception is to be thrown in a way that is independent of the actual file instance, and of I/O or\n * network conditions: an Subclasses implement specific archive formats (Zip, Tar...) but cannot be instantiated directly.\n * Instead, the Archive formats fall into 2 categories:\n * Implementation note: Archiver implementations must override this method to handle comments\n *\n * @param comment the comment to be stored in the archive\n */\n public void setComment(String comment) {\n // No-op\n }\n\n\n /**\n * Normalizes the entry path, that is :\n * This method will first attempt to get a {@link RandomAccessOutputStream} if the given file is able to supply\n * one, and if not, fall back to a regular If the entry is a regular file (not a directory), an OutputStream which can be used to write the contents\n * of the entry will be returned, If this Archiver uses a single entry format, the specified path and file won't be used at all.\n * Also in this case, this method must be invoked only once (single entry), it will throw an IOException\n * if invoked more than once.\n *\n * @param entryPath the path to be used to create the entry in the archive. This parameter is simply ignored if the\n * archive is a single entry format.\n * @param attributes used to determine whether the entry is a directory or regular file, and to retrieve its\n * date and size\n * @return By default, this value is 300 seconds (5 minutes).\n *\n * @return the number of seconds of inactivity after which {@link ConnectionPool} will close the connection,\n * By default, this value is 300 seconds (5 minutes).\n *\n * @param nbSeconds the number of seconds of inactivity after which {@link ConnectionPool} will close the connection,\n * By default, this value is -1 (keep alive disabled).\n *\n * @return the number of seconds of inactivity after which {@link ConnectionPool} will keep the connection alive\n * by calling {@link #keepAlive()}, By default, this value is -1 (keep alive disabled).\n *\n * @param nbSeconds the number of seconds of inactivity after which {@link ConnectionPool} will keep the connection\n * alive by calling {@link #keepAlive()}, Implementation note: This method must not perform any I/O which could block the calling thread.\n *\n * @return Implementation note: the implementation must guarantee that any calls to {@link #isConnected()} after this\n * method has been called return false.\n */\n public abstract void closeConnection();\n\n /**\n * Keeps this connection alive.\n *\n * Implementation note: if keep alive is not available in the underlying protocol or\n * simply unnecessary, this method should be implemented as a no-op (do nothing).\n */\n public abstract void keepAlive();\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/connection/ConnectionHandlerFactory.java",
"content": "package com.mucommander.commons.file.connection;\n\nimport com.mucommander.commons.file.FileURL;\n\n/**\n * This interface should be implemented by classes that are able to create ConnectionHandler instances for a given\n * server location, typically {@link com.mucommander.commons.file.AbstractFile} implementations.\n *\n * This interface allows to take advantage of {@link ConnectionPool} to share connections across\n * {@link com.mucommander.commons.file.AbstractFile} instances.\n *\n * @author Maxence Bernard\n */\npublic interface ConnectionHandlerFactory {\n\n /**\n * Creates and returns a {@link ConnectionHandler} instance for the given location.\n */\n ConnectionHandler createConnectionHandler(FileURL location);\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/connection/ConnectionPool.java",
"content": "package com.mucommander.commons.file.connection;\n\nimport java.io.InterruptedIOException;\nimport java.util.ArrayList;\nimport java.util.Iterator;\nimport java.util.List;\n\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\nimport com.mucommander.commons.file.Credentials;\nimport com.mucommander.commons.file.FileURL;\n\n\n/**\n * @see com.mucommander.commons.file.connection.ConnectionHandler\n * @author Maxence Bernard\n */\npublic class ConnectionPool implements Runnable {\n private static final Logger LOGGER = LoggerFactory.getLogger(ConnectionPool.class);\n\n /** Singleton instance */\n private static final ConnectionPool instance = new ConnectionPool();\n\n /** List of registered ConnectionHandler */\n private final static List The {@link #isInverted() inverted} mode has no effect on the values returned by this method.\n *\n * @param value the value to be tested\n * @return true if the given value was rejected by this filter\n */\n public boolean reject(C value) {\n return !accept(value);\n }\n\n /**\n * Convenience method that filters out files that do not {@link #match(AbstractFile) match} this filter and\n * returns a file array of matched The extension(s) may be any string, but when used in the traditional sense of a file extension (e.g. zip extension)\n * the '.' character must be included in the specified extension (e.g. \".zip\" must be used, not just \"zip\").\n *\n * @author Maxence Bernard, Nicolas Rinaudo\n */\npublic class AbstractExtensionFilter extends AbstractStringCriterionFilter {\n\n /** File extensions to match against criterion values */\n private final char[][] extensions;\n\n /**\n * Creates a new If this {@link ChainedFileFilter} contains no filter, this method will always return Only one attribute can be matched at a time. To match several attributes, combine them using a\n * {@link com.mucommander.commons.file.filter.ChainedFileFilter}.\n *\n * @author Maxence Bernard\n */\npublic class AttributeFileFilter extends AbstractFileFilter {\n\n\tpublic enum FileAttribute {\n\t\t/** Tests if the file is a {@link com.mucommander.commons.file.AbstractFile#isDirectory() directory}. */\n\t\tDIRECTORY,\n\t\t/** Tests if the file is a regular file, i.e. not a directory. This is equivalent to negating {@link #DIRECTORY}. */\n\t\tFILE,\n\t\t/** Tests if the file is {@link com.mucommander.commons.file.AbstractFile#isBrowsable() browsable}. */\n\t\tBROWSABLE,\n\t\t/** Tests if the file is an {@link com.mucommander.commons.file.AbstractFile#isArchive() archive}. */\n\t\tARCHIVE,\n\t\t/** Tests if the file is a {@link com.mucommander.commons.file.AbstractFile#isSymlink() symlink}. */\n\t\tSYMLINK,\n\t\t/** Tests if the file is {@link com.mucommander.commons.file.AbstractFile#isHidden() hidden}. */\n\t\tHIDDEN,\n\t\t/** Tests if the file is a {@link com.mucommander.commons.file.AbstractFile#isRoot() root folder}. */\n\t\tROOT,\n\t\t/** Tests if the file is a {@link com.mucommander.commons.file.AbstractFile#isSystem() system file}. */\n\t\tSYSTEM\n\t}\n\n /** The attribute to test files against */\n private FileAttribute attribute;\n\n\n /**\n * Creates a new The {@link AndFileFilter} and {@link OrFileFilter} implementations match files that respectively match all of\n * the registered filters, or any of them.\n *\n * @see AndFileFilter\n * @see OrFileFilter\n * @author Maxence Bernard\n */\npublic abstract class ChainedFileFilter extends AbstractFileFilter {\n\n /** List of registered FileFilter */\n protected List Several convenience methods are provided to operate this filter on a set of criteria values, and filter out\n * values that are rejected by this filter.\n *\n * @see AbstractPathFilter\n * @author Maxence Bernard\n */\npublic interface CriterionFilter The {@link #isInverted() inverted} mode has no effect on the values returned by this method.\n *\n * @param value the value to be tested\n * @return true if the given value was rejected by this filter\n */\n boolean reject(C value);\n\n /**\n * Convenience method that filters out files that do not {@link #match(AbstractFile) match} this filter and\n * returns a file array of matched The extension(s) may be any string, but when used in the traditional sense of a file extension (e.g. zip extension)\n * the '.' character must be included in the specified extension (e.g. \".zip\" must be used, not just \"zip\").\n * \n * @author Maxence Bernard, Nicolas Rinaudo\n */\npublic class ExtensionFilenameFilter extends AbstractExtensionFilter implements FilenameFilter {\n\n /**\n * Creates a case-insensitive The extension(s) may be any string, but when used in the traditional sense of a file extension (e.g. zip extension)\n * the '.' character must be included in the specified extension (e.g. \".zip\" must be used, not just \"zip\").\n * \n * @author Maxence Bernard, Nicolas Rinaudo\n */\npublic class ExtensionPathFilter extends AbstractExtensionFilter implements PathFilter {\n\n /**\n * Creates a case-insensitive Several convenience methods are provided to operate this filter on a set of files, and filter out files that\n * do not match this filter.\n *\n * A The {@link #isInverted() inverted} mode has no effect on the values returned by this method.\n *\n * @param file the file to test\n * @return true if the given file was rejected by this FileFilter\n */\n boolean reject(AbstractFile file);\n\n /**\n * Convenience method that filters out files that do not {@link #match(AbstractFile) match} this filter and\n * returns a file array of matched The {@link #isInverted() inverted} mode has no effect on the values returned by this method.\n *\n * @param file the file to test\n * @return true if the given file was accepted by this FileFilter\n */\n boolean accept(AbstractFile file);\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/FileOperationFilter.java",
"content": "package com.mucommander.commons.file.filter;\n\nimport com.mucommander.commons.file.AbstractFile;\nimport com.mucommander.commons.file.FileOperation;\n\n/**\n * Only one file operation can be matched at a time. To match several file operations, combine them using a\n * {@link com.mucommander.commons.file.filter.ChainedFileFilter}.\n *\n * @see FileOperation\n * @author Maxence Bernard\n */\npublic class FileOperationFilter extends AbstractFileFilter {\n\n /** The file operation to match */\n private FileOperation op;\n\n\n public FileOperationFilter(FileOperation op) {\n this(op, false);\n }\n\n public FileOperationFilter(FileOperation op, boolean inverted) {\n super(inverted);\n setFileOperation(op);\n }\n\n /**\n * Returns the file operation this filter matches.\n *\n * @return the file operation this filter matches.\n */\n public FileOperation getFileOperation() {\n return op;\n }\n\n /**\n * Sets the file operation this filter matches, replacing the previous operation.\n *\n * @param op the file operation this filter matches.\n */\n public void setFileOperation(FileOperation op) {\n this.op = op;\n }\n\n\n @Override\n public boolean accept(AbstractFile file) {\n return file.isFileOperationSupported(op);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/FilenameFilter.java",
"content": "package com.mucommander.commons.file.filter;\n\nimport com.mucommander.commons.file.AbstractFile;\n\n/**\n * A If this {@link ChainedFileFilter} contains no filter, this method will always return This method is called by {@link CachedFileIconProvider#getFileIcon(com.mucommander.commons.file.AbstractFile, java.awt.Dimension)}\n * each time an icon is requested. If This method is called only if the prior call to {@link #isCacheable(com.mucommander.commons.file.AbstractFile, java.awt.Dimension)}\n * returned This method is called only if the prior call to {@link #isCacheable(com.mucommander.commons.file.AbstractFile, java.awt.Dimension)}\n * returned This class does not actually provide icons nor does it manage the contents of the cache ; it delegates these tasks\n * to a {@link CacheableFileIconProvider} instance. All this class does is use the cache implementation to harness its\n * benefits and take all the credit for it. If the file icon is cacheable, {@link CacheableFileIconProvider#lookupCache(com.mucommander.commons.file.AbstractFile, java.awt.Dimension)}\n * is called to look for a previously cached icon. If a value is found, it is returned. If not,\n * {#getFileIcon(com.mucommander.commons.file.AbstractFile, java.awt.Dimension)} is called on the If the file icon is not cacheable, {#getFileIcon(com.mucommander.commons.file.AbstractFile, java.awt.Dimension)}\n * is simply called on the The specified Icons are stored as {@link java.lang.ref.SoftReference soft references} so they can be garbage collected \n * when the VM runs low on memory.\n *\n * The implementation uses the {@link ReferenceMap} class part of the This class implements {@link #getFileIcon(com.mucommander.commons.file.AbstractFile, java.awt.Dimension)} and passes on\n * requests for local file icons to {@link #getLocalFileIcon(com.mucommander.commons.file.impl.local.LocalFile, com.mucommander.commons.file.AbstractFile, java.awt.Dimension)}.\n * On the other hand, requests for non-local file icons are transformed to local ones, by creating a local temporary\n * file with the same name (the best effort) and extension (guaranteed) as the non-local file, and passes on the file\n * to {@link #getLocalFileIcon(com.mucommander.commons.file.impl.local.LocalFile, com.mucommander.commons.file.AbstractFile, java.awt.Dimension)}.\n *\n * @author Maxence Bernard\n */\npublic abstract class LocalFileIconProvider implements FileIconProvider {\n\n /**\n * Creates a returns a temporary local file/directory with the same extension as the specified file/directory\n * (guaranteed), and the same filename as much as possible (the best effort).\n * This method returns The specified Icons are provided by one of the two following Swing classes; the one that provides the best results on the\n * target platform is used:\n * \n * The initialization must be triggered by a thread other than the EventDispatchThread, or a deadlock may happen\n * on platforms where JFileChooser is used. This method provides to control when and where the initialization occurs.\n */\n public static void forceInit() {\n SwingFileIconProviderImpl.checkInit();\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/icon/impl/SwingFileIconProviderImpl.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see The values are retrieved and cached only when the 'cached methods' are called for the first time; they are\r\n * not preemptively retrieved in the constructor, so using this class has no negative impact on performance,\r\n * except for the small extra CPU cost added by proxying the methods and the extra RAM used to store cached values.\r\n *\r\n * Once the values are retrieved and cached, they never change: the same value will always be returned once a method\r\n * has been called for the first time. That means if the underlying file changes (e.g. its size or date has changed),\r\n * the changes will not be reflected by this CachedFile. Thus, this class should only be used when a 'real-time' view\r\n * of the file is not required, or when the file instance is used only for a small amount of time.\r\n *\r\n * @author Maxence Bernard\r\n */\r\n@Slf4j\r\npublic class CachedFile extends ProxyFile {\r\n // Used to access the java.io.FileSystem#getBooleanAttributes method\r\n private static final boolean GET_FILE_ATTRIBUTES_AVAILABLE;\r\n private static final Method M_GET_BOOLEAN_ATTRIBUTES;\r\n private static final int BA_DIRECTORY, BA_EXISTS, BA_HIDDEN;\r\n private static final Object FS;\r\n private static final boolean NATIVE_FILE_UTILS_AVAILABLE = OsFamily.MAC_OS_X.isCurrent() && NativeFileUtils.init();\r\n\r\n // set-flags\r\n private static final int SIZE_SET_MASK = 1;\r\n private static final int LAST_MODIFICATION_SET_MASK = 1 << 1;\r\n private static final int SYMLINK_SET_MASK = 1 << 2;\r\n private static final int DIRECTORY_SET_MASK = 1 << 3;\r\n private static final int ARCHIVE_SET_MASK = 1 << 4;\r\n private static final int EXECUTABLE_SET_MASK = 1 << 5;\r\n private static final int HIDDEN_SET_MASK = 1 << 6;\r\n private static final int ABSOLUTE_PATH_SET_MASK = 1 << 7;\r\n private static final int CANONICAL_PATH_SET_MASK = 1 << 8;\r\n private static final int EXTENSION_SET_MASK = 1 << 9;\r\n private static final int NAME_SET_MASK = 1 << 10;\r\n private static final int FREE_SPACE_SET_MASK = 1 << 11;\r\n private static final int TOTAL_SPACE_SET_MASK = 1 << 12;\r\n private static final int EXISTS_SET_MASK = 1 << 13;\r\n private static final int PERMISSIONS_SET_MASK = 1 << 14;\r\n private static final int PERMISSIONS_STRING_SET_MASK = 1 << 15;\r\n private static final int OWNER_SET_MASK = 1 << 16;\r\n private static final int GROUP_SET_MASK = 1 << 17;\r\n private static final int IS_ROOT_SET_MASK = 1 << 18;\r\n private static final int PARENT_SET_MASK = 1 << 19;\r\n private static final int GET_ROOT_SET_MASK = 1 << 20;\r\n private static final int CANONICAL_FILE_SET_MASK = 1 << 21;\r\n private static final int CREATION_DATE_SET_MASK = 1 << 22;\r\n private static final int LAST_ACCESS_SET_MASK = 1 << 23;\r\n\r\n // boolean values\r\n private static final int SYMLINK_VALUE_MASK = 1 << 24;\r\n private static final int DIRECTORY_VALUE_MASK = 1 << 25;\r\n private static final int ARCHIVE_VALUE_MASK = 1 << 26;\r\n private static final int EXECUTABLE_VALUE_MASK = 1 << 27;\r\n private static final int HIDDEN_VALUE_MASK = 1 << 28;\r\n private static final int EXISTS_VALUE_MASK = 1 << 29;\r\n private static final int IS_ROOT_VALUE_MASK = 1 << 30;\r\n\r\n /** If true, AbstractFile instances returned by this class will be wrapped into CachedFile instances */\r\n private static final int RECURSE_INSTANCES_MASK = 1 << 29;\r\n\r\n /**\r\n * All boolean values stored here as bits\r\n */\r\n private int bitmask;\r\n\r\n ///////////////////\r\n // Cached values //\r\n ///////////////////\r\n \r\n private long getSize;\r\n private long getLastModified;\r\n private long getCreationDate;\r\n private long getLastAccessDate;\r\n private String getAbsolutePath;\r\n private String getCanonicalPath;\r\n private String getExtension;\r\n private String getName;\r\n private long getFreeSpace;\r\n private long getTotalSpace;\r\n private FilePermissions getPermissions;\r\n private String getPermissionsString;\r\n private String getOwner;\r\n private String getGroup;\r\n private AbstractFile getParent;\r\n private AbstractFile getRoot;\r\n private AbstractFile getCanonicalFile;\r\n\r\n /**\r\n * Cached values for This class is useful for wrapper files, such as {@link com.mucommander.commons.file.AbstractArchiveFile archive files},\n * that provide additional functionality over an existing Implementation note: the The associated {@link FileURL} scheme is {@link FileProtocols#FTP}. The host part of the URL designates the\n * FTP server. Credentials must be specified in the login and password parts as FTP servers require a login and\n * password. The path separator is '/'.\n *\n * Here are a few examples of valid FTP URLs:\n * Internally, FTPFile uses {@link ConnectionPool} to create FTP connections as needed and allows them to be reused\n * by FTPFile instances located on the same server, dealing with concurrency issues. Connections are thus managed\n * transparently and need not be manually managed.\n *\n * Some FileURL properties control certain FTP connection settings:\n * Access to FTP files is provided by the If the reply is a positive one (not an error error), this method does nothing.\n */\n private void checkServerReply() throws IOException {\n // Check that connection went ok\n int replyCode = ftpClient.getReplyCode();\n LOGGER.trace(\"server reply=\"+ftpClient.getReplyString());\n\n // Close connection if the connection dropped prematurely so that isConnected() returns false\n if (replyCode == FTPReply.SERVICE_NOT_AVAILABLE) {\n closeConnection();\n }\n\n // If not, throw an exception using the reply string\n if (!FTPReply.isPositiveCompletion(replyCode)) {\n if (replyCode == FTPReply.BAD_COMMAND_SEQUENCE || replyCode == FTPReply.NEED_PASSWORD || replyCode == FTPReply.NOT_LOGGED_IN) {\n throwAuthException(ftpClient.getReplyString());\n } else {\n throw new IOException(ftpClient.getReplyString());\n }\n }\n }\n\n\n /**\n * Checks if the given IOException corresponds to a low-level socket exception, and if that is the case,\n * closes the connection so that {@link #isConnected()} returns false.\n * All IOException raised by FTPClient should be checked by this method so that socket errors are properly detected.\n */\n private void checkSocketException(IOException e) {\n if (((e instanceof FTPConnectionClosedException) || (e instanceof SocketException) || (e instanceof SocketTimeoutException)) && isConnected()) {\n LOGGER.info(\"socket exception detected, closing connection\", e);\n closeConnection();\n }\n }\n\n\n //////////////////////////////////////\n // ConnectionHandler implementation //\n //////////////////////////////////////\n\n @Override\n public void startConnection() throws IOException {\n LOGGER.info(\"connecting to {}\", getRealm().getHost());\n\n// this.ftpClient = new CustomFTPClient();\n this.ftpClient = new FTPClient();\n\n int retriesLeft = nbConnectionRetries;\n int retryDelay = connectionRetryDelay * 1000;\n do {\n\t try {\n\t FileURL realm = getRealm();\n\t\n\t // Override default port (21) if a custom port was specified in the URL\n\t int port = realm.getPort();\n\t LOGGER.info(\"custom port={}\", port);\n\t if (port >= 0) {\n ftpClient.setDefaultPort(port);\n }\n\t\n\t // Sets the control encoding\n\t // - most modern FTP servers seem to default to UTF-8, but not all of them do.\n\t // - commons-ftp defaults to ISO-8859-1 which is not good\n\t // Note: this has to be done before the connection is established otherwise it won't be taken into account\n\t LOGGER.info(\"encoding={}\", encoding);\n\t ftpClient.setControlEncoding(encoding);\n\t\n\t // Connect to the FTP server\n\t ftpClient.connect(realm.getHost());\n\t\n\t// // Set a socket timeout: default value is 0 (no timeout)\n\t// ftpClient.setSoTimeout(CONNECTION_TIMEOUT*1000);\n\t// FileLogger.finer(\"soTimeout=\"+ftpClient.getSoTimeout());\n\t\n\t // Throw an IOException if server replied with an error\n\t checkServerReply();\n\n\t Credentials credentials = getCredentials();\n\t\n\t // Throw an AuthException if there are no credentials\n\t LOGGER.info(\"fileURL={} credentials={}\", realm.toString(true), credentials);\n\t if (credentials == null) {\n throwAuthException(null);\n }\n\t\n\t // Login\n if (credentials != null) {\n ftpClient.login(credentials.getLogin(), credentials.getPassword());\n }\n\t // Throw an IOException (potentially an AuthException) if the server replied with an error\n\t checkServerReply();\n\t\n\t // Enables/disables passive mode\n\t LOGGER.info(\"passiveMode={}\", passiveMode);\n\t if (passiveMode) {\n this.ftpClient.enterLocalPassiveMode();\n } else {\n this.ftpClient.enterLocalActiveMode();\n }\n\t\n\t // Set file type to 'binary'\n\t ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);\n\t\n\t // Issue 'LIST -al' command to list hidden files (instead of LIST -l), only if the corresponding\n\t // configuration option has been manually enabled in the preferences.\n\t // The reason for not doing so by default is that the commons-net library will fail to properly parse\n\t // directory listings on some servers when 'LIST -al' is used (bug).\n\t // Note that by default, if 'LIST -l' is used, the decision to list hidden files is left to the\n\t // FTP server: some servers will choose to show them, some will not. This behavior is usually a\n\t // configuration setting of the FTP server.\n\t ftpClient.setListHiddenFiles(FTPProtocolProvider.getForceHiddenFilesListing());\n\n\t if (encoding.equalsIgnoreCase(\"UTF-8\")) {\n\t // This command enables UTF8 on the remote server... but only a few FTP servers currently support this command\n\t ftpClient.sendCommand(\"OPTS UTF8 ON\");\n\t }\n\n\t break;\n\t } catch(IOException e) {\n // Attempt to retry if the connection failed, or if the server reply corresponds to a temporary error.\n // Unlike 5xx errors which are permanent, 4xx errors are temporary and may be retried, quote from\n // RFC 959: \"The command was not accepted and the requested action did not take place, but the error\n // condition is temporary and the action may be requested again.\"\n\t int replyCode = ftpClient.getReplyCode();\n if (!ftpClient.isConnected() || FTPReply.isNegativeTransient(replyCode)) {\n LOGGER.info((!ftpClient.isConnected()?\"Connection error\":\"Temporary server error (\"+replyCode+\")\")+\", retries left=\"+retriesLeft, e);\n\n // Retry to connect, if we have at least an attempt left\n if (retriesLeft > 0) {\n retriesLeft--;\n\n // Wait before retrying\n if (retryDelay > 0) {\n LOGGER.info(\"waiting {} ms before retrying to connect\", retryDelay);\n\n try { Thread.sleep(retryDelay); }\n catch(InterruptedException ignore) {}\n }\n\n continue;\n }\n }\n\n // Disconnect if the connection could not be established\n if (ftpClient.isConnected())\n try {\n ftpClient.disconnect();\n } catch(IOException ignore) {}\n\n // Re-throw the exception\n throw e;\n\t }\n } while(true);\n }\n\n\n @Override\n public boolean isConnected() {\n // FTPClient#isConnected() will always return true once it is connected and does not detect socket\n // disconnections. Furthermore, retrieving the underlying Socket instance does not help any more:\n // Socket#isConnected() and Socket#isClosed() do not reflect socket errors that happen after the socket is\n // connected.\n // Thus, the only way (AFAIK) to know if the socket is still connected is to intercept all IOException\n // thrown by FTPClient and check if they correspond to a socket exception.\n\n return ftpClient != null && ftpClient.isConnected();\n\n// if(ftpClient==null || !ftpClient.isConnected())\n// return false;\n//\n// Socket socket = ftpClient.getSocket();\n// FileLogger.finest(\"socket=\"+socket+\" socket.isConnected()\"+socket.isConnected()+\" socket.isClosed()=\"+socket.isClosed());\n//\n// return socket!=null && socket.isConnected() && !socket.isClosed();\n }\n\n\n @Override\n public void closeConnection() {\n if (ftpClient != null) {\n // Try to logout, this may fail if the connection is broken\n try {\n ftpClient.logout();\n } catch(IOException e) {\n e.printStackTrace();\n }\n\n // Close the socket connection\n try {\n ftpClient.disconnect();\n } catch(IOException e) {\n e.printStackTrace();\n }\n\n ftpClient = null;\n }\n }\n\n\n @Override\n public void keepAlive() {\n // Send a NOOP command to the server to keep the connection alive.\n // Note: not all FTP servers support the NOOP command.\n if (ftpClient != null) {\n try {\n ftpClient.sendNoOp();\n } catch (IOException e) {\n // Checks if the IOException corresponds to a socket error and in that case, closes the connection\n checkSocketException(e);\n }\n }\n }\n }\n\n /**\n * A Permissions implementation for FTPFile.\n */\n private static class FTPFilePermissions extends IndividualPermissionBits implements FilePermissions {\n\n private final org.apache.commons.net.ftp.FTPFile file;\n\n FTPFilePermissions(org.apache.commons.net.ftp.FTPFile file) {\n this.file = file;\n }\n\n public boolean getBitValue(int access, int type) {\n int fAccess;\n if (access == USER_ACCESS) {\n fAccess = org.apache.commons.net.ftp.FTPFile.USER_ACCESS;\n } else if (access == GROUP_ACCESS) {\n fAccess = org.apache.commons.net.ftp.FTPFile.GROUP_ACCESS;\n } else if (access == OTHER_ACCESS) {\n fAccess = org.apache.commons.net.ftp.FTPFile.WORLD_ACCESS;\n } else {\n return false;\n }\n\n int fPermission;\n if (type == READ_PERMISSION) {\n fPermission = org.apache.commons.net.ftp.FTPFile.READ_PERMISSION;\n } else if (type == WRITE_PERMISSION) {\n fPermission = org.apache.commons.net.ftp.FTPFile.WRITE_PERMISSION;\n } else if (type == EXECUTE_PERMISSION) {\n fPermission = org.apache.commons.net.ftp.FTPFile.EXECUTE_PERMISSION;\n } else {\n return false;\n }\n\n return file.hasPermission(fAccess, fPermission);\n }\n\n public PermissionBits getMask() {\n return FULL_PERMISSION_BITS; \n }\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/impl/ftp/FTPProtocolProvider.java",
"content": "package com.mucommander.commons.file.impl.ftp;\n\nimport com.mucommander.commons.file.AbstractFile;\nimport com.mucommander.commons.file.FileURL;\nimport com.mucommander.commons.file.ProtocolProvider;\n\nimport java.io.IOException;\n\n/**\n * This class is the provider for the FTP filesystem implemented by {@link com.mucommander.commons.file.impl.ftp.FTPFile}.\n *\n * @author Nicolas Rinaudo\n * @see com.mucommander.commons.file.impl.ftp.FTPFile\n */\npublic class FTPProtocolProvider implements ProtocolProvider {\n\n /** Controls whether to force the listing of hidden files */\n private static boolean forceHiddenFilesListing = false;\n\n /**\n * Controls whether to force the listing of hidden files. Enabling this option will cause 'LIST -al' commands\n * to be issued when listing files, instead of 'LIST -l'.\n * When this option is disabled, the decision to list hidden files is left to the FTP server: some servers will\n * choose to show them, some will not. This behavior is usually a configuration setting of the FTP server.\n * \n * This option is disabled by default. The reason for this is that the commons-net library will fail to properly\n * parse directory listings on some servers when 'LIST -al' is used (bug).\n *\n * @param value The actual decompression work is performed by the {@link java.util.zip.GZIPInputStream} class.\n *\n * @see com.mucommander.commons.file.impl.gzip.GzipFormatProvider\n * @author Maxence Bernard\n */\npublic class GzipArchiveFile extends AbstractROArchiveFile {\n\n /**\n * Creates a GzipArchiveFile on top of the given file.\n *\n * @param file the underlying file to wrap this archive file around\n */\n public GzipArchiveFile(AbstractFile file) {\n super(file);\n }\n\n\n ////////////////////////////////////////\n // AbstractArchiveFile implementation //\n ////////////////////////////////////////\n\n @Override\n public ArchiveEntryIterator getEntryIterator() {\n String extension = getExtension();\n String name = getName();\n\t\t\n if (extension != null) {\n extension = extension.toLowerCase();\n\t\t\t\n // Remove the 'gz' or 'tgz' extension from the entry's name\n if (extension.equals(\"tgz\")) {\n name = name.substring(0, name.length()-3) + \"tar\";\n } else if (extension.equals(\"gz\")) {\n name = name.substring(0, name.length()-3);\n }\n }\n\n return new SingleArchiveEntryIterator(new ArchiveEntry(\"/\"+name, false, getLastModifiedDate(), -1, true));\n }\n\n\n @Override\n public InputStream getEntryInputStream(ArchiveEntry entry, ArchiveEntryIterator entryIterator) throws IOException {\n return new GZIPInputStream(getInputStream());\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/impl/gzip/GzipFormatProvider.java",
"content": "package com.mucommander.commons.file.impl.gzip;\n\nimport com.mucommander.commons.file.AbstractArchiveFile;\nimport com.mucommander.commons.file.AbstractFile;\nimport com.mucommander.commons.file.ArchiveFormatProvider;\nimport com.mucommander.commons.file.filter.ExtensionFilenameFilter;\nimport com.mucommander.commons.file.filter.FilenameFilter;\nimport com.mucommander.commons.file.impl.SevenZipJBindingROArchiveFile;\nimport net.sf.sevenzipjbinding.ArchiveFormat;\n\nimport java.io.IOException;\n\n/**\n * This class is the provider for the 'Gzip' archive format.\n *\n * @see com.mucommander.commons.file.impl.gzip.GzipArchiveFile\n * @author Nicolas Rinaudo, Maxence Bernard\n */\npublic class GzipFormatProvider implements ArchiveFormatProvider {\n private static final String[] EXTENSIONS = {\".gz\"};\n private final static byte[] SIGNATURE = {};\n\n /**\n * Static instance of the filename filter that matches archive filenames\n */\n private static final ExtensionFilenameFilter FILENAME_FILTER = new ExtensionFilenameFilter(EXTENSIONS);\n\n @Override\n public AbstractArchiveFile getFile(AbstractFile file) throws IOException {\n return new SevenZipJBindingROArchiveFile(file, ArchiveFormat.GZIP, SIGNATURE);\n }\n\n @Override\n public FilenameFilter getFilenameFilter() {\n return FILENAME_FILTER;\n }\n\n @Override\n public String[] getFileExtensions() {\n return EXTENSIONS;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/impl/gzip/package.html",
"content": " {@link ProtocolFile} is fully implemented by Even though it is working for the most part, it is flawed in several ways and should not be used.\n * See the {@link com.mucommander.commons.file.impl.s3} package for a better implementation of the Amazon S3 protocol.\n *\n * @deprecated\n * @author Maxence Bernard\n */\npublic class S3File extends HadoopFile {\n\n protected S3File(FileURL url) throws IOException {\n super(url);\n }\n\n protected S3File(FileURL url, FileSystem fs, FileStatus fileStatus) throws IOException {\n super(url, fs, fileStatus);\n }\n\n\n @Override\n protected FileSystem getHadoopFileSystem(FileURL url) throws IOException {\n if(!url.containsCredentials())\n throw new AuthException(url);\n\n // Note: getRealm returns a fresh instance every time\n FileURL realm = url.getRealm();\n\n // Import credentials\n Credentials creds = url.getCredentials();\n if(creds!=null) {\n // URL-encode secret as it may contain non URL-safe characters ('+' and '/')\n realm.setCredentials(new Credentials(creds.getLogin(), URLEncoder.encode(creds.getPassword(), StandardCharsets.UTF_8)));\n }\n\n // Change the scheme to the actual Hadoop fileystem (s3 -> s3n)\n realm.setScheme(\"s3n\");\n\n return FileSystem.get(URI.create(realm.toString(true, false)), DEFAULT_CONFIGURATION);\n }\n\n @Override\n protected void setDefaultFileAttributes(FileURL url, HadoopFileAttributes atts) {\n // Implemented as a no-op (S3 has no user info)\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/impl/hadoop/S3ProtocolProvider.java",
"content": "package com.mucommander.commons.file.impl.hadoop;\n\nimport com.mucommander.commons.file.AbstractFile;\nimport com.mucommander.commons.file.FileURL;\nimport com.mucommander.commons.file.ProtocolProvider;\nimport org.apache.hadoop.fs.FileStatus;\nimport org.apache.hadoop.fs.FileSystem;\n\nimport java.io.IOException;\n\n/**\n * A file protocol provider for the Amazon S3 protocol, provided by the Hadoop virtual filesystem.\n *\n * Even though it is working for the most part, it is flawed in several ways and should not be used.\n * See the {@link com.mucommander.commons.file.impl.s3} package for a better implementation of the Amazon S3 protocol.\n *\n * @deprecated \n * @author Maxence Bernard\n */\npublic class S3ProtocolProvider implements ProtocolProvider {\n\n public AbstractFile getFile(FileURL url, Object... instantiationParams) throws IOException {\n return instantiationParams.length==0\n ?new S3File(url)\n :new S3File(url, (FileSystem)instantiationParams[0], (FileStatus)instantiationParams[1]);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/impl/http/HTTPFile.java",
"content": "package com.mucommander.commons.file.impl.http;\n\nimport com.mucommander.commons.file.*;\nimport com.mucommander.commons.io.BlockRandomInputStream;\nimport com.mucommander.commons.io.RandomAccessInputStream;\nimport com.mucommander.commons.io.RandomAccessOutputStream;\nimport com.mucommander.commons.io.base64.Base64Encoder;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\nimport java.io.*;\nimport java.net.HttpURLConnection;\nimport java.net.URL;\nimport java.nio.charset.StandardCharsets;\nimport java.util.*;\nimport java.util.regex.Matcher;\nimport java.util.regex.Pattern;\n\n\n/**\n * HTTPFile provides access to files located on an HTTP/HTTPS server.\n *\n * The associated {@link FileURL} schemes are {@link FileProtocols#HTTP} and {@link FileProtocols#HTTPS}.\n * The host part of the URL designates the HTTP server. Credentials can be specified in the login and password parts\n * and will be used for HTTP Basic Authentication.\n *\n * Here are a few examples of valid HTTP URLs:\n * \n * A notable feature of HTTPFile is that it handles HTML/XHTML files as archives: when any of the {@link #ls()} methods\n * is called, the HTML file is parsed and any link found in the code is considered as a file:\n * In order to avoid the cost of having to perform a HEAD request for each file, some guessing based on the URL and\n * its filename is performed to determine if the file is an HTML/XHTML file or not.\n * In practice, this works quite well for most sites but the algorithm will be confused by some non-conventional\n * file naming, for instance if an HTML file ends with the '.gif' extension.\n * \n * A HEAD request is then issued only for non-HTML files, to determine their size and last modified date.\n * HTML files will thus have a size returned by {@link #getSize()} of Access to HTTP files is provided by the CharsetDetector class.\n *\n */\n public static String[] getAllDetectableCharsets() {\n String[] allCharsetNames = new String[ALL_CS_RECOGNIZERS.size()];\n for (int i = 0; i < allCharsetNames.length; i++) {\n allCharsetNames[i] = ALL_CS_RECOGNIZERS.get(i).recognizer.getName();\n }\n return allCharsetNames;\n } \n \n /**\n * Test whether input filtering is enabled.\n * \n * @return true if input text will be filtered.\n * \n * @see #enableInputFilter\n *\n */\n public boolean inputFilterEnabled() {\n return fStripTags;\n }\n \n /**\n * Enable filtering of input text. If filtering is enabled,\n * text within angle brackets (\"<\" and \">\") will be removed\n * before detection.\n * \n * @param filter true to enable input text filtering.\n * \n * @return The previous setting.\n *\n */\n public boolean enableInputFilter(boolean filter) {\n boolean previous = fStripTags;\n \n fStripTags = filter;\n \n return previous;\n }\n \n /*\n * MungeInput - after getting a set of raw input data to be analyzed, preprocess\n * it by removing what appears to be html markup.\n */\n private void MungeInput() {\n boolean inMarkup = false;\n int openTags = 0;\n int badTags = 0;\n \n //\n // html / xml markup stripping.\n // quick and dirty, not 100% accurate, but hopefully good enough, statistically.\n // discard everything within < brackets >\n // Count how many total '<' and illegal (nested) '<' occur, so we can make some\n // guess whether the input was actually marked up at all.\n int srci;\n\n if (fStripTags) {\n int dsti = 0;\n\n for (srci = 0; srci < fRawLength && dsti < fInputBytes.length; srci++) {\n byte b = fRawInput[srci];\n if (b == (byte)'<') {\n if (inMarkup) {\n badTags++;\n }\n inMarkup = true;\n openTags++;\n }\n \n if (!inMarkup) {\n fInputBytes[dsti++] = b;\n }\n \n if (b == (byte)'>') {\n inMarkup = false;\n } \n }\n \n fInputLen = dsti;\n }\n // If it looks like this input wasn't marked up, or if it looks like it's\n // essentially nothing but markup abandon the markup stripping.\n // Detection will have to work on the unstripped input.\n if (openTags < 5 || openTags/5 < badTags || (fInputLen < 100 && fRawLength>600)) {\n int limit = fRawLength;\n \n if (limit > kBufSize) {\n limit = kBufSize;\n }\n \n for (srci=0; srcitrue to enable, or false to disable the\n * charset encoding.\n * @return A reference to this CharsetDetector.\n * @throws IllegalArgumentException when the name of charset encoding is\n * not supported.\n * internal\n * @deprecated This API is ICU internal only.\n */\n public CharsetDetector setDetectableCharset(String encoding, boolean enabled) {\n int modIdx = -1;\n boolean isDefaultVal = false;\n for (int i = 0; i < ALL_CS_RECOGNIZERS.size(); i++) {\n CSRecognizerInfo csrinfo = ALL_CS_RECOGNIZERS.get(i);\n if (csrinfo.recognizer.getName().equals(encoding)) {\n modIdx = i;\n isDefaultVal = (csrinfo.isDefaultEnabled == enabled);\n break;\n }\n }\n if (modIdx < 0) {\n // No matching encoding found\n throw new IllegalArgumentException(\"Invalid encoding: \" + \"\\\"\" + encoding + \"\\\"\");\n }\n if (fEnabledRecognizers == null && !isDefaultVal) {\n // create an array storing the non default setting\n fEnabledRecognizers = new boolean[ALL_CS_RECOGNIZERS.size()];\n\n // Initialize the array with default info\n for (int i = 0; i < ALL_CS_RECOGNIZERS.size(); i++) {\n fEnabledRecognizers[i] = ALL_CS_RECOGNIZERS.get(i).isDefaultEnabled;\n }\n }\n if (fEnabledRecognizers != null) {\n fEnabledRecognizers[modIdx] = enabled;\n }\n return this;\n }\n}\n"
},
{
"path": "src/main/java/com/ibm/icu/text/CharsetMatch.java",
"content": "/*\n*******************************************************************************\n* Copyright (C) 2005-2012, International Business Machines Corporation and *\n* others. All Rights Reserved. *\n*******************************************************************************\n*/\npackage com.ibm.icu.text;\n\nimport org.jetbrains.annotations.NotNull;\n\nimport java.io.ByteArrayInputStream;\nimport java.io.IOException;\nimport java.io.InputStream;\nimport java.io.InputStreamReader;\nimport java.io.Reader;\n\n\n/**\n * This class represents a charset that has been identified by a CharsetDetector\n * as a possible encoding for a set of input data. From an instance of this\n * class, you can ask for a confidence level in the charset identification,\n * or for Java Reader or String to access the original byte data in Unicode form.\n * null if the language cannot be determined.\n *\n */\n public String getLanguage() {\n return fLang;\n }\n\n /**\n * Compare to other CharsetMatch objects.\n * Comparison is based on the match confidence value, which \n * allows CharsetDetector.detectAll() to order its results. \n *\n * @param other the CharsetMatch object to compare against.\n * @return a negative integer, zero, or a positive integer as the \n * confidence level of this CharsetMatch\n * is less than, equal to, or greater than that of\n * the argument.\n * @throws ClassCastException if the argument is not a CharsetMatch.\n */\n public int compareTo (@NotNull CharsetMatch other) {\n if (this.fConfidence > other.fConfidence) {\n return 1;\n } else if (this.fConfidence < other.fConfidence) {\n return -1;\n }\n return 0;\n }\n\n /*\n * Constructor. Implementation internal\n */\n CharsetMatch(CharsetDetector det, CharsetRecognizer rec, int conf) {\n fConfidence = conf;\n \n // The references to the original application input data must be copied out\n // of the charset recognizer to here, in case the application resets the\n // recognizer before using this CharsetMatch.\n if (det.fInputStream == null) {\n // We only want the existing input byte data if it came straight from the user,\n // not if is just the head of a stream.\n fRawInput = det.fRawInput;\n fRawLength = det.fRawLength;\n }\n fInputStream = det.fInputStream;\n fCharsetName = rec.getName();\n fLang = rec.getLanguage();\n }\n\n /*\n * Constructor. Implementation internal\n */\n CharsetMatch(CharsetDetector det, int conf, String csName, String lang) {\n fConfidence = conf;\n // The references to the original application input data must be copied out of the charset recognizer to here,\n // in case the application resets the recognizer before using this CharsetMatch.\n if (det.fInputStream == null) {\n // We only want the existing input byte data if it came straight from the user,\n // not if is just the head of a stream.\n fRawInput = det.fRawInput;\n fRawLength = det.fRawLength;\n }\n fInputStream = det.fInputStream;\n fCharsetName = csName;\n fLang = lang;\n }\n\n private final int fConfidence;\n private byte[] fRawInput; // Original, untouched input bytes. If user gave us a byte array, this is it.\n private int fRawLength; // Length of data in fRawInput array.\n private final InputStream fInputStream; // User's input stream, or null if the user gave us a byte array.\n private final String fCharsetName; // The name of the charset this CharsetMatch represents. Filled in by the recognizer.\n private final String fLang; // The language, if one was determined by the recognizer during the detect operation.\n}\n"
},
{
"path": "src/main/java/com/ibm/icu/text/CharsetRecog_2022.java",
"content": "/*\n *******************************************************************************\n * Copyright (C) 2005 - 2012, International Business Machines Corporation and *\n * others. All Rights Reserved. *\n *******************************************************************************\n */\npackage com.ibm.icu.text;\n\n/**\n * class CharsetRecog_2022 part of the ICU charset detection implementation.\n * This is a superclass for the individual detectors for each of the detectable members of the ISO 2022 family of encodings.\n * The separate classes are nested within this class.\n */\nabstract class CharsetRecog_2022 extends CharsetRecognizer {\n\n /**\n * Matching function shared among the 2022 detectors JP, CN and KR Counts up the number of legal an\n * unrecognized escape sequences in the sample of text, and computes a score based on the total number &\n * the proportion that fit the encoding.\n *\n * @param text the byte buffer containing text to analyse\n * @param textLen the size of the text in the byte.\n * @param escapeSequences the byte escape sequences to test for.\n * @return match quality, in the range of 0-100.\n */\n int match(byte[] text, int textLen, byte[][] escapeSequences) {\n int hits = 0;\n int misses = 0;\n int shifts = 0;\n int quality;\n scanInput:\n for (int i = 0; i < textLen; i++) {\n if (text[i] == 0x1b) {\n checkEscapes:\n for (byte[] seq : escapeSequences) {\n if ((textLen - i) < seq.length) {\n continue checkEscapes;\n }\n for (int j = 1; j < seq.length; j++) {\n if (seq[j] != text[i + j]) {\n continue checkEscapes;\n }\n }\n hits++;\n i += seq.length - 1;\n continue scanInput;\n }\n misses++;\n }\n\n if (text[i] == 0x0e || text[i] == 0x0f) {\n // Shift in/out\n shifts++;\n }\n }\n if (hits == 0) {\n return 0;\n }\n // Initial quality is based on relative proportion of recognized vs.\n // unrecognized escape sequences. \n // All good: quality = 100;\n // half or less good: quality = 0;\n // linear inbetween.\n quality = (100 * hits - 100 * misses) / (hits + misses);\n\n // Back off quality if there were too few escape sequences seen.\n // Include shifts in this computation, so that KR does not get penalized\n // for having only a single Escape sequence, but many shifts.\n if (hits + shifts < 5) {\n quality -= (5 - (hits + shifts)) * 10;\n }\n if (quality < 0) {\n quality = 0;\n }\n return quality;\n }\n\n\n static class CharsetRecog_2022JP extends CharsetRecog_2022 {\n private final byte[][] escapeSequences = {\n {0x1b, 0x24, 0x28, 0x43}, // KS X 1001:1992\n {0x1b, 0x24, 0x28, 0x44}, // JIS X 212-1990\n {0x1b, 0x24, 0x40}, // JIS C 6226-1978\n {0x1b, 0x24, 0x41}, // GB 2312-80\n {0x1b, 0x24, 0x42}, // JIS X 208-1983\n {0x1b, 0x26, 0x40}, // JIS X 208 1990, 1997\n {0x1b, 0x28, 0x42}, // ASCII\n {0x1b, 0x28, 0x48}, // JIS-Roman\n {0x1b, 0x28, 0x49}, // Half-width katakana\n {0x1b, 0x28, 0x4a}, // JIS-Roman\n {0x1b, 0x2e, 0x41}, // ISO 8859-1\n {0x1b, 0x2e, 0x46} // ISO 8859-7\n };\n\n String getName() {\n return \"ISO-2022-JP\";\n }\n\n CharsetMatch match(CharsetDetector det) {\n int confidence = match(det.fInputBytes, det.fInputLen, escapeSequences);\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n }\n\n static class CharsetRecog_2022KR extends CharsetRecog_2022 {\n private final byte[][] escapeSequences = {\n {0x1b, 0x24, 0x29, 0x43}\n };\n\n String getName() {\n return \"ISO-2022-KR\";\n }\n\n CharsetMatch match(CharsetDetector det) {\n int confidence = match(det.fInputBytes, det.fInputLen, escapeSequences);\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n }\n\n static class CharsetRecog_2022CN extends CharsetRecog_2022 {\n private final byte[][] escapeSequences = {\n {0x1b, 0x24, 0x29, 0x41}, // GB 2312-80\n {0x1b, 0x24, 0x29, 0x47}, // CNS 11643-1992 Plane 1\n {0x1b, 0x24, 0x2A, 0x48}, // CNS 11643-1992 Plane 2\n {0x1b, 0x24, 0x29, 0x45}, // ISO-IR-165\n {0x1b, 0x24, 0x2B, 0x49}, // CNS 11643-1992 Plane 3\n {0x1b, 0x24, 0x2B, 0x4A}, // CNS 11643-1992 Plane 4\n {0x1b, 0x24, 0x2B, 0x4B}, // CNS 11643-1992 Plane 5\n {0x1b, 0x24, 0x2B, 0x4C}, // CNS 11643-1992 Plane 6\n {0x1b, 0x24, 0x2B, 0x4D}, // CNS 11643-1992 Plane 7\n {0x1b, 0x4e}, // SS2\n {0x1b, 0x4f}, // SS3\n };\n\n String getName() {\n return \"ISO-2022-CN\";\n }\n\n CharsetMatch match(CharsetDetector det) {\n int confidence = match(det.fInputBytes, det.fInputLen, escapeSequences);\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n }\n\n}\n\n"
},
{
"path": "src/main/java/com/ibm/icu/text/CharsetRecog_UTF8.java",
"content": "/*\n *******************************************************************************\n * Copyright (C) 2005 - 2012, International Business Machines Corporation and *\n * others. All Rights Reserved. *\n *******************************************************************************\n */\npackage com.ibm.icu.text;\n\n/**\n * Charset recognizer for UTF-8\n */\nclass CharsetRecog_UTF8 extends CharsetRecognizer {\n\n String getName() {\n return \"UTF-8\";\n }\n\n /* (non-Javadoc)\n * @see com.ibm.icu.text.CharsetRecognizer#match(com.ibm.icu.text.CharsetDetector)\n */\n CharsetMatch match(CharsetDetector det) {\n boolean hasBOM = false;\n int numValid = 0;\n int numInvalid = 0;\n byte[] input = det.fRawInput;\n int trailBytes;\n\n if (det.fRawLength >= 3 &&\n (input[0] & 0xFF) == 0xef && (input[1] & 0xFF) == 0xbb && (input[2] & 0xFF) == 0xbf) {\n hasBOM = true;\n }\n\n // Scan for multibyte sequences\n for (int i = 0; i < det.fRawLength; i++) {\n int b = input[i];\n if ((b & 0x80) == 0) {\n continue; // ASCII\n }\n\n // High bit on char found. Figure out how long the sequence should be\n if ((b & 0x0e0) == 0x0c0) {\n trailBytes = 1;\n } else if ((b & 0x0f0) == 0x0e0) {\n trailBytes = 2;\n } else if ((b & 0x0f8) == 0xf0) {\n trailBytes = 3;\n } else {\n numInvalid++;\n if (numInvalid > 5) {\n break;\n }\n trailBytes = 0;\n }\n\n // Verify that we've got the right number of trail bytes in the sequence\n for (; ; ) {\n i++;\n if (i >= det.fRawLength) {\n break;\n }\n b = input[i];\n if ((b & 0xc0) != 0x080) {\n numInvalid++;\n break;\n }\n if (--trailBytes == 0) {\n numValid++;\n break;\n }\n }\n }\n // Cook up some sort of confidence score, based on presense of a BOM and the existence of valid\n // and/or invalid multibyte sequences.\n int confidence = 0;\n if (hasBOM && numInvalid == 0) {\n confidence = 100;\n } else if (hasBOM && numValid > numInvalid * 10) {\n confidence = 80;\n } else if (numValid > 3 && numInvalid == 0) {\n confidence = 100;\n } else if (numValid > 0 && numInvalid == 0) {\n confidence = 80;\n } else if (numValid == 0 && numInvalid == 0) {\n // Plain ASCII. \n confidence = 10;\n } else if (numValid > numInvalid * 10) {\n // Probably corrupt utf-8 data. Valid sequences aren't likely by chance.\n confidence = 25;\n }\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n\n}\n"
},
{
"path": "src/main/java/com/ibm/icu/text/CharsetRecog_Unicode.java",
"content": "/*\n *******************************************************************************\n * Copyright (C) 1996-2012, International Business Machines Corporation and *\n * others. All Rights Reserved. *\n *******************************************************************************\n *\n */\n\npackage com.ibm.icu.text;\n\n/**\n * This class matches UTF-16 and UTF-32, both big- and little-endian. The BOM will be used if it is present.\n */\nabstract class CharsetRecog_Unicode extends CharsetRecognizer {\n\n @Override\n abstract String getName();\n\n @Override\n abstract CharsetMatch match(CharsetDetector det);\n\n static class CharsetRecog_UTF_16_BE extends CharsetRecog_Unicode {\n String getName() {\n return \"UTF-16BE\";\n }\n\n CharsetMatch match(CharsetDetector det) {\n byte[] input = det.fRawInput;\n\n if (input.length >= 2 && ((input[0] & 0xFF) == 0xFE && (input[1] & 0xFF) == 0xFF)) {\n int confidence = 100;\n return new CharsetMatch(det, this, confidence);\n }\n\n // TODO: Do some statistics to check for unsigned UTF-16BE\n return null;\n }\n }\n\n static class CharsetRecog_UTF_16_LE extends CharsetRecog_Unicode {\n String getName() {\n return \"UTF-16LE\";\n }\n\n CharsetMatch match(CharsetDetector det) {\n byte[] input = det.fRawInput;\n\n if (input.length >= 2 && ((input[0] & 0xFF) == 0xFF && (input[1] & 0xFF) == 0xFE)) {\n // An LE BOM is present.\n if (input.length >= 4 && input[2] == 0x00 && input[3] == 0x00) {\n // It is probably UTF-32 LE, not UTF-16\n return null;\n }\n int confidence = 100;\n return new CharsetMatch(det, this, confidence);\n }\n // TODO: Do some statistics to check for unsigned UTF-16LE\n return null;\n }\n }\n\n static abstract class CharsetRecog_UTF_32 extends CharsetRecog_Unicode {\n abstract int getChar(byte[] input, int index);\n\n abstract String getName();\n\n CharsetMatch match(CharsetDetector det) {\n byte[] input = det.fRawInput;\n int limit = (det.fRawLength / 4) * 4;\n int numValid = 0;\n int numInvalid = 0;\n boolean hasBOM = false;\n int confidence = 0;\n\n if (limit == 0) {\n return null;\n }\n if (getChar(input, 0) == 0x0000FEFF) {\n hasBOM = true;\n }\n\n for (int i = 0; i < limit; i += 4) {\n int ch = getChar(input, i);\n\n if (ch < 0 || ch >= 0x10FFFF || (ch >= 0xD800 && ch <= 0xDFFF)) {\n numInvalid += 1;\n } else {\n numValid += 1;\n }\n }\n\n // Cook up some sort of confidence score, based on presence of a BOM\n // and the existence of valid and/or invalid multibyte sequences.\n if (hasBOM && numInvalid == 0) {\n confidence = 100;\n } else if (hasBOM && numValid > numInvalid * 10) {\n confidence = 80;\n } else if (numValid > 3 && numInvalid == 0) {\n confidence = 100;\n } else if (numValid > 0 && numInvalid == 0) {\n confidence = 80;\n } else if (numValid > numInvalid * 10) {\n // Probably corrupt UTF-32BE data. Valid sequences aren't likely by chance.\n confidence = 25;\n }\n\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n }\n\n static class CharsetRecog_UTF_32_BE extends CharsetRecog_UTF_32 {\n int getChar(byte[] input, int index) {\n return (input[index + 0] & 0xFF) << 24 | (input[index + 1] & 0xFF) << 16 |\n (input[index + 2] & 0xFF) << 8 | (input[index + 3] & 0xFF);\n }\n\n String getName() {\n return \"UTF-32BE\";\n }\n }\n\n\n static class CharsetRecog_UTF_32_LE extends CharsetRecog_UTF_32 {\n int getChar(byte[] input, int index) {\n return (input[index + 3] & 0xFF) << 24 | (input[index + 2] & 0xFF) << 16 |\n (input[index + 1] & 0xFF) << 8 | (input[index + 0] & 0xFF);\n }\n\n String getName() {\n return \"UTF-32LE\";\n }\n }\n}\n"
},
{
"path": "src/main/java/com/ibm/icu/text/CharsetRecog_mbcs.java",
"content": "/*\n ****************************************************************************\n * Copyright (C) 2005-2012, International Business Machines Corporation and *\n * others. All Rights Reserved. *\n ****************************************************************************\n *\n */\npackage com.ibm.icu.text;\n\nimport java.util.Arrays;\n\n/**\n * CharsetRecognizer implemenation for Asian - double or multi-byte - charsets.\n * Match is determined mostly by the input data adhering to the\n * encoding scheme for the charset, and, optionally,\n * frequency-of-occurence of characters.\n *
\n * bits 0-7: the match confidence, ranging from 0-100\n *
\n * bits 8-15: The match reason, an enum-like value.\n */\n int match(CharsetDetector det, int [] commonChars) {\n @SuppressWarnings(\"unused\")\n int singleByteCharCount = 0; //TODO Do we really need this?\n int doubleByteCharCount = 0;\n int commonCharCount = 0;\n int badCharCount = 0;\n int totalCharCount = 0;\n int confidence = 0;\n iteratedChar iter = new iteratedChar();\n \n detectBlock: {\n for (iter.reset(); nextChar(iter, det);) {\n totalCharCount++;\n if (iter.error) {\n badCharCount++; \n } else {\n long cv = iter.charValue & 0xFFFFFFFFL;\n \n if (cv <= 0xff) {\n singleByteCharCount++;\n } else {\n doubleByteCharCount++;\n if (commonChars != null) {\n // NOTE: This assumes that there are no 4-byte common chars.\n if (Arrays.binarySearch(commonChars, (int) cv) >= 0) {\n commonCharCount++;\n }\n }\n }\n }\n if (badCharCount >= 2 && badCharCount*5 >= doubleByteCharCount) {\n // Bail out early if the byte data is not matching the encoding scheme.\n break detectBlock;\n }\n }\n \n if (doubleByteCharCount <= 10 && badCharCount== 0) {\n // Not many multi-byte chars.\n if (doubleByteCharCount == 0 && totalCharCount < 10) {\n // There weren't any multibyte sequences, and there was a low density of non-ASCII single bytes.\n // We don't have enough data to have any confidence.\n // Statistical analysis of single byte non-ASCII charcters would probably help here.\n confidence = 0;\n }\n else {\n // ASCII or ISO file? It's probably not our encoding,\n // but is not incompatible with our encoding, so don't give it a zero.\n confidence = 10;\n }\n \n break detectBlock;\n }\n \n //\n // No match if there are too many characters that don't fit the encoding scheme.\n // (should we have zero tolerance for these?)\n //\n if (doubleByteCharCount < 20*badCharCount) {\n confidence = 0;\n break detectBlock;\n }\n \n if (commonChars == null) {\n // We have no statistics on frequently occuring characters.\n // Assess confidence purely on having a reasonable number of\n // multi-byte characters (the more the better\n confidence = 30 + doubleByteCharCount - 20*badCharCount;\n if (confidence > 100) {\n confidence = 100;\n }\n }else {\n //\n // Frequency of occurence statistics exist.\n //\n double maxVal = Math.log((float)doubleByteCharCount / 4);\n double scaleFactor = 90.0 / maxVal;\n confidence = (int)(Math.log(commonCharCount+1) * scaleFactor + 10);\n confidence = Math.min(confidence, 100);\n }\n } // end of detectBlock:\n \n return confidence;\n }\n \n // \"Character\" iterated character class.\n // Recognizers for specific mbcs encodings make their \"characters\" available\n // by providing a nextChar() function that fills in an instance of iteratedChar\n // with the next char from the input.\n // The returned characters are not converted to Unicode, but remain as the raw\n // bytes (concatenated into an int) from the codepage data.\n //\n // For Asian charsets, use the raw input rather than the input that has been\n // stripped of markup. Detection only considers multi-byte chars, effectively\n // stripping markup anyway, and double byte chars do occur in markup too.\n //\n static class iteratedChar {\n int charValue = 0; // 1-4 bytes from the raw input data\n int index = 0;\n int nextIndex = 0;\n boolean error = false;\n boolean done = false;\n \n void reset() {\n charValue = 0;\n index = -1;\n nextIndex = 0;\n error = false;\n done = false;\n }\n \n int nextByte(CharsetDetector det) {\n if (nextIndex >= det.fRawLength) {\n done = true;\n return -1;\n }\n return (int)det.fRawInput[nextIndex++] & 0x00ff;\n } \n }\n \n /**\n * Get the next character (however many bytes it is) from the input data\n * Subclasses for specific charset encodings must implement this function\n * to get characters according to the rules of their encoding scheme.\n * This function is not a method of class iteratedChar only because\n * that would require a lot of extra derived classes, which is awkward.\n * @param it The iteratedChar \"struct\" into which the returned char is placed.\n * @param det The charset detector, which is needed to get at the input byte data\n * being iterated over.\n * @return True if a character was returned, false at end of input.\n */\n abstract boolean nextChar(iteratedChar it, CharsetDetector det);\n \n\n\n \n \n /**\n * Shift-JIS charset recognizer. \n *\n */\n static class CharsetRecog_sjis extends CharsetRecog_mbcs {\n static int [] commonChars = \n // TODO: This set of data comes from the character frequency-\n // of-occurence analysis tool. The data needs to be moved\n // into a resource and loaded from there.\n {0x8140, 0x8141, 0x8142, 0x8145, 0x815b, 0x8169, 0x816a, 0x8175, 0x8176, 0x82a0, \n 0x82a2, 0x82a4, 0x82a9, 0x82aa, 0x82ab, 0x82ad, 0x82af, 0x82b1, 0x82b3, 0x82b5, \n 0x82b7, 0x82bd, 0x82be, 0x82c1, 0x82c4, 0x82c5, 0x82c6, 0x82c8, 0x82c9, 0x82cc, \n 0x82cd, 0x82dc, 0x82e0, 0x82e7, 0x82e8, 0x82e9, 0x82ea, 0x82f0, 0x82f1, 0x8341, \n 0x8343, 0x834e, 0x834f, 0x8358, 0x835e, 0x8362, 0x8367, 0x8375, 0x8376, 0x8389, \n 0x838a, 0x838b, 0x838d, 0x8393, 0x8e96, 0x93fa, 0x95aa};\n \n boolean nextChar(iteratedChar it, CharsetDetector det) {\n it.index = it.nextIndex;\n it.error = false;\n int firstByte;\n firstByte = it.charValue = it.nextByte(det);\n if (firstByte < 0) {\n return false;\n }\n \n if (firstByte <= 0x7f || (firstByte>0xa0 && firstByte<=0xdf)) {\n return true;\n }\n \n int secondByte = it.nextByte(det);\n if (secondByte < 0) {\n return false; \n }\n it.charValue = (firstByte << 8) | secondByte;\n if (! ((secondByte>=0x40 && secondByte<=0x7f) || (secondByte>=0x80 && secondByte<=0xff))) {\n // Illegal second byte value.\n it.error = true;\n }\n return true;\n }\n \n CharsetMatch match(CharsetDetector det) {\n int confidence = match(det, commonChars);\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n \n String getName() {\n return \"Shift_JIS\";\n }\n \n public String getLanguage()\n {\n return \"ja\";\n }\n\n \n }\n \n \n /**\n * Big5 charset recognizer. \n *\n */\n static class CharsetRecog_big5 extends CharsetRecog_mbcs {\n static int [] commonChars = \n // TODO: This set of data comes from the character frequency-\n // of-occurence analysis tool. The data needs to be moved\n // into a resource and loaded from there.\n {0xa140, 0xa141, 0xa142, 0xa143, 0xa147, 0xa149, 0xa175, 0xa176, 0xa440, 0xa446, \n 0xa447, 0xa448, 0xa451, 0xa454, 0xa457, 0xa464, 0xa46a, 0xa46c, 0xa477, 0xa4a3, \n 0xa4a4, 0xa4a7, 0xa4c1, 0xa4ce, 0xa4d1, 0xa4df, 0xa4e8, 0xa4fd, 0xa540, 0xa548, \n 0xa558, 0xa569, 0xa5cd, 0xa5e7, 0xa657, 0xa661, 0xa662, 0xa668, 0xa670, 0xa6a8, \n 0xa6b3, 0xa6b9, 0xa6d3, 0xa6db, 0xa6e6, 0xa6f2, 0xa740, 0xa751, 0xa759, 0xa7da, \n 0xa8a3, 0xa8a5, 0xa8ad, 0xa8d1, 0xa8d3, 0xa8e4, 0xa8fc, 0xa9c0, 0xa9d2, 0xa9f3, \n 0xaa6b, 0xaaba, 0xaabe, 0xaacc, 0xaafc, 0xac47, 0xac4f, 0xacb0, 0xacd2, 0xad59, \n 0xaec9, 0xafe0, 0xb0ea, 0xb16f, 0xb2b3, 0xb2c4, 0xb36f, 0xb44c, 0xb44e, 0xb54c, \n 0xb5a5, 0xb5bd, 0xb5d0, 0xb5d8, 0xb671, 0xb7ed, 0xb867, 0xb944, 0xbad8, 0xbb44, \n 0xbba1, 0xbdd1, 0xc2c4, 0xc3b9, 0xc440, 0xc45f};\n \n boolean nextChar(iteratedChar it, CharsetDetector det) {\n it.index = it.nextIndex;\n it.error = false;\n int firstByte;\n firstByte = it.charValue = it.nextByte(det);\n if (firstByte < 0) {\n return false;\n }\n \n if (firstByte <= 0x7f || firstByte==0xff) {\n // single byte character.\n return true;\n }\n \n int secondByte = it.nextByte(det);\n if (secondByte < 0) {\n return false; \n }\n it.charValue = (it.charValue << 8) | secondByte;\n\n if (secondByte < 0x40 ||\n secondByte ==0x7f ||\n secondByte == 0xff) {\n it.error = true;\n }\n return true;\n }\n \n CharsetMatch match(CharsetDetector det) {\n int confidence = match(det, commonChars);\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n \n String getName() {\n return \"Big5\";\n }\n \n \n public String getLanguage()\n {\n return \"zh\";\n }\n }\n \n \n /**\n * EUC charset recognizers. One abstract class that provides the common function\n * for getting the next character according to the EUC encoding scheme,\n * and nested derived classes for EUC_KR, EUC_JP, EUC_CN. \n *\n */\n abstract static class CharsetRecog_euc extends CharsetRecog_mbcs {\n \n /*\n * (non-Javadoc)\n * Get the next character value for EUC based encodings.\n * Character \"value\" is simply the raw bytes that make up the character\n * packed into an int.\n */\n boolean nextChar(iteratedChar it, CharsetDetector det) {\n it.index = it.nextIndex;\n it.error = false;\n int firstByte;\n int secondByte;\n int thirdByte;\n\n buildChar: {\n firstByte = it.charValue = it.nextByte(det); \n if (firstByte < 0) {\n // Ran off the end of the input data\n it.done = true;\n break buildChar;\n }\n if (firstByte <= 0x8d) {\n // single byte char\n break buildChar;\n }\n \n secondByte = it.nextByte(det);\n it.charValue = (it.charValue << 8) | secondByte;\n \n if (firstByte >= 0xA1 && firstByte <= 0xfe) {\n // Two byte Char\n if (secondByte < 0xa1) {\n it.error = true;\n }\n break buildChar;\n }\n if (firstByte == 0x8e) {\n // Code Set 2.\n // In EUC-JP, total char size is 2 bytes, only one byte of actual char value.\n // In EUC-TW, total char size is 4 bytes, three bytes contribute to char value.\n // We don't know which we've got.\n // Treat it like EUC-JP. If the data really was EUC-TW, the following two\n // bytes will look like a well formed 2 byte char. \n if (secondByte < 0xa1) {\n it.error = true;\n }\n break buildChar; \n }\n \n if (firstByte == 0x8f) {\n // Code set 3.\n // Three byte total char size, two bytes of actual char value.\n thirdByte = it.nextByte(det);\n it.charValue = (it.charValue << 8) | thirdByte;\n if (thirdByte < 0xa1) {\n it.error = true;\n }\n }\n }\n \n return !it.done;\n }\n \n /**\n * The charset recognize for EUC-JP. A singleton instance of this class\n * is created and kept by the public CharsetDetector class\n */\n static class CharsetRecog_euc_jp extends CharsetRecog_euc {\n static int [] commonChars = \n // TODO: This set of data comes from the character frequency-\n // of-occurrence analysis tool. The data needs to be moved\n // into a resource and loaded from there.\n {0xa1a1, 0xa1a2, 0xa1a3, 0xa1a6, 0xa1bc, 0xa1ca, 0xa1cb, 0xa1d6, 0xa1d7, 0xa4a2, \n 0xa4a4, 0xa4a6, 0xa4a8, 0xa4aa, 0xa4ab, 0xa4ac, 0xa4ad, 0xa4af, 0xa4b1, 0xa4b3, \n 0xa4b5, 0xa4b7, 0xa4b9, 0xa4bb, 0xa4bd, 0xa4bf, 0xa4c0, 0xa4c1, 0xa4c3, 0xa4c4, \n 0xa4c6, 0xa4c7, 0xa4c8, 0xa4c9, 0xa4ca, 0xa4cb, 0xa4ce, 0xa4cf, 0xa4d0, 0xa4de, \n 0xa4df, 0xa4e1, 0xa4e2, 0xa4e4, 0xa4e8, 0xa4e9, 0xa4ea, 0xa4eb, 0xa4ec, 0xa4ef, \n 0xa4f2, 0xa4f3, 0xa5a2, 0xa5a3, 0xa5a4, 0xa5a6, 0xa5a7, 0xa5aa, 0xa5ad, 0xa5af, \n 0xa5b0, 0xa5b3, 0xa5b5, 0xa5b7, 0xa5b8, 0xa5b9, 0xa5bf, 0xa5c3, 0xa5c6, 0xa5c7, \n 0xa5c8, 0xa5c9, 0xa5cb, 0xa5d0, 0xa5d5, 0xa5d6, 0xa5d7, 0xa5de, 0xa5e0, 0xa5e1, \n 0xa5e5, 0xa5e9, 0xa5ea, 0xa5eb, 0xa5ec, 0xa5ed, 0xa5f3, 0xb8a9, 0xb9d4, 0xbaee, \n 0xbbc8, 0xbef0, 0xbfb7, 0xc4ea, 0xc6fc, 0xc7bd, 0xcab8, 0xcaf3, 0xcbdc, 0xcdd1}; \n String getName() {\n return \"EUC-JP\";\n }\n \n CharsetMatch match(CharsetDetector det) {\n int confidence = match(det, commonChars);\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n \n public String getLanguage()\n {\n return \"ja\";\n }\n }\n \n /**\n * The charset recognize for EUC-KR. A singleton instance of this class\n * is created and kept by the public CharsetDetector class\n */\n static class CharsetRecog_euc_kr extends CharsetRecog_euc {\n static int [] commonChars = \n // TODO: This set of data comes from the character frequency-\n // of-occurrence analysis tool. The data needs to be moved\n // into a resource and loaded from there.\n {0xb0a1, 0xb0b3, 0xb0c5, 0xb0cd, 0xb0d4, 0xb0e6, 0xb0ed, 0xb0f8, 0xb0fa, 0xb0fc, \n 0xb1b8, 0xb1b9, 0xb1c7, 0xb1d7, 0xb1e2, 0xb3aa, 0xb3bb, 0xb4c2, 0xb4cf, 0xb4d9, \n 0xb4eb, 0xb5a5, 0xb5b5, 0xb5bf, 0xb5c7, 0xb5e9, 0xb6f3, 0xb7af, 0xb7c2, 0xb7ce, \n 0xb8a6, 0xb8ae, 0xb8b6, 0xb8b8, 0xb8bb, 0xb8e9, 0xb9ab, 0xb9ae, 0xb9cc, 0xb9ce, \n 0xb9fd, 0xbab8, 0xbace, 0xbad0, 0xbaf1, 0xbbe7, 0xbbf3, 0xbbfd, 0xbcad, 0xbcba, \n 0xbcd2, 0xbcf6, 0xbdba, 0xbdc0, 0xbdc3, 0xbdc5, 0xbec6, 0xbec8, 0xbedf, 0xbeee, \n 0xbef8, 0xbefa, 0xbfa1, 0xbfa9, 0xbfc0, 0xbfe4, 0xbfeb, 0xbfec, 0xbff8, 0xc0a7, \n 0xc0af, 0xc0b8, 0xc0ba, 0xc0bb, 0xc0bd, 0xc0c7, 0xc0cc, 0xc0ce, 0xc0cf, 0xc0d6, \n 0xc0da, 0xc0e5, 0xc0fb, 0xc0fc, 0xc1a4, 0xc1a6, 0xc1b6, 0xc1d6, 0xc1df, 0xc1f6, \n 0xc1f8, 0xc4a1, 0xc5cd, 0xc6ae, 0xc7cf, 0xc7d1, 0xc7d2, 0xc7d8, 0xc7e5, 0xc8ad};\n \n String getName() {\n return \"EUC-KR\";\n }\n \n CharsetMatch match(CharsetDetector det) {\n int confidence = match(det, commonChars);\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n \n public String getLanguage()\n {\n return \"ko\";\n }\n }\n }\n \n /**\n * \n * GB-18030 recognizer. Uses simplified Chinese statistics. \n *\n */\n static class CharsetRecog_gb_18030 extends CharsetRecog_mbcs {\n \n /*\n * (non-Javadoc)\n * Get the next character value for EUC based encodings.\n * Character \"value\" is simply the raw bytes that make up the character\n * packed into an int.\n */\n boolean nextChar(iteratedChar it, CharsetDetector det) {\n it.index = it.nextIndex;\n it.error = false;\n int firstByte;\n int secondByte;\n int thirdByte;\n int fourthByte;\n \n buildChar: {\n firstByte = it.charValue = it.nextByte(det); \n \n if (firstByte < 0) {\n // Ran off the end of the input data\n it.done = true;\n break buildChar;\n }\n \n if (firstByte <= 0x80) {\n // single byte char\n break buildChar;\n }\n \n secondByte = it.nextByte(det);\n it.charValue = (it.charValue << 8) | secondByte;\n \n if (firstByte >= 0x81 && firstByte <= 0xFE) {\n // Two byte Char\n if ((secondByte >= 0x40 && secondByte <= 0x7E) || (secondByte >=80 && secondByte <=0xFE)) {\n break buildChar;\n }\n \n // Four byte char\n if (secondByte >= 0x30 && secondByte <= 0x39) {\n thirdByte = it.nextByte(det);\n \n if (thirdByte >= 0x81 && thirdByte <= 0xFE) {\n fourthByte = it.nextByte(det);\n \n if (fourthByte >= 0x30 && fourthByte <= 0x39) {\n it.charValue = (it.charValue << 16) | (thirdByte << 8) | fourthByte;\n break buildChar;\n }\n }\n }\n \n it.error = true;\n break buildChar;\n }\n }\n \n return !it.done;\n }\n \n static int [] commonChars = \n // TODO: This set of data comes from the character frequency-\n // of-occurrence analysis tool. The data needs to be moved\n // into a resource and loaded from there.\n {0xa1a1, 0xa1a2, 0xa1a3, 0xa1a4, 0xa1b0, 0xa1b1, 0xa1f1, 0xa1f3, 0xa3a1, 0xa3ac, \n 0xa3ba, 0xb1a8, 0xb1b8, 0xb1be, 0xb2bb, 0xb3c9, 0xb3f6, 0xb4f3, 0xb5bd, 0xb5c4, \n 0xb5e3, 0xb6af, 0xb6d4, 0xb6e0, 0xb7a2, 0xb7a8, 0xb7bd, 0xb7d6, 0xb7dd, 0xb8b4, \n 0xb8df, 0xb8f6, 0xb9ab, 0xb9c9, 0xb9d8, 0xb9fa, 0xb9fd, 0xbacd, 0xbba7, 0xbbd6, \n 0xbbe1, 0xbbfa, 0xbcbc, 0xbcdb, 0xbcfe, 0xbdcc, 0xbecd, 0xbedd, 0xbfb4, 0xbfc6, \n 0xbfc9, 0xc0b4, 0xc0ed, 0xc1cb, 0xc2db, 0xc3c7, 0xc4dc, 0xc4ea, 0xc5cc, 0xc6f7, \n 0xc7f8, 0xc8ab, 0xc8cb, 0xc8d5, 0xc8e7, 0xc9cf, 0xc9fa, 0xcab1, 0xcab5, 0xcac7, \n 0xcad0, 0xcad6, 0xcaf5, 0xcafd, 0xccec, 0xcdf8, 0xceaa, 0xcec4, 0xced2, 0xcee5, \n 0xcfb5, 0xcfc2, 0xcfd6, 0xd0c2, 0xd0c5, 0xd0d0, 0xd0d4, 0xd1a7, 0xd2aa, 0xd2b2, \n 0xd2b5, 0xd2bb, 0xd2d4, 0xd3c3, 0xd3d0, 0xd3fd, 0xd4c2, 0xd4da, 0xd5e2, 0xd6d0};\n\n \n String getName() {\n return \"GB18030\";\n }\n \n CharsetMatch match(CharsetDetector det) {\n int confidence = match(det, commonChars);\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n \n public String getLanguage()\n {\n return \"zh\";\n }\n }\n \n \n}\n"
},
{
"path": "src/main/java/com/ibm/icu/text/CharsetRecog_sbcs.java",
"content": "/*\n ****************************************************************************\n * Copyright (C) 2005-2013, International Business Machines Corporation and *\n * others. All Rights Reserved. *\n ************************************************************************** *\n *\n * Modified by Oleg Trifonov\n * added cp866 support\n */\n\npackage com.ibm.icu.text;\n\n\n/**\n * This class recognizes single-byte encodings. Because the encoding scheme is so\n * simple, language statistics are used to do the matching.\n */\nabstract class CharsetRecog_sbcs extends CharsetRecognizer {\n\n /* (non-Javadoc)\n * @see com.ibm.icu.text.CharsetRecognizer#getName()\n */\n abstract String getName();\n\n static class NGramParser\n {\n// private static final int N_GRAM_SIZE = 3;\n private static final int N_GRAM_MASK = 0xFFFFFF;\n\n protected int byteIndex = 0;\n private int ngram;\n \n private final int[] ngramList;\n protected byte[] byteMap;\n \n private int ngramCount;\n private int hitCount;\n \n protected byte spaceChar;\n \n public NGramParser(int[] theNgramList, byte[] theByteMap)\n {\n ngramList = theNgramList;\n byteMap = theByteMap;\n \n ngram = 0;\n \n ngramCount = hitCount = 0;\n }\n \n /*\n * Binary search for value in table, which must have exactly 64 entries.\n */\n private static int search(int[] table, int value)\n {\n int index = 0;\n \n if (table[index + 32] <= value) {\n index += 32;\n }\n \n if (table[index + 16] <= value) {\n index += 16;\n }\n\n if (table[index + 8] <= value) {\n index += 8;\n }\n\n if (table[index + 4] <= value) {\n index += 4;\n }\n\n if (table[index + 2] <= value) {\n index += 2;\n }\n\n if (table[index + 1] <= value) {\n index += 1;\n }\n\n if (table[index] > value) {\n index -= 1;\n }\n \n if (index < 0 || table[index] != value) {\n return -1;\n }\n \n return index;\n }\n\n private void lookup(int thisNgram)\n {\n ngramCount += 1;\n \n if (search(ngramList, thisNgram) >= 0) {\n hitCount += 1;\n }\n \n }\n \n protected void addByte(int b)\n {\n ngram = ((ngram << 8) + (b & 0xFF)) & N_GRAM_MASK;\n lookup(ngram);\n }\n \n private int nextByte(CharsetDetector det)\n {\n if (byteIndex >= det.fInputLen) {\n return -1;\n }\n \n return det.fInputBytes[byteIndex++] & 0xFF;\n }\n \n protected void parseCharacters(CharsetDetector det)\n {\n int b;\n boolean ignoreSpace = false;\n \n while ((b = nextByte(det)) >= 0) {\n byte mb = byteMap[b];\n \n // TODO: 0x20 might not be a space in all character sets...\n if (mb != 0) {\n if (!(mb == spaceChar && ignoreSpace)) {\n addByte(mb); \n }\n \n ignoreSpace = (mb == spaceChar);\n }\n }\n \n }\n\n public int parse(CharsetDetector det)\n {\n return parse (det, (byte)0x20);\n }\n public int parse(CharsetDetector det, byte spaceCh)\n {\n \n this.spaceChar = spaceCh;\n \n parseCharacters(det);\n \n // TODO: Is this OK? The buffer could have ended in the middle of a word...\n addByte(spaceChar);\n\n double rawPercent = (double) hitCount / (double) ngramCount;\n \n// if (rawPercent <= 2.0) {\n// return 0;\n// }\n \n // TODO - This is a bit of a hack to take care of a case\n // were we were getting a confidence of 135...\n if (rawPercent > 0.33) {\n return 98;\n }\n \n return (int) (rawPercent * 300.0);\n }\n }\n \n static class NGramParser_IBM420 extends NGramParser\n {\n private byte alef = 0x00;\n \n protected static byte[] unshapeMap = {\n/* -0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -A -B -C -D -E -F */\n/* 0- */ (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 1- */ (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 2- */ (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 3- */ (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 4- */ (byte) 0x40, (byte) 0x40, (byte) 0x42, (byte) 0x42, (byte) 0x44, (byte) 0x45, (byte) 0x46, (byte) 0x47, (byte) 0x47, (byte) 0x49, (byte) 0x4A, (byte) 0x4B, (byte) 0x4C, (byte) 0x4D, (byte) 0x4E, (byte) 0x4F, \n/* 5- */ (byte) 0x50, (byte) 0x49, (byte) 0x52, (byte) 0x53, (byte) 0x54, (byte) 0x55, (byte) 0x56, (byte) 0x56, (byte) 0x58, (byte) 0x58, (byte) 0x5A, (byte) 0x5B, (byte) 0x5C, (byte) 0x5D, (byte) 0x5E, (byte) 0x5F, \n/* 6- */ (byte) 0x60, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x63, (byte) 0x65, (byte) 0x65, (byte) 0x67, (byte) 0x67, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n/* 7- */ (byte) 0x69, (byte) 0x71, (byte) 0x71, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, (byte) 0x77, (byte) 0x79, (byte) 0x7A, (byte) 0x7B, (byte) 0x7C, (byte) 0x7D, (byte) 0x7E, (byte) 0x7F, \n/* 8- */ (byte) 0x80, (byte) 0x81, (byte) 0x82, (byte) 0x83, (byte) 0x84, (byte) 0x85, (byte) 0x86, (byte) 0x87, (byte) 0x88, (byte) 0x89, (byte) 0x80, (byte) 0x8B, (byte) 0x8B, (byte) 0x8D, (byte) 0x8D, (byte) 0x8F, \n/* 9- */ (byte) 0x90, (byte) 0x91, (byte) 0x92, (byte) 0x93, (byte) 0x94, (byte) 0x95, (byte) 0x96, (byte) 0x97, (byte) 0x98, (byte) 0x99, (byte) 0x9A, (byte) 0x9A, (byte) 0x9A, (byte) 0x9A, (byte) 0x9E, (byte) 0x9E, \n/* A- */ (byte) 0x9E, (byte) 0xA1, (byte) 0xA2, (byte) 0xA3, (byte) 0xA4, (byte) 0xA5, (byte) 0xA6, (byte) 0xA7, (byte) 0xA8, (byte) 0xA9, (byte) 0x9E, (byte) 0xAB, (byte) 0xAB, (byte) 0xAD, (byte) 0xAD, (byte) 0xAF, \n/* B- */ (byte) 0xAF, (byte) 0xB1, (byte) 0xB2, (byte) 0xB3, (byte) 0xB4, (byte) 0xB5, (byte) 0xB6, (byte) 0xB7, (byte) 0xB8, (byte) 0xB9, (byte) 0xB1, (byte) 0xBB, (byte) 0xBB, (byte) 0xBD, (byte) 0xBD, (byte) 0xBF, \n/* C- */ (byte) 0xC0, (byte) 0xC1, (byte) 0xC2, (byte) 0xC3, (byte) 0xC4, (byte) 0xC5, (byte) 0xC6, (byte) 0xC7, (byte) 0xC8, (byte) 0xC9, (byte) 0xCA, (byte) 0xBF, (byte) 0xCC, (byte) 0xBF, (byte) 0xCE, (byte) 0xCF, \n/* D- */ (byte) 0xD0, (byte) 0xD1, (byte) 0xD2, (byte) 0xD3, (byte) 0xD4, (byte) 0xD5, (byte) 0xD6, (byte) 0xD7, (byte) 0xD8, (byte) 0xD9, (byte) 0xDA, (byte) 0xDA, (byte) 0xDC, (byte) 0xDC, (byte) 0xDC, (byte) 0xDF, \n/* E- */ (byte) 0xE0, (byte) 0xE1, (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, (byte) 0xE8, (byte) 0xE9, (byte) 0xEA, (byte) 0xEB, (byte) 0xEC, (byte) 0xED, (byte) 0xEE, (byte) 0xEF, \n/* F- */ (byte) 0xF0, (byte) 0xF1, (byte) 0xF2, (byte) 0xF3, (byte) 0xF4, (byte) 0xF5, (byte) 0xF6, (byte) 0xF7, (byte) 0xF8, (byte) 0xF9, (byte) 0xFA, (byte) 0xFB, (byte) 0xFC, (byte) 0xFD, (byte) 0xFE, (byte) 0xFF, \n };\n \n\n public NGramParser_IBM420(int[] theNgramList, byte[] theByteMap)\n {\n super(theNgramList, theByteMap);\n }\n \n private byte isLamAlef(byte b) {\n if(b == (byte)0xb2 || b == (byte)0xb3){\n return (byte)0x47;\n }else if(b == (byte)0xb4 || b == (byte)0xb5){\n return (byte)0x49;\n }else if(b == (byte)0xb8 || b == (byte)0xb9){\n return (byte)0x56;\n }else\n return (byte)0x00;\n }\n \n /*\n * Arabic shaping needs to be done manually. Cannot call ArabicShaping class\n * because CharsetDetector is dealing with bytes not Unicode code points. We could\n * convert the bytes to Unicode code points but that would leave us dependent\n * on CharsetICU which we try to avoid. IBM420 converter amongst different versions\n * of JDK can produce different results and therefore is also avoided.\n */\n private int nextByte(CharsetDetector det)\n {\n if (byteIndex >= det.fInputLen || det.fInputBytes[byteIndex] == 0) {\n return -1;\n } \n int next;\n \n alef = isLamAlef(det.fInputBytes[byteIndex]);\n if(alef != (byte)0x00)\n next = 0xB1 & 0xFF;\n else\n next = unshapeMap[det.fInputBytes[byteIndex]& 0xFF] & 0xFF;\n \n byteIndex++;\n \n return next;\n }\n \n protected void parseCharacters(CharsetDetector det)\n {\n int b;\n boolean ignoreSpace = false;\n \n while ((b = nextByte(det)) >= 0) {\n byte mb = byteMap[b];\n \n // TODO: 0x20 might not be a space in all character sets...\n if (mb != 0) {\n if (!(mb == spaceChar && ignoreSpace)) {\n addByte(mb); \n }\n \n ignoreSpace = (mb == spaceChar);\n }\n if(alef != (byte)0x00){\n mb = byteMap[alef & 0xFF];\n \n // TODO: 0x20 might not be a space in all character sets...\n if (mb != 0) {\n if (!(mb == spaceChar && ignoreSpace)) {\n addByte(mb); \n }\n \n ignoreSpace = (mb == spaceChar);\n }\n \n }\n }\n }\n }\n \n \n int match(CharsetDetector det, int[] ngrams, byte[] byteMap)\n {\n return match(det, ngrams, byteMap, (byte)0x20);\n }\n \n int match(CharsetDetector det, int[] ngrams, byte[] byteMap, byte spaceChar) {\n NGramParser parser = new NGramParser(ngrams, byteMap);\n return parser.parse(det, spaceChar);\n }\n \n int matchIBM420(CharsetDetector det, int[] ngrams, byte[] byteMap, byte spaceChar){\n NGramParser_IBM420 parser = new NGramParser_IBM420(ngrams, byteMap);\n return parser.parse(det, spaceChar);\n }\n \n static class NGramsPlusLang {\n int[] fNGrams;\n String fLang;\n NGramsPlusLang(String la, int [] ng) {\n fLang = la;\n fNGrams = ng;\n }\n }\n\n static class CharsetRecog_8859_1 extends CharsetRecog_sbcs\n {\n protected static byte[] byteMap = {\n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x00, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, \n (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, \n (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, \n (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, \n (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0xAA, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0xB5, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0xBA, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0xE0, (byte) 0xE1, (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, \n (byte) 0xE8, (byte) 0xE9, (byte) 0xEA, (byte) 0xEB, (byte) 0xEC, (byte) 0xED, (byte) 0xEE, (byte) 0xEF, \n (byte) 0xF0, (byte) 0xF1, (byte) 0xF2, (byte) 0xF3, (byte) 0xF4, (byte) 0xF5, (byte) 0xF6, (byte) 0x20, \n (byte) 0xF8, (byte) 0xF9, (byte) 0xFA, (byte) 0xFB, (byte) 0xFC, (byte) 0xFD, (byte) 0xFE, (byte) 0xDF, \n (byte) 0xE0, (byte) 0xE1, (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, \n (byte) 0xE8, (byte) 0xE9, (byte) 0xEA, (byte) 0xEB, (byte) 0xEC, (byte) 0xED, (byte) 0xEE, (byte) 0xEF, \n (byte) 0xF0, (byte) 0xF1, (byte) 0xF2, (byte) 0xF3, (byte) 0xF4, (byte) 0xF5, (byte) 0xF6, (byte) 0x20, \n (byte) 0xF8, (byte) 0xF9, (byte) 0xFA, (byte) 0xFB, (byte) 0xFC, (byte) 0xFD, (byte) 0xFE, (byte) 0xFF, \n };\n \n \n private static final NGramsPlusLang[] ngrams_8859_1 = new NGramsPlusLang[] {\n new NGramsPlusLang(\n \"da\", \n new int[] {\n // ' af'\n 0x206166, 0x206174, 0x206465, 0x20656E, 0x206572, 0x20666F, 0x206861, 0x206920, 0x206D65, 0x206F67, 0x2070E5, 0x207369, 0x207374, 0x207469, 0x207669, 0x616620, \n 0x616E20, 0x616E64, 0x617220, 0x617420, 0x646520, 0x64656E, 0x646572, 0x646574, 0x652073, 0x656420, 0x656465, 0x656E20, 0x656E64, 0x657220, 0x657265, 0x657320, \n 0x657420, 0x666F72, 0x676520, 0x67656E, 0x676572, 0x696765, 0x696C20, 0x696E67, 0x6B6520, 0x6B6B65, 0x6C6572, 0x6C6967, 0x6C6C65, 0x6D6564, 0x6E6465, 0x6E6520, \n 0x6E6720, 0x6E6765, 0x6F6720, 0x6F6D20, 0x6F7220, 0x70E520, 0x722064, 0x722065, 0x722073, 0x726520, 0x737465, 0x742073, 0x746520, 0x746572, 0x74696C, 0x766572, \n }),\n new NGramsPlusLang(\n \"de\",\n new int[] {\n // ' an'\n 0x20616E, 0x206175, 0x206265, 0x206461, 0x206465, 0x206469, 0x206569, 0x206765, 0x206861, 0x20696E, 0x206D69, 0x207363, 0x207365, 0x20756E, 0x207665, 0x20766F, \n 0x207765, 0x207A75, 0x626572, 0x636820, 0x636865, 0x636874, 0x646173, 0x64656E, 0x646572, 0x646965, 0x652064, 0x652073, 0x65696E, 0x656974, 0x656E20, 0x657220, \n 0x657320, 0x67656E, 0x68656E, 0x687420, 0x696368, 0x696520, 0x696E20, 0x696E65, 0x697420, 0x6C6963, 0x6C6C65, 0x6E2061, 0x6E2064, 0x6E2073, 0x6E6420, 0x6E6465, \n 0x6E6520, 0x6E6720, 0x6E6765, 0x6E7465, 0x722064, 0x726465, 0x726569, 0x736368, 0x737465, 0x742064, 0x746520, 0x74656E, 0x746572, 0x756E64, 0x756E67, 0x766572, \n }),\n new NGramsPlusLang(\n \"en\",\n new int[] {\n 0x206120, 0x20616E, 0x206265, 0x20636F, 0x20666F, 0x206861, 0x206865, 0x20696E, 0x206D61, 0x206F66, 0x207072, 0x207265, 0x207361, 0x207374, 0x207468, 0x20746F, \n 0x207768, 0x616964, 0x616C20, 0x616E20, 0x616E64, 0x617320, 0x617420, 0x617465, 0x617469, 0x642061, 0x642074, 0x652061, 0x652073, 0x652074, 0x656420, 0x656E74, \n 0x657220, 0x657320, 0x666F72, 0x686174, 0x686520, 0x686572, 0x696420, 0x696E20, 0x696E67, 0x696F6E, 0x697320, 0x6E2061, 0x6E2074, 0x6E6420, 0x6E6720, 0x6E7420, \n 0x6F6620, 0x6F6E20, 0x6F7220, 0x726520, 0x727320, 0x732061, 0x732074, 0x736169, 0x737420, 0x742074, 0x746572, 0x746861, 0x746865, 0x74696F, 0x746F20, 0x747320, \n }),\n\n new NGramsPlusLang(\n \"es\",\n new int[] {\n 0x206120, 0x206361, 0x20636F, 0x206465, 0x20656C, 0x20656E, 0x206573, 0x20696E, 0x206C61, 0x206C6F, 0x207061, 0x20706F, 0x207072, 0x207175, 0x207265, 0x207365, \n 0x20756E, 0x207920, 0x612063, 0x612064, 0x612065, 0x61206C, 0x612070, 0x616369, 0x61646F, 0x616C20, 0x617220, 0x617320, 0x6369F3, 0x636F6E, 0x646520, 0x64656C, \n 0x646F20, 0x652064, 0x652065, 0x65206C, 0x656C20, 0x656E20, 0x656E74, 0x657320, 0x657374, 0x69656E, 0x69F36E, 0x6C6120, 0x6C6F73, 0x6E2065, 0x6E7465, 0x6F2064, \n 0x6F2065, 0x6F6E20, 0x6F7220, 0x6F7320, 0x706172, 0x717565, 0x726120, 0x726573, 0x732064, 0x732065, 0x732070, 0x736520, 0x746520, 0x746F20, 0x756520, 0xF36E20, \n }),\n \n new NGramsPlusLang(\n \"fr\",\n new int[] {\n 0x206175, 0x20636F, 0x206461, 0x206465, 0x206475, 0x20656E, 0x206574, 0x206C61, 0x206C65, 0x207061, 0x20706F, 0x207072, 0x207175, 0x207365, 0x20736F, 0x20756E, \n 0x20E020, 0x616E74, 0x617469, 0x636520, 0x636F6E, 0x646520, 0x646573, 0x647520, 0x652061, 0x652063, 0x652064, 0x652065, 0x65206C, 0x652070, 0x652073, 0x656E20, \n 0x656E74, 0x657220, 0x657320, 0x657420, 0x657572, 0x696F6E, 0x697320, 0x697420, 0x6C6120, 0x6C6520, 0x6C6573, 0x6D656E, 0x6E2064, 0x6E6520, 0x6E7320, 0x6E7420, \n 0x6F6E20, 0x6F6E74, 0x6F7572, 0x717565, 0x72206C, 0x726520, 0x732061, 0x732064, 0x732065, 0x73206C, 0x732070, 0x742064, 0x746520, 0x74696F, 0x756520, 0x757220,\n }),\n\n new NGramsPlusLang(\n \"it\",\n new int[] {\n 0x20616C, 0x206368, 0x20636F, 0x206465, 0x206469, 0x206520, 0x20696C, 0x20696E, 0x206C61, 0x207065, 0x207072, 0x20756E, 0x612063, 0x612064, 0x612070, 0x612073, \n 0x61746F, 0x636865, 0x636F6E, 0x64656C, 0x646920, 0x652061, 0x652063, 0x652064, 0x652069, 0x65206C, 0x652070, 0x652073, 0x656C20, 0x656C6C, 0x656E74, 0x657220, \n 0x686520, 0x692061, 0x692063, 0x692064, 0x692073, 0x696120, 0x696C20, 0x696E20, 0x696F6E, 0x6C6120, 0x6C6520, 0x6C6920, 0x6C6C61, 0x6E6520, 0x6E6920, 0x6E6F20, \n 0x6E7465, 0x6F2061, 0x6F2064, 0x6F2069, 0x6F2073, 0x6F6E20, 0x6F6E65, 0x706572, 0x726120, 0x726520, 0x736920, 0x746120, 0x746520, 0x746920, 0x746F20, 0x7A696F, \n }),\n \n new NGramsPlusLang(\n \"nl\",\n new int[] {\n 0x20616C, 0x206265, 0x206461, 0x206465, 0x206469, 0x206565, 0x20656E, 0x206765, 0x206865, 0x20696E, 0x206D61, 0x206D65, 0x206F70, 0x207465, 0x207661, 0x207665, \n 0x20766F, 0x207765, 0x207A69, 0x61616E, 0x616172, 0x616E20, 0x616E64, 0x617220, 0x617420, 0x636874, 0x646520, 0x64656E, 0x646572, 0x652062, 0x652076, 0x65656E, \n 0x656572, 0x656E20, 0x657220, 0x657273, 0x657420, 0x67656E, 0x686574, 0x696520, 0x696E20, 0x696E67, 0x697320, 0x6E2062, 0x6E2064, 0x6E2065, 0x6E2068, 0x6E206F, \n 0x6E2076, 0x6E6465, 0x6E6720, 0x6F6E64, 0x6F6F72, 0x6F7020, 0x6F7220, 0x736368, 0x737465, 0x742064, 0x746520, 0x74656E, 0x746572, 0x76616E, 0x766572, 0x766F6F, \n }),\n \n new NGramsPlusLang(\n \"no\",\n new int[] {\n 0x206174, 0x206176, 0x206465, 0x20656E, 0x206572, 0x20666F, 0x206861, 0x206920, 0x206D65, 0x206F67, 0x2070E5, 0x207365, 0x20736B, 0x20736F, 0x207374, 0x207469, \n 0x207669, 0x20E520, 0x616E64, 0x617220, 0x617420, 0x646520, 0x64656E, 0x646574, 0x652073, 0x656420, 0x656E20, 0x656E65, 0x657220, 0x657265, 0x657420, 0x657474, \n 0x666F72, 0x67656E, 0x696B6B, 0x696C20, 0x696E67, 0x6B6520, 0x6B6B65, 0x6C6520, 0x6C6C65, 0x6D6564, 0x6D656E, 0x6E2073, 0x6E6520, 0x6E6720, 0x6E6765, 0x6E6E65, \n 0x6F6720, 0x6F6D20, 0x6F7220, 0x70E520, 0x722073, 0x726520, 0x736F6D, 0x737465, 0x742073, 0x746520, 0x74656E, 0x746572, 0x74696C, 0x747420, 0x747465, 0x766572, \n }),\n \n new NGramsPlusLang(\n \"pt\",\n new int[] {\n 0x206120, 0x20636F, 0x206461, 0x206465, 0x20646F, 0x206520, 0x206573, 0x206D61, 0x206E6F, 0x206F20, 0x207061, 0x20706F, 0x207072, 0x207175, 0x207265, 0x207365, \n 0x20756D, 0x612061, 0x612063, 0x612064, 0x612070, 0x616465, 0x61646F, 0x616C20, 0x617220, 0x617261, 0x617320, 0x636F6D, 0x636F6E, 0x646120, 0x646520, 0x646F20, \n 0x646F73, 0x652061, 0x652064, 0x656D20, 0x656E74, 0x657320, 0x657374, 0x696120, 0x696361, 0x6D656E, 0x6E7465, 0x6E746F, 0x6F2061, 0x6F2063, 0x6F2064, 0x6F2065, \n 0x6F2070, 0x6F7320, 0x706172, 0x717565, 0x726120, 0x726573, 0x732061, 0x732064, 0x732065, 0x732070, 0x737461, 0x746520, 0x746F20, 0x756520, 0xE36F20, 0xE7E36F, \n\n }),\n \n new NGramsPlusLang(\n \"sv\",\n new int[] {\n 0x206174, 0x206176, 0x206465, 0x20656E, 0x2066F6, 0x206861, 0x206920, 0x20696E, 0x206B6F, 0x206D65, 0x206F63, 0x2070E5, 0x20736B, 0x20736F, 0x207374, 0x207469, \n 0x207661, 0x207669, 0x20E472, 0x616465, 0x616E20, 0x616E64, 0x617220, 0x617474, 0x636820, 0x646520, 0x64656E, 0x646572, 0x646574, 0x656420, 0x656E20, 0x657220, \n 0x657420, 0x66F672, 0x67656E, 0x696C6C, 0x696E67, 0x6B6120, 0x6C6C20, 0x6D6564, 0x6E2073, 0x6E6120, 0x6E6465, 0x6E6720, 0x6E6765, 0x6E696E, 0x6F6368, 0x6F6D20, \n 0x6F6E20, 0x70E520, 0x722061, 0x722073, 0x726120, 0x736B61, 0x736F6D, 0x742073, 0x746120, 0x746520, 0x746572, 0x74696C, 0x747420, 0x766172, 0xE47220, 0xF67220, \n }),\n \n };\n\n \n public CharsetMatch match(CharsetDetector det)\n {\n String name = det.fC1Bytes ? \"windows-1252\" : \"ISO-8859-1\";\n int bestConfidenceSoFar = -1;\n String lang = null;\n for (NGramsPlusLang ngl: ngrams_8859_1) {\n int confidence = match(det, ngl.fNGrams, byteMap);\n if (confidence > bestConfidenceSoFar) {\n bestConfidenceSoFar = confidence;\n lang = ngl.fLang;\n }\n }\n return bestConfidenceSoFar <= 0 ? null : new CharsetMatch(det, bestConfidenceSoFar, name, lang);\n }\n\n \n public String getName()\n {\n return \"ISO-8859-1\";\n }\n }\n\n \n static class CharsetRecog_8859_2 extends CharsetRecog_sbcs\n {\n protected static byte[] byteMap = {\n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x00, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, \n (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, \n (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, \n (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, \n (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0xB1, (byte) 0x20, (byte) 0xB3, (byte) 0x20, (byte) 0xB5, (byte) 0xB6, (byte) 0x20, \n (byte) 0x20, (byte) 0xB9, (byte) 0xBA, (byte) 0xBB, (byte) 0xBC, (byte) 0x20, (byte) 0xBE, (byte) 0xBF, \n (byte) 0x20, (byte) 0xB1, (byte) 0x20, (byte) 0xB3, (byte) 0x20, (byte) 0xB5, (byte) 0xB6, (byte) 0xB7, \n (byte) 0x20, (byte) 0xB9, (byte) 0xBA, (byte) 0xBB, (byte) 0xBC, (byte) 0x20, (byte) 0xBE, (byte) 0xBF, \n (byte) 0xE0, (byte) 0xE1, (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, \n (byte) 0xE8, (byte) 0xE9, (byte) 0xEA, (byte) 0xEB, (byte) 0xEC, (byte) 0xED, (byte) 0xEE, (byte) 0xEF, \n (byte) 0xF0, (byte) 0xF1, (byte) 0xF2, (byte) 0xF3, (byte) 0xF4, (byte) 0xF5, (byte) 0xF6, (byte) 0x20, \n (byte) 0xF8, (byte) 0xF9, (byte) 0xFA, (byte) 0xFB, (byte) 0xFC, (byte) 0xFD, (byte) 0xFE, (byte) 0xDF, \n (byte) 0xE0, (byte) 0xE1, (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, \n (byte) 0xE8, (byte) 0xE9, (byte) 0xEA, (byte) 0xEB, (byte) 0xEC, (byte) 0xED, (byte) 0xEE, (byte) 0xEF, \n (byte) 0xF0, (byte) 0xF1, (byte) 0xF2, (byte) 0xF3, (byte) 0xF4, (byte) 0xF5, (byte) 0xF6, (byte) 0x20, \n (byte) 0xF8, (byte) 0xF9, (byte) 0xFA, (byte) 0xFB, (byte) 0xFC, (byte) 0xFD, (byte) 0xFE, (byte) 0x20, \n };\n\n private static final NGramsPlusLang[] ngrams_8859_2 = new NGramsPlusLang[] {\n new NGramsPlusLang(\n \"cs\", \n new int[] {\n 0x206120, 0x206279, 0x20646F, 0x206A65, 0x206E61, 0x206E65, 0x206F20, 0x206F64, 0x20706F, 0x207072, 0x2070F8, 0x20726F, 0x207365, 0x20736F, 0x207374, 0x20746F, \n 0x207620, 0x207679, 0x207A61, 0x612070, 0x636520, 0x636820, 0x652070, 0x652073, 0x652076, 0x656D20, 0x656EED, 0x686F20, 0x686F64, 0x697374, 0x6A6520, 0x6B7465, \n 0x6C6520, 0x6C6920, 0x6E6120, 0x6EE920, 0x6EEC20, 0x6EED20, 0x6F2070, 0x6F646E, 0x6F6A69, 0x6F7374, 0x6F7520, 0x6F7661, 0x706F64, 0x706F6A, 0x70726F, 0x70F865, \n 0x736520, 0x736F75, 0x737461, 0x737469, 0x73746E, 0x746572, 0x746EED, 0x746F20, 0x752070, 0xBE6520, 0xE16EED, 0xE9686F, 0xED2070, 0xED2073, 0xED6D20, 0xF86564, \n }),\n new NGramsPlusLang(\n \"hu\", \n new int[] {\n 0x206120, 0x20617A, 0x206265, 0x206567, 0x20656C, 0x206665, 0x206861, 0x20686F, 0x206973, 0x206B65, 0x206B69, 0x206BF6, 0x206C65, 0x206D61, 0x206D65, 0x206D69, \n 0x206E65, 0x20737A, 0x207465, 0x20E973, 0x612061, 0x61206B, 0x61206D, 0x612073, 0x616B20, 0x616E20, 0x617A20, 0x62616E, 0x62656E, 0x656779, 0x656B20, 0x656C20, \n 0x656C65, 0x656D20, 0x656E20, 0x657265, 0x657420, 0x657465, 0x657474, 0x677920, 0x686F67, 0x696E74, 0x697320, 0x6B2061, 0x6BF67A, 0x6D6567, 0x6D696E, 0x6E2061, \n 0x6E616B, 0x6E656B, 0x6E656D, 0x6E7420, 0x6F6779, 0x732061, 0x737A65, 0x737A74, 0x737AE1, 0x73E967, 0x742061, 0x747420, 0x74E173, 0x7A6572, 0xE16E20, 0xE97320, \n }),\n new NGramsPlusLang(\n \"pl\", \n new int[] {\n 0x20637A, 0x20646F, 0x206920, 0x206A65, 0x206B6F, 0x206D61, 0x206D69, 0x206E61, 0x206E69, 0x206F64, 0x20706F, 0x207072, 0x207369, 0x207720, 0x207769, 0x207779, \n 0x207A20, 0x207A61, 0x612070, 0x612077, 0x616E69, 0x636820, 0x637A65, 0x637A79, 0x646F20, 0x647A69, 0x652070, 0x652073, 0x652077, 0x65207A, 0x65676F, 0x656A20, \n 0x656D20, 0x656E69, 0x676F20, 0x696120, 0x696520, 0x69656A, 0x6B6120, 0x6B6920, 0x6B6965, 0x6D6965, 0x6E6120, 0x6E6961, 0x6E6965, 0x6F2070, 0x6F7761, 0x6F7769, \n 0x706F6C, 0x707261, 0x70726F, 0x70727A, 0x727A65, 0x727A79, 0x7369EA, 0x736B69, 0x737461, 0x776965, 0x796368, 0x796D20, 0x7A6520, 0x7A6965, 0x7A7920, 0xF37720, \n }),\n new NGramsPlusLang(\n \"ro\", \n new int[] {\n 0x206120, 0x206163, 0x206361, 0x206365, 0x20636F, 0x206375, 0x206465, 0x206469, 0x206C61, 0x206D61, 0x207065, 0x207072, 0x207365, 0x2073E3, 0x20756E, 0x20BA69, \n 0x20EE6E, 0x612063, 0x612064, 0x617265, 0x617420, 0x617465, 0x617520, 0x636172, 0x636F6E, 0x637520, 0x63E320, 0x646520, 0x652061, 0x652063, 0x652064, 0x652070, \n 0x652073, 0x656120, 0x656920, 0x656C65, 0x656E74, 0x657374, 0x692061, 0x692063, 0x692064, 0x692070, 0x696520, 0x696920, 0x696E20, 0x6C6120, 0x6C6520, 0x6C6F72, \n 0x6C7569, 0x6E6520, 0x6E7472, 0x6F7220, 0x70656E, 0x726520, 0x726561, 0x727520, 0x73E320, 0x746520, 0x747275, 0x74E320, 0x756920, 0x756C20, 0xBA6920, 0xEE6E20, \n })\n };\n\n public CharsetMatch match(CharsetDetector det)\n {\n String name = det.fC1Bytes ? \"windows-1250\" : \"ISO-8859-2\";\n int bestConfidenceSoFar = -1;\n String lang = null;\n for (NGramsPlusLang ngl: ngrams_8859_2) {\n int confidence = match(det, ngl.fNGrams, byteMap);\n if (confidence > bestConfidenceSoFar) {\n bestConfidenceSoFar = confidence;\n lang = ngl.fLang;\n }\n }\n return bestConfidenceSoFar <= 0 ? null : new CharsetMatch(det, bestConfidenceSoFar, name, lang);\n }\n\n public String getName()\n {\n return \"ISO-8859-2\";\n }\n\n }\n \n \n abstract static class CharsetRecog_8859_5 extends CharsetRecog_sbcs\n {\n protected static byte[] byteMap = {\n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x00, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, \n (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, \n (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, \n (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, \n (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0xF1, (byte) 0xF2, (byte) 0xF3, (byte) 0xF4, (byte) 0xF5, (byte) 0xF6, (byte) 0xF7, \n (byte) 0xF8, (byte) 0xF9, (byte) 0xFA, (byte) 0xFB, (byte) 0xFC, (byte) 0x20, (byte) 0xFE, (byte) 0xFF, \n (byte) 0xD0, (byte) 0xD1, (byte) 0xD2, (byte) 0xD3, (byte) 0xD4, (byte) 0xD5, (byte) 0xD6, (byte) 0xD7, \n (byte) 0xD8, (byte) 0xD9, (byte) 0xDA, (byte) 0xDB, (byte) 0xDC, (byte) 0xDD, (byte) 0xDE, (byte) 0xDF, \n (byte) 0xE0, (byte) 0xE1, (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, \n (byte) 0xE8, (byte) 0xE9, (byte) 0xEA, (byte) 0xEB, (byte) 0xEC, (byte) 0xED, (byte) 0xEE, (byte) 0xEF, \n (byte) 0xD0, (byte) 0xD1, (byte) 0xD2, (byte) 0xD3, (byte) 0xD4, (byte) 0xD5, (byte) 0xD6, (byte) 0xD7, \n (byte) 0xD8, (byte) 0xD9, (byte) 0xDA, (byte) 0xDB, (byte) 0xDC, (byte) 0xDD, (byte) 0xDE, (byte) 0xDF, \n (byte) 0xE0, (byte) 0xE1, (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, \n (byte) 0xE8, (byte) 0xE9, (byte) 0xEA, (byte) 0xEB, (byte) 0xEC, (byte) 0xED, (byte) 0xEE, (byte) 0xEF, \n (byte) 0x20, (byte) 0xF1, (byte) 0xF2, (byte) 0xF3, (byte) 0xF4, (byte) 0xF5, (byte) 0xF6, (byte) 0xF7, \n (byte) 0xF8, (byte) 0xF9, (byte) 0xFA, (byte) 0xFB, (byte) 0xFC, (byte) 0x20, (byte) 0xFE, (byte) 0xFF, \n };\n\n public String getName()\n {\n return \"ISO-8859-5\";\n }\n }\n \n static class CharsetRecog_8859_5_ru extends CharsetRecog_8859_5\n {\n private static final int[] ngrams = {\n 0x20D220, 0x20D2DE, 0x20D4DE, 0x20D7D0, 0x20D820, 0x20DAD0, 0x20DADE, 0x20DDD0, 0x20DDD5, 0x20DED1, 0x20DFDE, 0x20DFE0, 0x20E0D0, 0x20E1DE, 0x20E1E2, 0x20E2DE, \n 0x20E7E2, 0x20EDE2, 0xD0DDD8, 0xD0E2EC, 0xD3DE20, 0xD5DBEC, 0xD5DDD8, 0xD5E1E2, 0xD5E220, 0xD820DF, 0xD8D520, 0xD8D820, 0xD8EF20, 0xDBD5DD, 0xDBD820, 0xDBECDD, \n 0xDDD020, 0xDDD520, 0xDDD8D5, 0xDDD8EF, 0xDDDE20, 0xDDDED2, 0xDE20D2, 0xDE20DF, 0xDE20E1, 0xDED220, 0xDED2D0, 0xDED3DE, 0xDED920, 0xDEDBEC, 0xDEDC20, 0xDEE1E2, \n 0xDFDEDB, 0xDFE0D5, 0xDFE0D8, 0xDFE0DE, 0xE0D0D2, 0xE0D5D4, 0xE1E2D0, 0xE1E2D2, 0xE1E2D8, 0xE1EF20, 0xE2D5DB, 0xE2DE20, 0xE2DEE0, 0xE2EC20, 0xE7E2DE, 0xEBE520, \n };\n\n public String getLanguage()\n {\n return \"ru\";\n }\n \n public CharsetMatch match(CharsetDetector det)\n {\n int confidence = match(det, ngrams, byteMap);\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n }\n \n abstract static class CharsetRecog_8859_6 extends CharsetRecog_sbcs\n {\n protected static byte[] byteMap = {\n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x00, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, \n (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, \n (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, \n (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, \n (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0xC1, (byte) 0xC2, (byte) 0xC3, (byte) 0xC4, (byte) 0xC5, (byte) 0xC6, (byte) 0xC7, \n (byte) 0xC8, (byte) 0xC9, (byte) 0xCA, (byte) 0xCB, (byte) 0xCC, (byte) 0xCD, (byte) 0xCE, (byte) 0xCF, \n (byte) 0xD0, (byte) 0xD1, (byte) 0xD2, (byte) 0xD3, (byte) 0xD4, (byte) 0xD5, (byte) 0xD6, (byte) 0xD7, \n (byte) 0xD8, (byte) 0xD9, (byte) 0xDA, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0xE0, (byte) 0xE1, (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, \n (byte) 0xE8, (byte) 0xE9, (byte) 0xEA, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n };\n\n public String getName()\n {\n return \"ISO-8859-6\";\n }\n }\n \n static class CharsetRecog_8859_6_ar extends CharsetRecog_8859_6\n {\n private static final int[] ngrams = {\n 0x20C7E4, 0x20C7E6, 0x20C8C7, 0x20D9E4, 0x20E1EA, 0x20E4E4, 0x20E5E6, 0x20E8C7, 0xC720C7, 0xC7C120, 0xC7CA20, 0xC7D120, 0xC7E420, 0xC7E4C3, 0xC7E4C7, 0xC7E4C8, \n 0xC7E4CA, 0xC7E4CC, 0xC7E4CD, 0xC7E4CF, 0xC7E4D3, 0xC7E4D9, 0xC7E4E2, 0xC7E4E5, 0xC7E4E8, 0xC7E4EA, 0xC7E520, 0xC7E620, 0xC7E6CA, 0xC820C7, 0xC920C7, 0xC920E1, \n 0xC920E4, 0xC920E5, 0xC920E8, 0xCA20C7, 0xCF20C7, 0xCFC920, 0xD120C7, 0xD1C920, 0xD320C7, 0xD920C7, 0xD9E4E9, 0xE1EA20, 0xE420C7, 0xE4C920, 0xE4E920, 0xE4EA20, \n 0xE520C7, 0xE5C720, 0xE5C920, 0xE5E620, 0xE620C7, 0xE720C7, 0xE7C720, 0xE8C7E4, 0xE8E620, 0xE920C7, 0xEA20C7, 0xEA20E5, 0xEA20E8, 0xEAC920, 0xEAD120, 0xEAE620, \n };\n\n public String getLanguage()\n {\n return \"ar\";\n }\n \n public CharsetMatch match(CharsetDetector det)\n {\n int confidence = match(det, ngrams, byteMap);\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n }\n \n abstract static class CharsetRecog_8859_7 extends CharsetRecog_sbcs\n {\n protected static byte[] byteMap = {\n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x00, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, \n (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, \n (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, \n (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, \n (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0xA1, (byte) 0xA2, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0xDC, (byte) 0x20, \n (byte) 0xDD, (byte) 0xDE, (byte) 0xDF, (byte) 0x20, (byte) 0xFC, (byte) 0x20, (byte) 0xFD, (byte) 0xFE, \n (byte) 0xC0, (byte) 0xE1, (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, \n (byte) 0xE8, (byte) 0xE9, (byte) 0xEA, (byte) 0xEB, (byte) 0xEC, (byte) 0xED, (byte) 0xEE, (byte) 0xEF, \n (byte) 0xF0, (byte) 0xF1, (byte) 0x20, (byte) 0xF3, (byte) 0xF4, (byte) 0xF5, (byte) 0xF6, (byte) 0xF7, \n (byte) 0xF8, (byte) 0xF9, (byte) 0xFA, (byte) 0xFB, (byte) 0xDC, (byte) 0xDD, (byte) 0xDE, (byte) 0xDF, \n (byte) 0xE0, (byte) 0xE1, (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, \n (byte) 0xE8, (byte) 0xE9, (byte) 0xEA, (byte) 0xEB, (byte) 0xEC, (byte) 0xED, (byte) 0xEE, (byte) 0xEF, \n (byte) 0xF0, (byte) 0xF1, (byte) 0xF2, (byte) 0xF3, (byte) 0xF4, (byte) 0xF5, (byte) 0xF6, (byte) 0xF7, \n (byte) 0xF8, (byte) 0xF9, (byte) 0xFA, (byte) 0xFB, (byte) 0xFC, (byte) 0xFD, (byte) 0xFE, (byte) 0x20, \n };\n\n public String getName()\n {\n return \"ISO-8859-7\";\n }\n }\n \n static class CharsetRecog_8859_7_el extends CharsetRecog_8859_7\n {\n private static final int[] ngrams = {\n 0x20E1ED, 0x20E1F0, 0x20E3E9, 0x20E4E9, 0x20E5F0, 0x20E720, 0x20EAE1, 0x20ECE5, 0x20EDE1, 0x20EF20, 0x20F0E1, 0x20F0EF, 0x20F0F1, 0x20F3F4, 0x20F3F5, 0x20F4E7, \n 0x20F4EF, 0xDFE120, 0xE120E1, 0xE120F4, 0xE1E920, 0xE1ED20, 0xE1F0FC, 0xE1F220, 0xE3E9E1, 0xE5E920, 0xE5F220, 0xE720F4, 0xE7ED20, 0xE7F220, 0xE920F4, 0xE9E120, \n 0xE9EADE, 0xE9F220, 0xEAE1E9, 0xEAE1F4, 0xECE520, 0xED20E1, 0xED20E5, 0xED20F0, 0xEDE120, 0xEFF220, 0xEFF520, 0xF0EFF5, 0xF0F1EF, 0xF0FC20, 0xF220E1, 0xF220E5, \n 0xF220EA, 0xF220F0, 0xF220F4, 0xF3E520, 0xF3E720, 0xF3F4EF, 0xF4E120, 0xF4E1E9, 0xF4E7ED, 0xF4E7F2, 0xF4E9EA, 0xF4EF20, 0xF4EFF5, 0xF4F9ED, 0xF9ED20, 0xFEED20, \n };\n\n public String getLanguage()\n {\n return \"el\";\n }\n \n public CharsetMatch match(CharsetDetector det)\n {\n String name = det.fC1Bytes ? \"windows-1253\" : \"ISO-8859-7\";\n int confidence = match(det, ngrams, byteMap);\n return confidence == 0 ? null : new CharsetMatch(det, confidence, name, \"el\");\n }\n }\n \n abstract static class CharsetRecog_8859_8 extends CharsetRecog_sbcs {\n protected static byte[] byteMap = {\n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x00, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, \n (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, \n (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, \n (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, \n (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0xB5, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0xE0, (byte) 0xE1, (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, \n (byte) 0xE8, (byte) 0xE9, (byte) 0xEA, (byte) 0xEB, (byte) 0xEC, (byte) 0xED, (byte) 0xEE, (byte) 0xEF, \n (byte) 0xF0, (byte) 0xF1, (byte) 0xF2, (byte) 0xF3, (byte) 0xF4, (byte) 0xF5, (byte) 0xF6, (byte) 0xF7, \n (byte) 0xF8, (byte) 0xF9, (byte) 0xFA, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n };\n\n public String getName()\n {\n return \"ISO-8859-8\";\n }\n }\n \n static class CharsetRecog_8859_8_I_he extends CharsetRecog_8859_8\n {\n private static final int[] ngrams = {\n 0x20E0E5, 0x20E0E7, 0x20E0E9, 0x20E0FA, 0x20E1E9, 0x20E1EE, 0x20E4E0, 0x20E4E5, 0x20E4E9, 0x20E4EE, 0x20E4F2, 0x20E4F9, 0x20E4FA, 0x20ECE0, 0x20ECE4, 0x20EEE0, \n 0x20F2EC, 0x20F9EC, 0xE0FA20, 0xE420E0, 0xE420E1, 0xE420E4, 0xE420EC, 0xE420EE, 0xE420F9, 0xE4E5E0, 0xE5E020, 0xE5ED20, 0xE5EF20, 0xE5F820, 0xE5FA20, 0xE920E4, \n 0xE9E420, 0xE9E5FA, 0xE9E9ED, 0xE9ED20, 0xE9EF20, 0xE9F820, 0xE9FA20, 0xEC20E0, 0xEC20E4, 0xECE020, 0xECE420, 0xED20E0, 0xED20E1, 0xED20E4, 0xED20EC, 0xED20EE, \n 0xED20F9, 0xEEE420, 0xEF20E4, 0xF0E420, 0xF0E920, 0xF0E9ED, 0xF2EC20, 0xF820E4, 0xF8E9ED, 0xF9EC20, 0xFA20E0, 0xFA20E1, 0xFA20E4, 0xFA20EC, 0xFA20EE, 0xFA20F9, \n };\n\n public String getName()\n {\n return \"ISO-8859-8-I\";\n }\n\n public String getLanguage()\n {\n return \"he\";\n }\n \n public CharsetMatch match(CharsetDetector det) {\n String name = det.fC1Bytes ? \"windows-1255\" : \"ISO-8859-8-I\";\n int confidence = match(det, ngrams, byteMap);\n return confidence == 0 ? null : new CharsetMatch(det, confidence, name, \"he\");\n }\n }\n \n static class CharsetRecog_8859_8_he extends CharsetRecog_8859_8\n {\n private static final int[] ngrams = {\n 0x20E0E5, 0x20E0EC, 0x20E4E9, 0x20E4EC, 0x20E4EE, 0x20E4F0, 0x20E9F0, 0x20ECF2, 0x20ECF9, 0x20EDE5, 0x20EDE9, 0x20EFE5, 0x20EFE9, 0x20F8E5, 0x20F8E9, 0x20FAE0, \n 0x20FAE5, 0x20FAE9, 0xE020E4, 0xE020EC, 0xE020ED, 0xE020FA, 0xE0E420, 0xE0E5E4, 0xE0EC20, 0xE0EE20, 0xE120E4, 0xE120ED, 0xE120FA, 0xE420E4, 0xE420E9, 0xE420EC, \n 0xE420ED, 0xE420EF, 0xE420F8, 0xE420FA, 0xE4EC20, 0xE5E020, 0xE5E420, 0xE7E020, 0xE9E020, 0xE9E120, 0xE9E420, 0xEC20E4, 0xEC20ED, 0xEC20FA, 0xECF220, 0xECF920, \n 0xEDE9E9, 0xEDE9F0, 0xEDE9F8, 0xEE20E4, 0xEE20ED, 0xEE20FA, 0xEEE120, 0xEEE420, 0xF2E420, 0xF920E4, 0xF920ED, 0xF920FA, 0xF9E420, 0xFAE020, 0xFAE420, 0xFAE5E9, \n };\n\n public String getLanguage()\n {\n return \"he\";\n }\n \n public CharsetMatch match(CharsetDetector det)\n {\n String name = det.fC1Bytes ? \"windows-1255\" : \"ISO-8859-8\";\n int confidence = match(det, ngrams, byteMap);\n return confidence == 0 ? null : new CharsetMatch(det, confidence, name, \"he\");\n\n }\n }\n \n abstract static class CharsetRecog_8859_9 extends CharsetRecog_sbcs\n {\n protected static byte[] byteMap = {\n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x00, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, \n (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, \n (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, \n (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, \n (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0xAA, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0xB5, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0xBA, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0xE0, (byte) 0xE1, (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, \n (byte) 0xE8, (byte) 0xE9, (byte) 0xEA, (byte) 0xEB, (byte) 0xEC, (byte) 0xED, (byte) 0xEE, (byte) 0xEF, \n (byte) 0xF0, (byte) 0xF1, (byte) 0xF2, (byte) 0xF3, (byte) 0xF4, (byte) 0xF5, (byte) 0xF6, (byte) 0x20, \n (byte) 0xF8, (byte) 0xF9, (byte) 0xFA, (byte) 0xFB, (byte) 0xFC, (byte) 0x69, (byte) 0xFE, (byte) 0xDF, \n (byte) 0xE0, (byte) 0xE1, (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, \n (byte) 0xE8, (byte) 0xE9, (byte) 0xEA, (byte) 0xEB, (byte) 0xEC, (byte) 0xED, (byte) 0xEE, (byte) 0xEF, \n (byte) 0xF0, (byte) 0xF1, (byte) 0xF2, (byte) 0xF3, (byte) 0xF4, (byte) 0xF5, (byte) 0xF6, (byte) 0x20, \n (byte) 0xF8, (byte) 0xF9, (byte) 0xFA, (byte) 0xFB, (byte) 0xFC, (byte) 0xFD, (byte) 0xFE, (byte) 0xFF, \n };\n\n public String getName()\n {\n return \"ISO-8859-9\";\n }\n }\n \n static class CharsetRecog_8859_9_tr extends CharsetRecog_8859_9\n {\n private static final int[] ngrams = {\n 0x206261, 0x206269, 0x206275, 0x206461, 0x206465, 0x206765, 0x206861, 0x20696C, 0x206B61, 0x206B6F, 0x206D61, 0x206F6C, 0x207361, 0x207461, 0x207665, 0x207961, \n 0x612062, 0x616B20, 0x616C61, 0x616D61, 0x616E20, 0x616EFD, 0x617220, 0x617261, 0x6172FD, 0x6173FD, 0x617961, 0x626972, 0x646120, 0x646520, 0x646920, 0x652062, \n 0x65206B, 0x656469, 0x656E20, 0x657220, 0x657269, 0x657369, 0x696C65, 0x696E20, 0x696E69, 0x697220, 0x6C616E, 0x6C6172, 0x6C6520, 0x6C6572, 0x6E2061, 0x6E2062, \n 0x6E206B, 0x6E6461, 0x6E6465, 0x6E6520, 0x6E6920, 0x6E696E, 0x6EFD20, 0x72696E, 0x72FD6E, 0x766520, 0x796120, 0x796F72, 0xFD6E20, 0xFD6E64, 0xFD6EFD, 0xFDF0FD, \n };\n\n public String getLanguage()\n {\n return \"tr\";\n }\n \n public CharsetMatch match(CharsetDetector det)\n {\n String name = det.fC1Bytes ? \"windows-1254\" : \"ISO-8859-9\";\n int confidence = match(det, ngrams, byteMap);\n return confidence == 0 ? null : new CharsetMatch(det, confidence, name, \"tr\");\n }\n }\n \n static class CharsetRecog_windows_1251 extends CharsetRecog_sbcs\n {\n private static final int[] ngrams = {\n // ' в ' ' во' ' до' ' за' ' и ' ' ка' ' ко' ' на' ' не' ' об' ' по' ' пр' ' ра' ' со' ' ст' ' то'\n 0x20E220, 0x20E2EE, 0x20E4EE, 0x20E7E0, 0x20E820, 0x20EAE0, 0x20EAEE, 0x20EDE0, 0x20EDE5, 0x20EEE1, 0x20EFEE, 0x20EFF0, 0x20F0E0, 0x20F1EE, 0x20F1F2, 0x20F2EE,\n // ' чт' ' эт' 'ани' 'ать' 'го ' 'ель' 'ени' 'ест' 'ет ' 'и п' 'ие ' 'ии ' 'ия ' 'лен' 'ли ' 'льн'\n 0x20F7F2, 0x20FDF2, 0xE0EDE8, 0xE0F2FC, 0xE3EE20, 0xE5EBFC, 0xE5EDE8, 0xE5F1F2, 0xE5F220, 0xE820EF, 0xE8E520, 0xE8E820, 0xE8FF20, 0xEBE5ED, 0xEBE820, 0xEBFCED,\n // 'на ' 'не ' 'ние' 'ния' 'но ' 'нов' 'о в' 'о п' 'о с' 'ов ' 'ова' 'ого' 'ой ' 'оль' 'ом ' 'ост'\n 0xEDE020, 0xEDE520, 0xEDE8E5, 0xEDE8FF, 0xEDEE20, 0xEDEEE2, 0xEE20E2, 0xEE20EF, 0xEE20F1, 0xEEE220, 0xEEE2E0, 0xEEE3EE, 0xEEE920, 0xEEEBFC, 0xEEEC20, 0xEEF1F2,\n // 'пол' 'пре' 'при' 'про' 'рав' 'ред' 'ста' 'ств' 'сти' 'ся ' 'тел' 'то ' 'тор' 'ть ' 'что' 'ых '\n 0xEFEEEB, 0xEFF0E5, 0xEFF0E8, 0xEFF0EE, 0xF0E0E2, 0xF0E5E4, 0xF1F2E0, 0xF1F2E2, 0xF1F2E8, 0xF1FF20, 0xF2E5EB, 0xF2EE20, 0xF2EEF0, 0xF2FC20, 0xF7F2EE, 0xFBF520, \n };\n\n private static final byte[] byteMap = {\n/* -0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -A -B -C -D -E -F */\n/* 0- */ (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20,\n/* 1- */ (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20,\n/* 2- */ (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x00, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20,\n/* 3- */ (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20,\n/* 4- */ (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F,\n/* 5- */ (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20,\n/* 6- */ (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F,\n/* 7- */ (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20,\n/* 8- */ (byte) 0x90, (byte) 0x83, (byte) 0x20, (byte) 0x83, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x9A, (byte) 0x20, (byte) 0x9C, (byte) 0x9D, (byte) 0x9E, (byte) 0x9F,\n/* 9- */ (byte) 0x90, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0xA8, (byte) 0x20, (byte) 0x9A, (byte) 0x20, (byte) 0x9C, (byte) 0x9D, (byte) 0x9E, (byte) 0x9F,\n/* A- */ (byte) 0x20, (byte) 0xA2, (byte) 0xA2, (byte) 0xBC, (byte) 0x20, (byte) 0xB4, (byte) 0x20, (byte) 0x20, (byte) 0xA8, (byte) 0x20, (byte) 0xBA, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0xBF,\n/* B- */ (byte) 0x20, (byte) 0x20, (byte) 0xB3, (byte) 0xB3, (byte) 0xB4, (byte) 0xB5, (byte) 0x20, (byte) 0x20, (byte) 0xB8, (byte) 0x20, (byte) 0xBA, (byte) 0x20, (byte) 0xBC, (byte) 0xBE, (byte) 0xBE, (byte) 0xBF,\n/* C- */ (byte) 0xE0, (byte) 0xE1, (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, (byte) 0xE8, (byte) 0xE9, (byte) 0xEA, (byte) 0xEB, (byte) 0xEC, (byte) 0xED, (byte) 0xEE, (byte) 0xEF,\n/* D- */ (byte) 0xF0, (byte) 0xF1, (byte) 0xF2, (byte) 0xF3, (byte) 0xF4, (byte) 0xF5, (byte) 0xF6, (byte) 0xF7, (byte) 0xF8, (byte) 0xF9, (byte) 0xFA, (byte) 0xFB, (byte) 0xFC, (byte) 0xFD, (byte) 0xFE, (byte) 0xFF,\n/* E- */ (byte) 0xE0, (byte) 0xE1, (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, (byte) 0xE8, (byte) 0xE9, (byte) 0xEA, (byte) 0xEB, (byte) 0xEC, (byte) 0xED, (byte) 0xEE, (byte) 0xEF,\n/* F- */ (byte) 0xF0, (byte) 0xF1, (byte) 0xF2, (byte) 0xF3, (byte) 0xF4, (byte) 0xF5, (byte) 0xF6, (byte) 0xF7, (byte) 0xF8, (byte) 0xF9, (byte) 0xFA, (byte) 0xFB, (byte) 0xFC, (byte) 0xFD, (byte) 0xFE, (byte) 0xFF,\n };\n\n public String getName()\n {\n return \"windows-1251\";\n }\n \n public String getLanguage()\n {\n return \"ru\";\n }\n \n public CharsetMatch match(CharsetDetector det)\n {\n int confidence = match(det, ngrams, byteMap);\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n }\n \n static class CharsetRecog_windows_1256 extends CharsetRecog_sbcs\n {\n private static final int[] ngrams = {\n 0x20C7E1, 0x20C7E4, 0x20C8C7, 0x20DAE1, 0x20DDED, 0x20E1E1, 0x20E3E4, 0x20E6C7, 0xC720C7, 0xC7C120, 0xC7CA20, 0xC7D120, 0xC7E120, 0xC7E1C3, 0xC7E1C7, 0xC7E1C8, \n 0xC7E1CA, 0xC7E1CC, 0xC7E1CD, 0xC7E1CF, 0xC7E1D3, 0xC7E1DA, 0xC7E1DE, 0xC7E1E3, 0xC7E1E6, 0xC7E1ED, 0xC7E320, 0xC7E420, 0xC7E4CA, 0xC820C7, 0xC920C7, 0xC920DD, \n 0xC920E1, 0xC920E3, 0xC920E6, 0xCA20C7, 0xCF20C7, 0xCFC920, 0xD120C7, 0xD1C920, 0xD320C7, 0xDA20C7, 0xDAE1EC, 0xDDED20, 0xE120C7, 0xE1C920, 0xE1EC20, 0xE1ED20, \n 0xE320C7, 0xE3C720, 0xE3C920, 0xE3E420, 0xE420C7, 0xE520C7, 0xE5C720, 0xE6C7E1, 0xE6E420, 0xEC20C7, 0xED20C7, 0xED20E3, 0xED20E6, 0xEDC920, 0xEDD120, 0xEDE420, \n };\n\n private static final byte[] byteMap = {\n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x00, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, \n (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, \n (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, \n (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, \n (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x81, (byte) 0x20, (byte) 0x83, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x88, (byte) 0x20, (byte) 0x8A, (byte) 0x20, (byte) 0x9C, (byte) 0x8D, (byte) 0x8E, (byte) 0x8F, \n (byte) 0x90, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x98, (byte) 0x20, (byte) 0x9A, (byte) 0x20, (byte) 0x9C, (byte) 0x20, (byte) 0x20, (byte) 0x9F, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0xAA, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0xB5, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0xC0, (byte) 0xC1, (byte) 0xC2, (byte) 0xC3, (byte) 0xC4, (byte) 0xC5, (byte) 0xC6, (byte) 0xC7, \n (byte) 0xC8, (byte) 0xC9, (byte) 0xCA, (byte) 0xCB, (byte) 0xCC, (byte) 0xCD, (byte) 0xCE, (byte) 0xCF, \n (byte) 0xD0, (byte) 0xD1, (byte) 0xD2, (byte) 0xD3, (byte) 0xD4, (byte) 0xD5, (byte) 0xD6, (byte) 0x20, \n (byte) 0xD8, (byte) 0xD9, (byte) 0xDA, (byte) 0xDB, (byte) 0xDC, (byte) 0xDD, (byte) 0xDE, (byte) 0xDF, \n (byte) 0xE0, (byte) 0xE1, (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, \n (byte) 0xE8, (byte) 0xE9, (byte) 0xEA, (byte) 0xEB, (byte) 0xEC, (byte) 0xED, (byte) 0xEE, (byte) 0xEF, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0xF4, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0xF9, (byte) 0x20, (byte) 0xFB, (byte) 0xFC, (byte) 0x20, (byte) 0x20, (byte) 0xFF, \n };\n\n public String getName()\n {\n return \"windows-1256\";\n }\n \n public String getLanguage()\n {\n return \"ar\";\n }\n \n public CharsetMatch match(CharsetDetector det)\n {\n int confidence = match(det, ngrams, byteMap);\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n }\n \n static class CharsetRecog_KOI8_R extends CharsetRecog_sbcs\n {\n private static final int[] ngrams = {\n 0x20C4CF, 0x20C920, 0x20CBC1, 0x20CBCF, 0x20CEC1, 0x20CEC5, 0x20CFC2, 0x20D0CF, 0x20D0D2, 0x20D2C1, 0x20D3CF, 0x20D3D4, 0x20D4CF, 0x20D720, 0x20D7CF, 0x20DAC1, \n 0x20DCD4, 0x20DED4, 0xC1CEC9, 0xC1D4D8, 0xC5CCD8, 0xC5CEC9, 0xC5D3D4, 0xC5D420, 0xC7CF20, 0xC920D0, 0xC9C520, 0xC9C920, 0xC9D120, 0xCCC5CE, 0xCCC920, 0xCCD8CE, \n 0xCEC120, 0xCEC520, 0xCEC9C5, 0xCEC9D1, 0xCECF20, 0xCECFD7, 0xCF20D0, 0xCF20D3, 0xCF20D7, 0xCFC7CF, 0xCFCA20, 0xCFCCD8, 0xCFCD20, 0xCFD3D4, 0xCFD720, 0xCFD7C1, \n 0xD0CFCC, 0xD0D2C5, 0xD0D2C9, 0xD0D2CF, 0xD2C1D7, 0xD2C5C4, 0xD3D120, 0xD3D4C1, 0xD3D4C9, 0xD3D4D7, 0xD4C5CC, 0xD4CF20, 0xD4CFD2, 0xD4D820, 0xD9C820, 0xDED4CF, \n };\n\n private static final byte[] byteMap = {\n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x00, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, \n (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, \n (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, \n (byte) 0x68, (byte) 0x69, (byte) 0x6A, (byte) 0x6B, (byte) 0x6C, (byte) 0x6D, (byte) 0x6E, (byte) 0x6F, \n (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, \n (byte) 0x78, (byte) 0x79, (byte) 0x7A, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0xA3, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0xA3, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, \n (byte) 0xC0, (byte) 0xC1, (byte) 0xC2, (byte) 0xC3, (byte) 0xC4, (byte) 0xC5, (byte) 0xC6, (byte) 0xC7, \n (byte) 0xC8, (byte) 0xC9, (byte) 0xCA, (byte) 0xCB, (byte) 0xCC, (byte) 0xCD, (byte) 0xCE, (byte) 0xCF, \n (byte) 0xD0, (byte) 0xD1, (byte) 0xD2, (byte) 0xD3, (byte) 0xD4, (byte) 0xD5, (byte) 0xD6, (byte) 0xD7, \n (byte) 0xD8, (byte) 0xD9, (byte) 0xDA, (byte) 0xDB, (byte) 0xDC, (byte) 0xDD, (byte) 0xDE, (byte) 0xDF, \n (byte) 0xC0, (byte) 0xC1, (byte) 0xC2, (byte) 0xC3, (byte) 0xC4, (byte) 0xC5, (byte) 0xC6, (byte) 0xC7, \n (byte) 0xC8, (byte) 0xC9, (byte) 0xCA, (byte) 0xCB, (byte) 0xCC, (byte) 0xCD, (byte) 0xCE, (byte) 0xCF, \n (byte) 0xD0, (byte) 0xD1, (byte) 0xD2, (byte) 0xD3, (byte) 0xD4, (byte) 0xD5, (byte) 0xD6, (byte) 0xD7, \n (byte) 0xD8, (byte) 0xD9, (byte) 0xDA, (byte) 0xDB, (byte) 0xDC, (byte) 0xDD, (byte) 0xDE, (byte) 0xDF, \n };\n \n public String getName()\n {\n return \"KOI8-R\";\n }\n \n public String getLanguage()\n {\n return \"ru\";\n }\n \n public CharsetMatch match(CharsetDetector det)\n {\n int confidence = match(det, ngrams, byteMap);\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n }\n \n abstract static class CharsetRecog_IBM424_he extends CharsetRecog_sbcs\n {\n protected static byte[] byteMap = {\n/* -0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -A -B -C -D -E -F */\n/* 0- */ (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 1- */ (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 2- */ (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 3- */ (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 4- */ (byte) 0x40, (byte) 0x41, (byte) 0x42, (byte) 0x43, (byte) 0x44, (byte) 0x45, (byte) 0x46, (byte) 0x47, (byte) 0x48, (byte) 0x49, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 5- */ (byte) 0x40, (byte) 0x51, (byte) 0x52, (byte) 0x53, (byte) 0x54, (byte) 0x55, (byte) 0x56, (byte) 0x57, (byte) 0x58, (byte) 0x59, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 6- */ (byte) 0x40, (byte) 0x40, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, (byte) 0x68, (byte) 0x69, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 7- */ (byte) 0x40, (byte) 0x71, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x00, (byte) 0x40, (byte) 0x40, \n/* 8- */ (byte) 0x40, (byte) 0x81, (byte) 0x82, (byte) 0x83, (byte) 0x84, (byte) 0x85, (byte) 0x86, (byte) 0x87, (byte) 0x88, (byte) 0x89, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 9- */ (byte) 0x40, (byte) 0x91, (byte) 0x92, (byte) 0x93, (byte) 0x94, (byte) 0x95, (byte) 0x96, (byte) 0x97, (byte) 0x98, (byte) 0x99, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* A- */ (byte) 0xA0, (byte) 0x40, (byte) 0xA2, (byte) 0xA3, (byte) 0xA4, (byte) 0xA5, (byte) 0xA6, (byte) 0xA7, (byte) 0xA8, (byte) 0xA9, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* B- */ (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* C- */ (byte) 0x40, (byte) 0x81, (byte) 0x82, (byte) 0x83, (byte) 0x84, (byte) 0x85, (byte) 0x86, (byte) 0x87, (byte) 0x88, (byte) 0x89, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* D- */ (byte) 0x40, (byte) 0x91, (byte) 0x92, (byte) 0x93, (byte) 0x94, (byte) 0x95, (byte) 0x96, (byte) 0x97, (byte) 0x98, (byte) 0x99, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* E- */ (byte) 0x40, (byte) 0x40, (byte) 0xA2, (byte) 0xA3, (byte) 0xA4, (byte) 0xA5, (byte) 0xA6, (byte) 0xA7, (byte) 0xA8, (byte) 0xA9, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* F- */ (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n };\n\n public String getLanguage()\n {\n return \"he\";\n }\n }\n static class CharsetRecog_IBM424_he_rtl extends CharsetRecog_IBM424_he \n {\n public String getName()\n {\n return \"IBM424_rtl\";\n }\n private static final int[] ngrams = {\n 0x404146, 0x404148, 0x404151, 0x404171, 0x404251, 0x404256, 0x404541, 0x404546, 0x404551, 0x404556, 0x404562, 0x404569, 0x404571, 0x405441, 0x405445, 0x405641, \n 0x406254, 0x406954, 0x417140, 0x454041, 0x454042, 0x454045, 0x454054, 0x454056, 0x454069, 0x454641, 0x464140, 0x465540, 0x465740, 0x466840, 0x467140, 0x514045, \n 0x514540, 0x514671, 0x515155, 0x515540, 0x515740, 0x516840, 0x517140, 0x544041, 0x544045, 0x544140, 0x544540, 0x554041, 0x554042, 0x554045, 0x554054, 0x554056, \n 0x554069, 0x564540, 0x574045, 0x584540, 0x585140, 0x585155, 0x625440, 0x684045, 0x685155, 0x695440, 0x714041, 0x714042, 0x714045, 0x714054, 0x714056, 0x714069, \n };\n public CharsetMatch match(CharsetDetector det)\n {\n int confidence = match(det, ngrams, byteMap, (byte)0x40);\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n }\n static class CharsetRecog_IBM424_he_ltr extends CharsetRecog_IBM424_he \n {\n public String getName()\n {\n return \"IBM424_ltr\";\n }\n private static final int[] ngrams = {\n 0x404146, 0x404154, 0x404551, 0x404554, 0x404556, 0x404558, 0x405158, 0x405462, 0x405469, 0x405546, 0x405551, 0x405746, 0x405751, 0x406846, 0x406851, 0x407141,\n 0x407146, 0x407151, 0x414045, 0x414054, 0x414055, 0x414071, 0x414540, 0x414645, 0x415440, 0x415640, 0x424045, 0x424055, 0x424071, 0x454045, 0x454051, 0x454054,\n 0x454055, 0x454057, 0x454068, 0x454071, 0x455440, 0x464140, 0x464540, 0x484140, 0x514140, 0x514240, 0x514540, 0x544045, 0x544055, 0x544071, 0x546240, 0x546940,\n 0x555151, 0x555158, 0x555168, 0x564045, 0x564055, 0x564071, 0x564240, 0x564540, 0x624540, 0x694045, 0x694055, 0x694071, 0x694540, 0x714140, 0x714540, 0x714651\n\n };\n public CharsetMatch match(CharsetDetector det)\n {\n int confidence = match(det, ngrams, byteMap, (byte)0x40);\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n }\n \n abstract static class CharsetRecog_IBM420_ar extends CharsetRecog_sbcs\n {\n\n protected static byte[] byteMap = {\n/* -0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -A -B -C -D -E -F */\n/* 0- */ (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 1- */ (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 2- */ (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 3- */ (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 4- */ (byte) 0x40, (byte) 0x40, (byte) 0x42, (byte) 0x43, (byte) 0x44, (byte) 0x45, (byte) 0x46, (byte) 0x47, (byte) 0x48, (byte) 0x49, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 5- */ (byte) 0x40, (byte) 0x51, (byte) 0x52, (byte) 0x40, (byte) 0x40, (byte) 0x55, (byte) 0x56, (byte) 0x57, (byte) 0x58, (byte) 0x59, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 6- */ (byte) 0x40, (byte) 0x40, (byte) 0x62, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, (byte) 0x68, (byte) 0x69, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 7- */ (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, (byte) 0x78, (byte) 0x79, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, \n/* 8- */ (byte) 0x80, (byte) 0x81, (byte) 0x82, (byte) 0x83, (byte) 0x84, (byte) 0x85, (byte) 0x86, (byte) 0x87, (byte) 0x88, (byte) 0x89, (byte) 0x8A, (byte) 0x8B, (byte) 0x8C, (byte) 0x8D, (byte) 0x8E, (byte) 0x8F, \n/* 9- */ (byte) 0x90, (byte) 0x91, (byte) 0x92, (byte) 0x93, (byte) 0x94, (byte) 0x95, (byte) 0x96, (byte) 0x97, (byte) 0x98, (byte) 0x99, (byte) 0x9A, (byte) 0x9B, (byte) 0x9C, (byte) 0x9D, (byte) 0x9E, (byte) 0x9F, \n/* A- */ (byte) 0xA0, (byte) 0x40, (byte) 0xA2, (byte) 0xA3, (byte) 0xA4, (byte) 0xA5, (byte) 0xA6, (byte) 0xA7, (byte) 0xA8, (byte) 0xA9, (byte) 0xAA, (byte) 0xAB, (byte) 0xAC, (byte) 0xAD, (byte) 0xAE, (byte) 0xAF, \n/* B- */ (byte) 0xB0, (byte) 0xB1, (byte) 0xB2, (byte) 0xB3, (byte) 0xB4, (byte) 0xB5, (byte) 0x40, (byte) 0x40, (byte) 0xB8, (byte) 0xB9, (byte) 0xBA, (byte) 0xBB, (byte) 0xBC, (byte) 0xBD, (byte) 0xBE, (byte) 0xBF, \n/* C- */ (byte) 0x40, (byte) 0x81, (byte) 0x82, (byte) 0x83, (byte) 0x84, (byte) 0x85, (byte) 0x86, (byte) 0x87, (byte) 0x88, (byte) 0x89, (byte) 0x40, (byte) 0xCB, (byte) 0x40, (byte) 0xCD, (byte) 0x40, (byte) 0xCF, \n/* D- */ (byte) 0x40, (byte) 0x91, (byte) 0x92, (byte) 0x93, (byte) 0x94, (byte) 0x95, (byte) 0x96, (byte) 0x97, (byte) 0x98, (byte) 0x99, (byte) 0xDA, (byte) 0xDB, (byte) 0xDC, (byte) 0xDD, (byte) 0xDE, (byte) 0xDF, \n/* E- */ (byte) 0x40, (byte) 0x40, (byte) 0xA2, (byte) 0xA3, (byte) 0xA4, (byte) 0xA5, (byte) 0xA6, (byte) 0xA7, (byte) 0xA8, (byte) 0xA9, (byte) 0xEA, (byte) 0xEB, (byte) 0x40, (byte) 0xED, (byte) 0xEE, (byte) 0xEF, \n/* F- */ (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0x40, (byte) 0xFB, (byte) 0xFC, (byte) 0xFD, (byte) 0xFE, (byte) 0x40, \n };\n \n\n public String getLanguage()\n {\n return \"ar\";\n }\n \n }\n static class CharsetRecog_IBM420_ar_rtl extends CharsetRecog_IBM420_ar \n {\n private static final int[] ngrams = {\n 0x4056B1, 0x4056BD, 0x405856, 0x409AB1, 0x40ABDC, 0x40B1B1, 0x40BBBD, 0x40CF56, 0x564056, 0x564640, 0x566340, 0x567540, 0x56B140, 0x56B149, 0x56B156, 0x56B158,\n 0x56B163, 0x56B167, 0x56B169, 0x56B173, 0x56B178, 0x56B19A, 0x56B1AD, 0x56B1BB, 0x56B1CF, 0x56B1DC, 0x56BB40, 0x56BD40, 0x56BD63, 0x584056, 0x624056, 0x6240AB,\n 0x6240B1, 0x6240BB, 0x6240CF, 0x634056, 0x734056, 0x736240, 0x754056, 0x756240, 0x784056, 0x9A4056, 0x9AB1DA, 0xABDC40, 0xB14056, 0xB16240, 0xB1DA40, 0xB1DC40,\n 0xBB4056, 0xBB5640, 0xBB6240, 0xBBBD40, 0xBD4056, 0xBF4056, 0xBF5640, 0xCF56B1, 0xCFBD40, 0xDA4056, 0xDC4056, 0xDC40BB, 0xDC40CF, 0xDC6240, 0xDC7540, 0xDCBD40,\n };\n\n public String getName()\n {\n return \"IBM420_rtl\";\n }\n public CharsetMatch match(CharsetDetector det)\n {\n int confidence = matchIBM420(det, ngrams, byteMap, (byte)0x40);\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n \n }\n static class CharsetRecog_IBM420_ar_ltr extends CharsetRecog_IBM420_ar \n {\n private static final int[] ngrams = {\n 0x404656, 0x4056BB, 0x4056BF, 0x406273, 0x406275, 0x4062B1, 0x4062BB, 0x4062DC, 0x406356, 0x407556, 0x4075DC, 0x40B156, 0x40BB56, 0x40BD56, 0x40BDBB, 0x40BDCF, \n 0x40BDDC, 0x40DAB1, 0x40DCAB, 0x40DCB1, 0x49B156, 0x564056, 0x564058, 0x564062, 0x564063, 0x564073, 0x564075, 0x564078, 0x56409A, 0x5640B1, 0x5640BB, 0x5640BD,\n 0x5640BF, 0x5640DA, 0x5640DC, 0x565840, 0x56B156, 0x56CF40, 0x58B156, 0x63B156, 0x63BD56, 0x67B156, 0x69B156, 0x73B156, 0x78B156, 0x9AB156, 0xAB4062, 0xADB156,\n 0xB14062, 0xB15640, 0xB156CF, 0xB19A40, 0xB1B140, 0xBB4062, 0xBB40DC, 0xBBB156, 0xBD5640, 0xBDBB40, 0xCF4062, 0xCF40DC, 0xCFB156, 0xDAB19A, 0xDCAB40, 0xDCB156\n };\n\n public String getName()\n {\n return \"IBM420_ltr\";\n }\n public CharsetMatch match(CharsetDetector det)\n {\n int confidence = matchIBM420(det, ngrams, byteMap, (byte)0x40);\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n \n }\n\n\n\n\n static class CharsetRecog_cp866 extends CharsetRecog_sbcs\n {\n private static final int[] ngrams = {\n // ' в ' ' во' ' до' ' за' ' и ' ' ка' ' ко' ' на' ' не' ' об' ' по' ' пр' ' ра' ' со' ' ст' ' то'\n 0x20A220, 0x20A2AE, 0x20A4AE, 0x20A7A0, 0x20A820, 0x20AAA0, 0x20AAAE, 0x20ADA0, 0x20ADA5, 0x20AEA1, 0x20AFAE, 0x20AFE0, 0x20E0A0, 0x20E1AE, 0x20E1E2, 0x20E2AE,\n // ' чт' ' эт' 'ани' 'ать' 'го ' 'ель' 'ени' 'ест' 'ет ' 'и п' 'ие ' 'ии ' 'ия ' 'лен' 'ли ' 'льн'\n 0x20E7E2, 0x20EDE2, 0xA0ADA8, 0xA0E2EC, 0xA3AE20, 0xA5ABEC, 0xA5ADA8, 0xA5E1E2, 0xA5E220, 0xA820AF, 0xA8A520, 0xA8A820, 0xA8EF20, 0xABA5AD, 0xABA820, 0xABECAD,\n // 'на ' 'не ' 'ние' 'ния' 'но ' 'нов' 'о в' 'о п' 'о с' 'ов ' 'ова' 'ого' 'ой ' 'оль' 'ом ' 'ост'\n 0xADA020, 0xADA520, 0xADA8A5, 0xADA8EF, 0xADAE20, 0xADAEA2, 0xAE20A2, 0xAE20AF, 0xAE20E1, 0xAEA220, 0xAEA2A0, 0xAEA3AE, 0xAEA920, 0xAEABEC, 0xAEAC20, 0xAEE1E2,\n // 'пол' 'пре' 'при' 'про' 'рав' 'ред' 'ста' 'ств' 'сти' 'ся ' 'тел' 'то ' 'тор' 'ть ' 'что' 'ых '\n 0xAFAEAB, 0xAFE0A5, 0xAFE0A8, 0xAFE0AE, 0xE0A0A2, 0xE0A5A4, 0xE1E2A0, 0xE1E2A2, 0xE1E2A8, 0xE1EF20, 0xE2A5AB, 0xE2AE20, 0xE2AEE0, 0xE2EC20, 0xE7E2AE, 0xEBE520\n };\n\n private static final byte[] byteMap = {\n/* -0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -A -B -C -D -E -F */\n/* 0- */ (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20,\n/* 1- */ (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20,\n/* 2- */ (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x00, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20,\n/* 3- */ (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20,\n/* 4- */ (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20,\n/* 5- */ (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20,\n/* 6- */ (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20,\n/* 7- */ (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20,\n/* 8- */ (byte) 0xA0, (byte) 0xA1, (byte) 0xA2, (byte) 0xA3, (byte) 0xA4, (byte) 0xA5, (byte) 0xA6, (byte) 0xA7, (byte) 0xA8, (byte) 0xA9, (byte) 0xAA, (byte) 0xAB, (byte) 0xAC, (byte) 0xAD, (byte) 0xAE, (byte) 0xAF,\n/* 9- */ (byte) 0xE0, (byte) 0xE1, (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, (byte) 0xE8, (byte) 0xE9, (byte) 0xEA, (byte) 0xEB, (byte) 0xEC, (byte) 0xED, (byte) 0xEE, (byte) 0xEF,\n/* A- */ (byte) 0xA0, (byte) 0xA1, (byte) 0xA2, (byte) 0xA3, (byte) 0xA4, (byte) 0xA5, (byte) 0xA6, (byte) 0xA7, (byte) 0xA8, (byte) 0xA9, (byte) 0xAA, (byte) 0xAB, (byte) 0xAC, (byte) 0xAD, (byte) 0xAE, (byte) 0xAF,\n/* B- */ (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20,\n/* C- */ (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20,\n/* D- */ (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20,\n/* E- */ (byte) 0xE0, (byte) 0xE1, (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, (byte) 0xE8, (byte) 0xE9, (byte) 0xEA, (byte) 0xEB, (byte) 0xEC, (byte) 0xED, (byte) 0xEE, (byte) 0xEF,\n/* F- */ (byte) 0xF0, (byte) 0xF0, (byte) 0xF2, (byte) 0xF3, (byte) 0xF4, (byte) 0xF5, (byte) 0xF6, (byte) 0xF7, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20, (byte) 0x20,\n };\n\n public String getName()\n {\n return \"cp866\";\n }\n\n public String getLanguage()\n {\n return \"ru\";\n }\n\n public CharsetMatch match(CharsetDetector det)\n {\n int confidence = match(det, ngrams, byteMap);\n return confidence == 0 ? null : new CharsetMatch(det, this, confidence);\n }\n }\n\n}\n"
},
{
"path": "src/main/java/com/ibm/icu/text/CharsetRecognizer.java",
"content": "/*\n*******************************************************************************\n* Copyright (C) 2005-2012, International Business Machines Corporation and *\n* others. All Rights Reserved. *\n*******************************************************************************\n*/\npackage com.ibm.icu.text;\n\n/**\n * Abstract class for recognizing a single charset.\n * Part of the implementation of ICU's CharsetDetector.\n\n * Each specific charset that can be recognized will have an instance of some subclass of this class.\n * All interaction between the overall CharsetDetector and the stuff specific to an individual charset happens\n * via the interface provided here.\n\n * Instances of CharsetDetector DO NOT have or maintain state pertaining to a specific match or detect operation.\n * The WILL be shared by multiple instances of CharsetDetector. They encapsulate const charset-specific information.\n */\nabstract class CharsetRecognizer {\n /**\n * Get the IANA name of this charset.\n * @return the charset name.\n */\n abstract String getName();\n \n /**\n * Get the ISO language code for this charset.\n * @return the language code, or null if the language cannot be determined.\n */\n public String getLanguage()\n {\n return null;\n }\n \n /**\n * Test the match of this charset with the input text data\n * which is obtained via the CharsetDetector object.\n * \n * @param det The CharsetDetector, which contains the input text\n * to be checked for being in this charset.\n * @return A CharsetMatch object containing details of match\n * with this charset, or null if there was no match.\n */\n abstract CharsetMatch match(CharsetDetector det);\n\n}\n"
},
{
"path": "src/main/java/com/mucommander/PlatformManager.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see \n *
\n * ~/Library/Preferences/trolCommander/ under MAC OS X.~/.trolcommander/ under all other OSes.\n *
\n * ~/Library/Preferences/trolCommander/ under MAC OS X.~/.trolcommander/ under all other OSes.folder is a file, its parent folder will be used instead. If it doesn't exist,\n * this method will create it.\n *\n * @param folder path to the folder in which trolCommander will look for its preferences.\n * @throws IOException if an IO error occurs.\n * @see #getPreferencesFolder()\n * @see #setPreferencesFolder(String)\n * @see #setPreferencesFolder(AbstractFile)\n */\n public static void setPreferencesFolder(File folder) throws IOException {\n AbstractFile file = FileFactory.getFile(folder.getAbsolutePath());\n if (file != null) {\n setPreferencesFolder(file);\n }\n }\n\n /**\n * Sets the path to the folder in which trolCommander will look for its preferences.\n * folder is a file, its parent folder will be used instead. If it doesn't exist,\n * this method will create it.\n *\n * @param path path to the folder in which trolCommander will look for its preferences.\n * @throws IOException if an IO error occurs.\n * @see #getPreferencesFolder()\n * @see #setPreferencesFolder(File)\n * @see #setPreferencesFolder(AbstractFile)\n */\n public static void setPreferencesFolder(String path) throws IOException {\n AbstractFile folder = FileFactory.getFile(path);\n\n if (folder == null) {\n setPreferencesFolder(new File(path));\n } else {\n setPreferencesFolder(folder);\n }\n }\n\n /**\n * Sets the path to the folder in which trolCommander will look for its preferences.\n * folder is a file, its parent folder will be used instead. If it doesn't exist,\n * this method will create it.\n *\n * @param folder path to the folder in which trolCommander will look for its preferences.\n * @throws IOException if an IO error occurs.\n * @see #getPreferencesFolder()\n * @see #setPreferencesFolder(String)\n * @see #setPreferencesFolder(File)\n */\n public static void setPreferencesFolder(AbstractFile folder) throws IOException {\n if (!folder.exists()) {\n folder.mkdir();\n } else if (!folder.isBrowsable()) {\n folder = folder.getParent();\n }\n prefFolder = folder;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/RuntimeConstants.java",
"content": "/*\r\n * This file is part of trolCommander, http://www.trolsoft.ru/en/soft/trolcommander\r\n * Copyright (C) 2013-2020 Oleg Trifonov\r\n *\r\n * trolCommander is free software; you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation; either version 3 of the License, or\r\n * (at your option) any later version.\r\n *\r\n * trolCommander is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see MAJOR.MINOR.DEV). */\r\n public static final String VERSION;\r\n /** Date at which the build was generated (YYYYMMDD). */\r\n public static final String BUILD_DATE;\r\n /** Time at which the build was generated (HHMM). */\r\n public static final String BUILD_TIME;\r\n /** Copyright information (YYYY-YYYY). */\r\n public static final String COPYRIGHT;\r\n /** String describing the software (trolCommander vMAJOR.MINOR.DEV). */\r\n public static final String APP_STRING;\r\n /** String describing the trolCommander build number. */\r\n public static final String BUILD_NUMBER;\r\n /** YYYYMMDDHHmm */\r\n public static final String BUILD_CODE;\r\n\r\n \r\n\r\n static {\r\n Attributes attributes = getManifestAttributes();\r\n\r\n if (attributes == null) { // No MANIFEST.MF found, use default values.\r\n VERSION = \"?\";\r\n COPYRIGHT = \"2013-\" + Calendar.getInstance().get(Calendar.YEAR);\r\n // We use a date that we are sure is later than the latest version to trigger the version checker.\r\n // After all, the JAR appears to be corrupt and should be upgraded.\r\n BUILD_DATE = DEFAULT_RELEASE_DATE;\r\n BUILD_TIME = null;\r\n VERSION_URL = DEFAULT_VERSION_URL;\r\n BUILD_NUMBER = \"?\";\r\n BUILD_CODE = null;\r\n } else { // A MANIFEST.MF file was found, extract data from it.\r\n VERSION = getAttribute(attributes, \"Specification-Version\");\r\n BUILD_DATE = getAttribute(attributes, \"Build-Date\");\r\n BUILD_TIME = getAttribute(attributes, \"Build-Time\");\r\n VERSION_URL = getAttribute(attributes, \"Build-URL\");\r\n BUILD_NUMBER = getAttribute(attributes, \"Implementation-Version\");\r\n // Protection against corrupt manifest files.\r\n COPYRIGHT = BUILD_DATE.length() > 4 ? BUILD_DATE.substring(0, 4) : DEFAULT_RELEASE_DATE;\r\n BUILD_CODE = BUILD_DATE + BUILD_TIME;\r\n }\r\n APP_STRING = \"trolCommander v\" + VERSION;\r\n }\r\n\r\n @Nullable\r\n private static Attributes getManifestAttributes() {\r\n try (InputStream in = ResourceLoader.getResourceAsStream(\"META-INF/MANIFEST.MF\", ResourceLoader.getDefaultClassLoader(), ResourceLoader.getRootPackageAsFile(RuntimeConstants.class))) {\r\n if (in != null) {\r\n Manifest manifest = new Manifest();\r\n manifest.read(in);\r\n return manifest.getMainAttributes();\r\n }\r\n } catch (IOException e) {\r\n LOGGER.warn(\"Failed to read MANIFEST.MF, default values will be used\", e);\r\n }\r\n return null;\r\n }\r\n\r\n /**\r\n * Extract the requested attribute value.\r\n * @param attributes attributes from which to extract the requested value.\r\n * @param name name of the attribute to retrieve.\r\n * @return the requested attribute value.\r\n */\r\n private static String getAttribute(Attributes attributes, String name) {\r\n String buffer = attributes.getValue(name);\r\n return buffer == null ? \"?\" : buffer;\r\n }\r\n\r\n private static boolean is4KDisplay() {\r\n Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();\r\n return screenSize.width*screenSize.height > 3500*3500;\r\n }\r\n\r\n}\r\n"
},
{
"path": "src/main/java/com/mucommander/StressTester.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see Launcher.\r\n */\r\n private TrolCommander() {}\r\n\r\n\r\n /**\r\n * This method can be called to wait until the application has been launched. The caller thread will be blocked\r\n * until the application has been launched.\r\n * This method will return immediately if the application has already been launched when it is called.\r\n */\r\n public static void waitUntilLaunched() {\r\n getLogger().debug(\"called, thread {}\", Thread.currentThread());\r\n synchronized(LAUNCH_LOCK) {\r\n while (isLaunching) {\r\n try {\r\n getLogger().debug(\"waiting\");\r\n LAUNCH_LOCK.wait();\r\n } catch (InterruptedException e) {\r\n // will loop\r\n }\r\n }\r\n }\r\n }\r\n\r\n // - Boot code --------------------------------------------------------------\r\n // --------------------------------------------------------------------------\r\n /**\r\n * Method used to migrate commands that used to be defined in the configuration but were moved to commands.xml.\r\n * @param useName name of the use custom command configuration variable.\r\n * @param commandName name of the custom command configuration variable.\r\n */\r\n public static void migrateCommand(String useName, String commandName, String alias) {\r\n String command;\r\n\r\n if (TcConfigurations.getPreferences().getBooleanVariable(useName) && (command = TcConfigurations.getPreferences().getVariable(commandName)) != null) {\r\n CommandManager.registerCommand(new Command(alias, command, CommandType.SYSTEM_COMMAND));\r\n TcConfigurations.getPreferences().removeVariable(useName);\r\n TcConfigurations.getPreferences().removeVariable(commandName);\r\n }\r\n }\r\n\r\n\r\n /**\r\n * Main method used to startup muCommander.\r\n * @param args command line arguments.\r\n */\r\n public static void main(String[] args) {\r\n if (OsFamily.MAC_OS_X.isCurrent()) {\r\n System.setProperty(\"com.apple.mrj.application.apple.menu.about.name\", \"trolCommander\");\r\n\t\t\t// disable openGL in javaFX (used for HtmlViewer) as it cashes JVM under vmWare\r\n\t\t\tSystem.setProperty(\"prism.order\", \"sw\");\r\n }\r\n\r\n Profiler.start(\"init\");\r\n Profiler.start(\"loading\");\r\n\r\n int processors = Runtime.getRuntime().availableProcessors();\r\n System.out.println(\"Current OS family: \" + OsFamily.getCurrent());\r\n System.out.println(\"Processors: \" + processors);\r\n\r\n try (LauncherExecutor executor = new LauncherExecutor(processors <= 0 ? 1 : processors)) {\r\n LauncherCmdHelper helper = new LauncherCmdHelper(args, true, false);\r\n // Whether, or not to ignore warnings when booting.\r\n helper.parseArgs();\r\n\r\n ListAndroidMenu.\n */\n public AndroidMenu() {\n super(Translator.get(\"adb.android_devices\"));\n\n setIcon(IconManager.getIcon(IconManager.IconSet.FILE, \"android.png\"));\n\n // Menu items will be added when menu gets selected\n addMenuListener(this);\n }\n\n /**\n * Returns the action to perform for the given item.\n *\n * @param deviceSerial the serial number of the device\n * @return the action to perform for the given Android device\n */\n public abstract TcAction getMenuItemAction(String deviceSerial);\n\n\n @Override\n public void menuSelected(MenuEvent e) {\n // Remove previous menu items (if any)\n removeAll();\n\n List\n *
\n *\n * @author Maxence Bernard\n */\npublic class CredentialsManager {\n\tprivate static Logger logger;\n\t\n /** Contains volatile CredentialsMapping instances, lost when the application terminates */\n private static final Listpath is not available.\n */\n public static void setCredentialsFile(String path) throws FileNotFoundException {\n AbstractFile file = FileFactory.getFile(path);\n\n if (file == null) {\n setCredentialsFile(new File(path));\n } else {\n setCredentialsFile(file);\n }\n }\n\n /**\n * Sets the path to the credentials file.\n *\n * @param file path to the credentials file\n * @throws FileNotFoundException if path is not available.\n */\n public static void setCredentialsFile(File file) throws FileNotFoundException {\n setCredentialsFile(FileFactory.getFile(file.getAbsolutePath()));\n }\n\n /**\n * Sets the path to the credentials file.\n *\n * @param file path to the credentials file\n * @throws FileNotFoundException if path is not available.\n */\n public static void setCredentialsFile(AbstractFile file) throws FileNotFoundException {\n if (file.isBrowsable()) {\n throw new FileNotFoundException(\"Not a valid file: \" + file);\n }\n credentialsFile = file;\n }\n\n /**\n * Tries to load credentials from the credentials file if it exists. Does nothing if it doesn't.\n *\n * @throws Exception if an error occurs while loading the credentials file.\n */\n public static void loadCredentials() throws Exception {\n AbstractFile credentialsFile = getCredentialsFile();\n if (credentialsFile.exists()) {\n getLogger().debug(\"Found credentials file: \"+credentialsFile.getAbsolutePath());\n // Parse the credentials file\n new CredentialsParser().parse(credentialsFile);\n getLogger().debug(\"Credentials file loaded.\");\n } else {\n getLogger().debug(\"No credentials file found at \" + credentialsFile.getAbsolutePath());\n }\n }\n\n /**\n * Tries to write the credentials file. Unless the 'forceWrite' is set to true, the credentials file will be written\n * only if changes were made to persistent entries since last write.\n *\n * @param forceWrite if false, the credentials file will be written only if changes were made to persistent entries\n * since last write, if true the file will always be written.\n * @throws IOException if an I/O error occurs.\n */\n public static void writeCredentials(boolean forceWrite) throws IOException {\n // Write credentials file only if changes were made to persistent entries since last write, or if write is forced\n if (!(forceWrite || saveNeeded)) {\n return;\n }\n\n BackupOutputStream out = null;\n try {\n credentialsFile = getCredentialsFile();\n CredentialsWriter.write(out = new BackupOutputStream(credentialsFile));\n saveNeeded = false;\n } finally {\n if (out != null) {\n // TODO autoclosable\n try {\n out.close();\n } catch(Exception ignore) {}\n }\n }\n\n // Under UNIX-based systems, change the credentials file's permissions so that the file can't be read by\n // 'group' and 'other'.\n boolean fileSecured = !OsFamily.getCurrent().isUnixBased() || Chmod.chmod(credentialsFile, 0600); // rw-------\n\n if (fileSecured) {\n getLogger().debug(\"Credentials file saved successfully.\");\n } else {\n getLogger().warn(\"Credentials file could not be chmod!\");\n }\n }\n\n\n /**\n * Returns an array of {@link CredentialsMapping} that match the location designated by the given {@link FileURL}\n * and which can be used to authenticate. The location is compared against all known credentials, both volatile and\n * persistent.\n *\n * CredentialsMapping to authenticate the\n * given {@link FileURL}.\n\n * FileURL will be lost and replaced with the new ones.\n * If properties with the same key are defined both in the realm and the given FileURL, the ones from the FileURL\n * will be preserved.\n *\n * @param location the FileURL to authenticate\n * @param credentialsMapping the credentials to use to authenticate the given FileURL\n */\n public static void authenticate(FileURL location, CredentialsMapping credentialsMapping) {\n location.setCredentials(credentialsMapping.getCredentials());\n\n FileURL realm = credentialsMapping.getRealm();\n Settrue if a set of credentials was found and used to authenticate the URL, false\n * otherwise.\n *\n * Vector, preserving its position. If the\n * vector contains no such object, it is added to the end of the vector.\n *\n * @param list the List to replace/add the object to\n * @param o the object to replace/add\n */\n private static void replaceListElement(Listtrue if these credentials should be saved when the application terminates.\n *\n * @return true if these credentials should be saved when the application terminates, false otherwise.\n */\n public boolean isPersistent() {\n return isPersistent;\n }\n\n\n /**\n * Returns true if the given Object is a {@link com.mucommander.auth.CredentialsMapping} instance\n * whose credentials and realm are equals to those of this instance.\n *\n * @param o the Object to test for equality\n * @return true if both CredentialsMapping instances are equal\n */\n @Override\n public boolean equals(Object o) {\n if (!(o instanceof CredentialsMapping cm)) { // Note: CredentialsMapping is final, no need to test classes\n return false;\n }\n return cm.credentials.equals(this.credentials, false) && cm.realm.equals(this.realm, false, true);\n }\n\n @Override\n public String toString() {\n return credentials.toString()+\" \"+realm.toString(false);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/auth/CredentialsParser.java",
"content": "/*\r\n * This file is part of muCommander, http://www.mucommander.com\r\n * Copyright (C) 2002-2012 Maxence Bernard\r\n *\r\n * muCommander is free software; you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation; either version 3 of the License, or\r\n * (at your option) any later version.\r\n *\r\n * muCommander is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see null if it is unknown.\r\n * null if it is unknown.\r\n */\r\n public String getVersion() {\r\n return version;\r\n }\r\n\r\n\r\n ///////////////////////////////////\r\n // ContentHandler implementation //\r\n ///////////////////////////////////\r\n\r\n @Override\r\n public void startElement(String uri, String localName, String qName, Attributes attributes) {\r\n characters.setLength(0);\r\n\r\n switch (qName) {\r\n case ELEMENT_CREDENTIALS:\r\n // Reset parsing variables\r\n url = null;\r\n urlProperties = null;\r\n login = null;\r\n password = null;\r\n break;\r\n // Property element (properties will be set when credentials element ends\r\n case ELEMENT_PROPERTY:\r\n if (urlProperties == null)\r\n urlProperties = new Hashtable<>();\r\n urlProperties.put(attributes.getValue(ATTRIBUTE_NAME), attributes.getValue(ATTRIBUTE_VALUE));\r\n break;\r\n // Root element, the 'encryption' attribute specifies which encoding was used to encrypt passwords\r\n case ELEMENT_ROOT:\r\n encryptionMethod = attributes.getValue(\"encryption\");\r\n version = attributes.getValue(ATTRIBUTE_VERSION);\r\n break;\r\n }\r\n }\r\n\r\n @Override\r\n public void endElement(String uri, String localName, String qName) {\r\n switch (qName) {\r\n case ELEMENT_CREDENTIALS:\r\n if (url == null || login == null || password == null) {\r\n getLogger().info(\"Missing value, credentials ignored: url=\" + url + \" login=\" + login);\r\n return;\r\n }\r\n\r\n // Copy properties into FileURL instance (if any)\r\n if (urlProperties != null) {\r\n for (String key : urlProperties.keySet())\r\n url.setProperty(key, urlProperties.get(key));\r\n }\r\n\r\n // Decrypt password\r\n try {\r\n password = XORCipher.decryptXORBase64(password);\r\n } catch (IOException e) {\r\n getLogger().info(\"Password could not be decrypted: \" + password + \", credentials will be ignored\");\r\n return;\r\n }\r\n\r\n // Add credentials to persistent credentials list\r\n CredentialsManager.getPersistentCredentialMappings().add(new CredentialsMapping(new Credentials(login, password), url, true));\r\n break;\r\n case ELEMENT_URL:\r\n try {\r\n url = FileURL.getFileURL(characters.toString().trim());\r\n } catch (MalformedURLException e) {\r\n getLogger().info(\"Malformed URL: \" + characters + \", location will be ignored\");\r\n }\r\n break;\r\n case ELEMENT_LOGIN:\r\n login = characters.toString().trim();\r\n break;\r\n case ELEMENT_PASSWORD:\r\n password = characters.toString().trim();\r\n break;\r\n }\r\n }\r\n\r\n @Override\r\n public void characters(char[] ch, int offset, int length) {\r\n characters.append(ch, offset, length);\r\n }\r\n\r\n\r\n private static Logger getLogger() {\r\n if (logger == null) {\r\n logger = LoggerFactory.getLogger(CredentialsParser.class);\r\n }\r\n return logger;\r\n }\r\n}\r\n"
},
{
"path": "src/main/java/com/mucommander/auth/CredentialsWriter.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see true if Bonjour services discovery is currently running.\n * @return true if Bonjour services discovery is currently running, false otherwise.\n */\n public static boolean isActive() {\n return jmDNS != null;\n }\n\n\n /**\n * Returns all currently available Bonjour services. The returned array may be empty but never null.\n * If BonjourDirectory is not currently active ({@link #isActive()}, an empty array will be returned.\n * @return all currently available Bonjour services\n */\n public static BonjourService[] getServices() {\n BonjourService[] servicesArray = new BonjourService[services.size()];\n services.toArray(servicesArray);\n return servicesArray;\n }\n\n\n /**\n * Wraps a Bonjour service into a {@link BonjourService} object and returns it. Returns null if\n * the service type doesn't correspond to any of the supported protocols, or if the service URL is malformed.\n *\n * @param serviceInfo the ServiceInfo to wrap into a BonjourService\n * @return a BonjourService instance corresponding to the given ServiceInfo\n */\n private static BonjourService createBonjourService(ServiceInfo serviceInfo) {\n try {\n String type = serviceInfo.getType();\n // Looks for the file protocol corresponding to the service type\n for (String[] KNOWN_SERVICE_TYPE : KNOWN_SERVICE_TYPES) {\n if (KNOWN_SERVICE_TYPE[0].equals(type)) {\n return new BonjourService(serviceInfo.getName(), FileURL.getFileURL(serviceInfo.getURL(KNOWN_SERVICE_TYPE[1])), serviceInfo.getQualifiedName());\n }\n }\n } catch (MalformedURLException e) {\n // Null will be returned\n }\n\n return null;\n }\n\n\n ////////////////////////////////////\n // ServiceListener implementation //\n ////////////////////////////////////\n\n public void serviceAdded(final ServiceEvent serviceEvent) {\n getLogger().trace(\"name=\"+serviceEvent.getName()+\" type=\"+serviceEvent.getType());\n \n // Ignore if Bonjour has been disabled\n if (!isActive()) {\n return;\n }\n // Resolve service info in a separate thread, serviceResolved() will be called once service info has been resolved.\n // Not spawning a thread often leads to service info loss (serviceResolved() not called).\n new Thread(() -> jmDNS.requestServiceInfo(serviceEvent.getType(), serviceEvent.getName(), SERVICE_RESOLUTION_TIMEOUT)).start();\n }\n\n public void serviceResolved(ServiceEvent serviceEvent) {\n getLogger().trace(\"name=\"+serviceEvent.getName()+\" type=\"+serviceEvent.getType()+\" info=\"+serviceEvent.getInfo());\n\n // Ignore if Bonjour has been disabled\n if (!isActive())\n return;\n\n // Creates a new BonjourService corresponding to the new service and add it to the list of current Bonjour services\n ServiceInfo serviceInfo = serviceEvent.getInfo();\n if(serviceInfo!=null) {\n if(serviceInfo.getInetAddress() instanceof Inet6Address) {\n // IPv6 addresses not supported at this time + they seem not to be correctly handled by ServiceInfo\n getLogger().debug(\"ignoring IPv6 service\");\n return;\n }\n\n BonjourService bs = createBonjourService(serviceInfo);\n // Synchronized to properly handle duplicate calls\n synchronized(instance) {\n if(bs!=null && !services.contains(bs)) {\n getLogger().debug(\"BonjourService \"+bs+\" added\");\n services.add(bs);\n }\n }\n }\n }\n\n public void serviceRemoved(ServiceEvent serviceEvent) {\n getLogger().trace(\"name=\"+serviceEvent.getName()+\" type=\"+serviceEvent.getType());\n\n // Ignore if Bonjour has been disabled\n if(!isActive())\n return;\n\n // Looks for an existing BonjourService instance corresponding to the service being removed and removes it from\n // the list of current Bonjour services.\n // ServiceInfo should be available in JmDNS's cache.\n ServiceInfo serviceInfo = jmDNS.getServiceInfo(serviceEvent.getType(), serviceEvent.getName()); \n if (serviceInfo != null) {\n if(serviceInfo.getInetAddress() instanceof Inet6Address) {\n // IPv6 addresses not supported at this time + they seem not to be correctly handled by ServiceInfo\n getLogger().debug(\"ignoring IPv6 service\");\n return;\n }\n\n BonjourService bs = createBonjourService(serviceInfo);\n // Synchronized to properly handle duplicate calls\n synchronized(instance) {\n // Note: BonjourService#equals() uses the service's fully qualified name as the discriminator.\n if (bs != null && services.contains(bs)) {\n getLogger().debug(\"BonjourService \"+bs+\" removed\");\n services.remove(bs);\n }\n }\n }\n }\n\n private static Logger getLogger() {\n if (logger == null) {\n logger = LoggerFactory.getLogger(BonjourDirectory.class);\n }\n return logger;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/bonjour/BonjourMenu.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see BonjourMenu.\n */\n public BonjourMenu() {\n super(Translator.get(\"bonjour.bonjour_services\"));\n\n setIcon(IconManager.getIcon(IconManager.IconSet.FILE, \"bonjour.png\"));\n\n // Menu items will be added when menu gets selected\n addMenuListener(this);\n }\n\n\n /**\n * Returns the action to perform for the given {@link BonjourService}. This method is called for every\n * BonjourService available when this menu is selected.\n *\n * @param bs the BonjourService\n * @return the action to perform for the given BonjourService\n */\n public abstract TcAction getMenuItemAction(BonjourService bs);\n\n\n /////////////////////////////////\n // MenuListener implementation //\n /////////////////////////////////\n @Override\n public void menuSelected(MenuEvent menuEvent) {\n // Remove previous menu items (if any)\n removeAll();\n\n if (!BonjourDirectory.isActive()) {\n // Inform that Bonjour support has been disabled\n add(new JMenuItem(Translator.get(\"bonjour.bonjour_disabled\"))).setEnabled(false);\n return;\n }\n BonjourService[] services = BonjourDirectory.getServices();\n\n if (services.length > 0) {\n // Add a menu item for each Bonjour service.\n // When clicked, the corresponding URL will be opened in the active table.\n MnemonicHelper mnemonicHelper = new MnemonicHelper();\n\n for (BonjourService service : services) {\n JMenuItem menuItem = new JMenuItem(getMenuItemAction(service));\n menuItem.setMnemonic(mnemonicHelper.getMnemonic(menuItem.getText()));\n\n add(menuItem);\n }\n } else {\n // Inform that no service have been discovered\n add(new JMenuItem(Translator.get(\"bonjour.no_service_discovered\"))).setEnabled(false);\n }\n }\n\n @Override\n public void menuDeselected(MenuEvent menuEvent) {\n }\n\n @Override\n public void menuCanceled(MenuEvent menuEvent) {\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/bonjour/BonjourService.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see true if the given Object is a BonjourService instance with the same fully qualified name.\n */\n @Override\n public boolean equals(Object o) {\n return o instanceof BonjourService && fullyQualifiedName.equals(((BonjourService) o).fullyQualifiedName);\n }\n\n\n /**\n * Returns a String representation of this BonjourService in the form name / url.\n */\n @Override\n public String toString() {\n return name + \" / \" + url.toString(false);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/bonjour/package.html",
"content": "\n *
\n *\n * @author Maxence Bernard\n */\npublic class Bookmark implements Cloneable {\n private String name;\n private String location;\n private String parent;\n\n\n /**\n * Creates a new Bookmark using the given name and location.\n *\n * @param name name given to this bookmark\n * @param location location (path or URL) this bookmark points to\n */\n public Bookmark(String name, String location, String parent) {\n // Use setters to checks for null values\n setName(name);\n setLocation(location);\n setParent(parent);\n }\n\n\n /**\n * Returns this bookmark's name.\n * @return this bookmark's name.\n * @see #setName(String)\n */\n public String getName() {\n return name;\n }\n\n\n /**\n * Changes this bookmark's name to the given one and fires an event to registered {@link BookmarkListener}\n * instances.\n * @param newName bookmark's new name.\n * @see #getName()\n */\n public void setName(String newName) {\n if (newName == null) {\n newName = \"\";\n }\n\n if (!newName.equals(this.name)) {\n this.name = newName;\n // Notify registered listeners of the change\n BookmarkManager.fireBookmarksChanged();\n }\n }\n\n\n /**\n * Returns this bookmark's location which should normally designate a path or file URL, but which isn't\n * necessarily valid nor exists.\n * @return this bookmark's location.\n * @see #setLocation(String)\n */\n public String getLocation() {\n return location;\n }\n\n\n /**\n * Changes this bookmark's location to the given one and fires an event to registered {@link BookmarkListener}\n * instances.\n * @param newLocation bookmark's new location.\n * @see #getLocation()\n */\n public void setLocation(String newLocation) {\n // Replace null values by empty strings\n if (newLocation == null) {\n newLocation = \"\";\n }\n\n if (!newLocation.equals(this.location)) {\n this.location = newLocation;\n\n // Notify registered listeners of the change\n BookmarkManager.fireBookmarksChanged();\n }\n }\n\n public String getParent() {\n return parent;\n }\n\n public void setParent(String parent) {\n if (parent != null && parent.trim().isEmpty()) {\n parent = null;\n }\n this.parent = parent;\n }\n\n\n /**\n * Returns a clone of this bookmark.\n */\n @Override\n public Object clone() throws CloneNotSupportedException {\n return super.clone();\n }\n\n\n /**\n * Returns the bookmark's name.\n */\n public String toString() {\n if (parent != null) {\n return parent + \" -> \" + name;\n }\n return name;\n }\n\n public boolean equals(Object object) {\n if (!(object instanceof Bookmark bookmark)) {\n return false;\n }\n return bookmark.getName().equals(name);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/bookmark/BookmarkBuilder.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see BookmarkManager.\r\n */\r\n private BookmarkManager() {}\r\n\r\n\r\n\r\n // - Bookmark building -----------------------------------------------------\r\n // -------------------------------------------------------------------------\r\n /**\r\n * Passes messages about all known bookmarks to the specified builder.\r\n * @param builder where to send bookmark building messages.\r\n * @throws BookmarkException if an error occurs.\r\n */\r\n private static synchronized void buildBookmarks(BookmarkBuilder builder) throws BookmarkException {\r\n builder.startBookmarks();\r\n for (Bookmark bookmark : bookmarks) {\r\n builder.addBookmark(bookmark.getName(), bookmark.getLocation(), bookmark.getParent());\r\n }\r\n builder.endBookmarks();\r\n }\r\n\r\n\r\n\r\n // - Bookmark file access --------------------------------------------------\r\n // -------------------------------------------------------------------------\r\n /**\r\n * Returns the path to the bookmark file.\r\n * setBookmarksFile(FileFactory.getFile(file)).\r\n *\r\n * @param path path to the bookmarks file\r\n * @exception FileNotFoundException if path is not accessible.\r\n * @see #getBookmarksFile()\r\n */\r\n public static void setBookmarksFile(String path) throws FileNotFoundException {\r\n AbstractFile file = FileFactory.getFile(path);\r\n\r\n if (file == null) {\r\n setBookmarksFile(new File(path));\r\n } else {\r\n setBookmarksFile(file);\r\n }\r\n }\r\n\r\n /**\r\n * Sets the path to the bookmarks file.\r\n * setBookmarksFile(FileFactory.getFile(file.getAbsolutePath())).\r\n *\r\n * @param file path to the bookmarks file\r\n * @exception FileNotFoundException if path is not accessible.\r\n * @see #getBookmarksFile()\r\n */\r\n private static void setBookmarksFile(File file) throws FileNotFoundException {\r\n setBookmarksFile(FileFactory.getFile(file.getAbsolutePath()));\r\n }\r\n\r\n /**\r\n * Sets the path to the bookmarks file.\r\n * @param file path to the bookmarks file\r\n * @exception FileNotFoundException if path is not accessible.\r\n * @see #getBookmarksFile()\r\n */\r\n\r\n private static synchronized void setBookmarksFile(AbstractFile file) throws FileNotFoundException {\r\n if (file.isBrowsable()) {\r\n throw new FileNotFoundException(\"Not a valid file: \" + file.getAbsolutePath());\r\n }\r\n bookmarksFile = file;\r\n }\r\n\r\n\r\n\r\n // - Bookmarks loading -----------------------------------------------------\r\n // -------------------------------------------------------------------------\r\n /**\r\n * Loads all available bookmarks.\r\n * @throws Exception if an error occurs.\r\n */\r\n public static synchronized void loadBookmarks() throws Exception {\r\n // Parse the bookmarks file\r\n isLoading = true;\r\n try (InputStream in = new BackupInputStream(getBookmarksFile())) {\r\n readBookmarks(in, new Loader());\r\n isLoading = false;\r\n } catch (IOException e) {\r\n isLoading = false;\r\n throw e;\r\n }\r\n }\r\n\r\n /**\r\n * Reads bookmarks from the specified InputStream.\r\n * @param in where to read bookmarks from.\r\n * @throws Exception if an error occurs.\r\n */\r\n public static void readBookmarks(InputStream in) throws Exception {\r\n readBookmarks(in, new Loader());\r\n }\r\n\r\n /**\r\n * Reads bookmarks from the specified InputStream and passes messages to the specified {@link BookmarkBuilder}.\r\n * @param in where to read bookmarks from.\r\n * @param builder where to send builing messages to.\r\n * @throws Exception if an error occurs.\r\n */\r\n public static synchronized void readBookmarks(InputStream in, BookmarkBuilder builder) throws Exception {\r\n new BookmarkParser().parse(in, builder);\r\n }\r\n\r\n\r\n\r\n // - Bookmarks writing -----------------------------------------------------\r\n // -------------------------------------------------------------------------\r\n /**\r\n * Returns a {@link BookmarkBuilder} that will write all building messages as XML to the specified output stream.\r\n * @param out where to write the bookmarks' XML content.\r\n * @return a {@link BookmarkBuilder} that will write all building messages as XML to the specified output stream.\r\n * @throws IOException if an IO related error occurs.\r\n */\r\n public static BookmarkBuilder getBookmarkWriter(OutputStream out) throws IOException {\r\n return new BookmarkWriter(out);\r\n }\r\n\r\n /**\r\n * Writes all known bookmarks to the bookmark {@link #getBookmarksFile() file}.\r\n * @param forceWrite if false, the bookmarks file will be written only if changes were made to bookmarks since\r\n * last write, if true the file will always be written\r\n * @throws IOException if an I/O error occurs.\r\n * @throws BookmarkException if an error occurs.\r\n */\r\n public static synchronized void writeBookmarks(boolean forceWrite) throws IOException, BookmarkException {\r\n // Write bookmarks file only if changes were made to the bookmarks since last write, or if write is forced.\r\n if (!forceWrite && !saveNeeded) {\r\n return;\r\n }\r\n try (OutputStream out = new BackupOutputStream(getBookmarksFile())) {\r\n buildBookmarks(getBookmarkWriter(out));\r\n saveNeeded = false;\r\n }\r\n }\r\n\r\n\r\n\r\n // - Bookmarks access ------------------------------------------------------\r\n // -------------------------------------------------------------------------\r\n /**\r\n * Returns an {@link AlteredVector} that contains all bookmarks.\r\n * \r\n * \r\n *
\r\n */\r\n static void fireBookmarksChanged() {\r\n // Bookmarks file will need to be saved\r\n if (!isLoading) {\r\n saveNeeded = true;\r\n }\r\n\r\n lastBookmarkChangeTime = System.currentTimeMillis();\r\n\r\n // Do not fire event if events are currently disabled\r\n if (!fireEvents) {\r\n return;\r\n }\r\n\r\n synchronized(listeners) {\r\n // Iterate on all listeners\r\n for (BookmarkListener listener : listeners.keySet()) {\r\n listener.bookmarksChanged();\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * Specifies whether bookmark events should be fired when a change in the bookmarks is detected. This allows\r\n * to temporarily suspend events firing when a lot of them are made, for example when editing the bookmarks list.\r\n *\r\n * null if it is unknown.\n * null if it is unknown.\n */\n public String getVersion() {\n return version;\n }\n\n\n /* ------------------------ */\n /* ContentHandler methods */\n /* ------------------------ */\n\n @Override\n public void startDocument() throws SAXException {\n try {\n builder.startBookmarks();\n } catch (BookmarkException e) {\n throw new SAXException(e);\n }\n }\n\n @Override\n public void endDocument() throws SAXException {\n try {\n builder.endBookmarks();\n } catch (BookmarkException e) {\n throw new SAXException(e);\n }\n }\n\n /**\n * Method called when some PCDATA has been found in an XML node.\n */\n @Override\n public void characters(char[] ch, int start, int length) {\n characters.append(ch, start, length);\n }\n\n /**\n * Notifies the parser that a new XML node has been found.\n */\n @Override\n public void startElement(String uri, String localName, String qName, Attributes attributes) {\n characters.setLength(0);\n\n if (qName.equals(ELEMENT_ROOT)) {\n version = attributes.getValue(ATTRIBUTE_VERSION);\n } else if (qName.equals(ELEMENT_BOOKMARK)) {\n // Reset parsing variables\n bookmarkName = null;\n bookmarkLocation = null;\n bookmarkParent = null;\n }\n }\n\n /**\n * Notifies the parser that an XML node has been closed.\n */\n @Override\n public void endElement(String uri, String localName, String qName) throws SAXException {\n switch (qName) {\n case ELEMENT_BOOKMARK:\n addBookmark();\n break;\n case ELEMENT_NAME:\n bookmarkName = characters.toString().trim();\n break;\n case ELEMENT_LOCATION:\n bookmarkLocation = characters.toString().trim();\n break;\n case ELEMENT_PARENT:\n bookmarkParent = characters.toString().trim();\n break;\n // Note: url element has been deprecated in 0.8 beta3 but is still checked against for upward compatibility.\n// case ELEMENT_URL:\n// // Until early 0.8 beta3 nightly builds, credentials were stored directly in the bookmark's url.\n// // Now bookmark locations are free of credentials, these are stored in a dedicated credentials file where\n// // the password is encrypted.\n// try {\n// FileURL url = FileURL.getFileURL(characters.toString().trim());\n// Credentials credentials = url.getCredentials();\n//\n// // If the URL contains credentials, import them into CredentialsManager and remove credentials\n// // from the bookmark's location\n// if (credentials != null) {\n// CredentialsManager.addCredentials(new CredentialsMapping(credentials, url, true));\n// bookmarkLocation = url.toString(false);\n// } else {\n// bookmarkLocation = characters.toString().trim();\n// }\n// } catch (MalformedURLException e) {\n// bookmarkLocation = characters.toString().trim();\n// }\n// break;\n }\n }\n\n private void addBookmark() throws SAXException {\n if (bookmarkName == null || bookmarkLocation == null) {\n getLogger().info(\"Missing value, bookmark ignored: name=\" + bookmarkName + \" location=\" + bookmarkLocation);\n return;\n }\n\n try {\n builder.addBookmark(bookmarkName, bookmarkLocation, bookmarkParent);\n } catch (BookmarkException e) {\n throw new SAXException(e);\n }\n }\n\n private static Logger getLogger() {\n if (logger == null) {\n logger = LoggerFactory.getLogger(BookmarkParser.class);\n }\n return logger;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/bookmark/BookmarkWriter.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see bookmark:// file system.\n * @author Nicolas Rinaudo\n */\npublic class BookmarkFile extends ProtocolFile {\n // - Instance fields -------------------------------------------------------\n // -------------------------------------------------------------------------\n /** Bookmark wrapped by this abstract file. */\n private final Bookmark bookmark;\n /** Underlying abstract file. */\n private AbstractFile file;\n\n /** Permissions for all bookmark files: rw- (600 octal). Only the 'user' permissions bits are supported. */\n final static FilePermissions PERMISSIONS = new SimpleFilePermissions(384, 448);\n\n /**\n * Creates a new bookmark file wrapping the specified bookmark.\n * @param bookmark bookmark to wrap.\n * @throws IOException if the specified bookmark's URL cannot be resolved.\n */\n BookmarkFile(Bookmark bookmark) throws IOException {\n super(FileURL.getFileURL(BookmarkProtocolProvider.BOOKMARK + \"://\" + java.net.URLEncoder.encode(bookmark.getName(), StandardCharsets.UTF_8)));\n this.bookmark = bookmark;\n }\n\n\n /**\n * Returns the AbstractFile this instance wraps.\n * AbstractFile this instance wraps.\n */\n private synchronized AbstractFile getUnderlyingFile() {\n // Resolves the file if necessary.\n if (file == null) {\n file = FileFactory.getFile(bookmark.getLocation());\n }\n\n return file;\n }\n\n /**\n * Returns the underlying bookmark.\n * @return the underlying bookmark.\n */\n public Bookmark getBookmark() {\n return bookmark;\n }\n\n\n\n // - AbstractFile methods --------------------------------------------------\n // -------------------------------------------------------------------------\n /**\n * Returns the underlying bookmark's name.\n * @return the underlying bookmark's name.\n */\n @Override\n public String getName() {\n return bookmark.getName();\n }\n\n /**\n * Returns the wrapped file's descendants.\n * @return the wrapped file's descendants.\n * @throws IOException if an I/O error occurs.\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\n * or is not implemented.\n */\n @Override\n public AbstractFile[] ls() throws IOException, UnsupportedFileOperationException {\n return getUnderlyingFile().ls();\n }\n\n /**\n * Returns the wrapped file's parent.\n * @return the wrapped file's parent.\n * @see #setParent(AbstractFile)\n */\n @Override\n public AbstractFile getParent() {\n try {\n return new BookmarkRoot();\n } catch(IOException e) {\n return null;\n }\n }\n\n /**\n * Returns the result of the wrapped file's getFreeSpace() methods.\n * @return the result of the wrapped file's getFreeSpace() methods.\n * @throws IOException if an I/O error occurred\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\n * or is not implemented.\n */\n @Override\n public long getFreeSpace() throws IOException, UnsupportedFileOperationException {\n return getUnderlyingFile().getFreeSpace();\n }\n\n /**\n * Returns the result of the wrapped file's getTotalSpace() methods.\n * @return the result of the wrapped file's getTotalSpace() methods.\n * @throws IOException if an I/O error occurred\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\n * or is not implemented.\n */\n @Override\n public long getTotalSpace() throws IOException, UnsupportedFileOperationException {\n return getUnderlyingFile().getTotalSpace();\n }\n\n /**\n * Returns false.\n * @return false.\n */\n @Override\n public boolean isDirectory() {\n return true;\n }\n\n /**\n * Sets the wrapped file's parent.\n * @param parent object to use as the wrapped file's parent.\n * @see AbstractFile#getParent()\n */\n @Override\n public void setParent(AbstractFile parent) {\n getUnderlyingFile().setParent(parent);}\n\n /**\n * Returns true if the specified bookmark exists.\n * true if the specified bookmark exists, false otherwise.\n */\n @Override\n public boolean exists() {\n return BookmarkManager.getBookmark(bookmark.getName()) != null;\n }\n\n @Override\n public void mkfile() {\n BookmarkManager.addBookmark(bookmark);\n }\n\n public boolean equals(Object o) {\n // Makes sure we're working with an abstract file.\n if (!(o instanceof AbstractFile)) {\n return false;\n }\n\n // Retrieves the actual file instance.\n // We might have received a Proxied or Cached file, so we need to make sure\n // we 'unwrap' that before comparing.\n AbstractFile file = ((AbstractFile)o).getAncestor();\n\n // We only know how to compare one bookmark file to the other.\n if (file instanceof BookmarkFile) {\n return bookmark.equals(((BookmarkFile)file).getBookmark());\n }\n return false;\n }\n\n @Override\n public String getCanonicalPath() {return bookmark.getLocation();}\n\n\n\n // - Bookmark renaming -----------------------------------------------------\n // -------------------------------------------------------------------------\n\n /**\n * Attempts to rename the bookmark to the specified destination.\n * The operation will only be carried out if the specified destination is a BookmarkFile or has an\n * ancestor that is.\n *\n * @param destination where to move the bookmark to.\n * @throws IOException if the operation could not be carried out.\n */\n @Override\n public void renameTo(AbstractFile destination) throws IOException {\n checkRenamePrerequisites(destination, true, true);\n\n destination = destination.getTopAncestor();\n\n // Makes sure we're working with a bookmark.\n if (!(destination instanceof BookmarkFile)) {\n throw new IOException();\n }\n\n // Creates the new bookmark and checks for conflicts.\n Bookmark newBookmark = new Bookmark(destination.getName(), bookmark.getLocation(), bookmark.getParent());\n Bookmark oldBookmark = BookmarkManager.getBookmark(newBookmark.getName());\n if (oldBookmark != null) {\n BookmarkManager.removeBookmark(oldBookmark);\n }\n\n // Adds the new bookmark and deletes its 'old' version.\n BookmarkManager.addBookmark(newBookmark);\n BookmarkManager.removeBookmark(bookmark);\n }\n\n // TODO: bookmark deleting is currently disabled as a quick fix for #329 \n// /**\n// * Deletes the bookmark.\n// * BookmarkFile,\n * this will duplicate the bookmark. Otherwise, this method will fail.\n *\n * @param destination where to copy the bookmark to.\n * @throws FileTransferException if the specified destination is not an instance of BookmarkFile.\n */\n @Override\n public void copyRemotelyTo(AbstractFile destination) throws IOException {\n // Makes sure we're working with a bookmark.\n destination = destination.getTopAncestor();\n if (!(destination instanceof BookmarkFile)) {\n throw new IOException();\n }\n // Copies this bookmark to the specified destination.\n BookmarkManager.addBookmark(new Bookmark(destination.getName(), bookmark.getLocation(), bookmark.getParent()));\n }\n\n\n\n // - Permissions -----------------------------------------------------------\n // -------------------------------------------------------------------------\n /**\n * Returns the same permissions for all boookmark files: rw- (600 octal).\n * Only the 'user' permissions bits are supported.\n\n * @return this file's permissions.\n * @see #changePermission(int,int,boolean)\n */\n @Override\n public FilePermissions getPermissions() {\n return PERMISSIONS;\n }\n\n /**\n * Always throws an {@link UnsupportedFileOperationException} when called: bookmarks always have all permissions,\n * this is not changeable.\n *\n * @param access ignored.\n * @param permission ignored.\n * @param enabled ignored.\n * @see #getPermissions()\n */\n @Override\n @UnsupportedFileOperation\n public void changePermission(int access, int permission, boolean enabled) throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.CHANGE_PERMISSION);\n }\n\n\n // - Import / export -------------------------------------------------------\n // -------------------------------------------------------------------------\n @Override\n public InputStream getInputStream() throws IOException {\n ByteArrayOutputStream stream = new ByteArrayOutputStream();\n BookmarkBuilder builder = BookmarkManager.getBookmarkWriter(stream);\n try {\n builder.startBookmarks();\n builder.addBookmark(bookmark.getName(), bookmark.getLocation(), bookmark.getParent());\n builder.endBookmarks();\n } catch (Throwable e) {\n // If an exception occurred, we have to look for its root cause.\n Throwable e2;\n\n // Looks for the cause.\n while ((e2 = e.getCause()) != null) {\n e = e2;\n }\n\n // If the cause is an IOException, thow it.\n if (e instanceof IOException) {\n throw (IOException)e;\n }\n\n // Otherwise, throw the exception as an IOException with a the underlying cause's message.\n throw new IOException(e.getMessage());\n }\n\n return new ByteArrayInputStream(stream.toByteArray());\n }\n\n @Override\n public OutputStream getOutputStream() throws IOException {return new BookmarkOutputStream();}\n\n\n // - Unused methods --------------------------------------------------------\n // -------------------------------------------------------------------------\n // The following methods are not used by BookmarkFile. They will throw an exception or\n // return an 'operation non supported' / default value.\n\n @Override\n @UnsupportedFileOperation\n public void mkdir() throws UnsupportedFileOperationException {throw new UnsupportedFileOperationException(FileOperation.CREATE_DIRECTORY);}\n @Override\n public long getLastModifiedDate() {return 0;}\n @Override\n public PermissionBits getChangeablePermissions() {return PermissionBits.EMPTY_PERMISSION_BITS;}\n @Override\n @UnsupportedFileOperation\n public void setLastModifiedDate(long lastModified) throws UnsupportedFileOperationException {throw new UnsupportedFileOperationException(FileOperation.CHANGE_DATE);}\n @Override\n public long getSize() {return -1;}\n @Override\n @UnsupportedFileOperation\n public RandomAccessInputStream getRandomAccessInputStream() throws UnsupportedFileOperationException {throw new UnsupportedFileOperationException(FileOperation.RANDOM_READ_FILE);}\n @Override\n @UnsupportedFileOperation\n public OutputStream getAppendOutputStream() throws UnsupportedFileOperationException {throw new UnsupportedFileOperationException(FileOperation.APPEND_FILE);}\n @Override\n @UnsupportedFileOperation\n public RandomAccessOutputStream getRandomAccessOutputStream() throws UnsupportedFileOperationException {throw new UnsupportedFileOperationException(FileOperation.RANDOM_WRITE_FILE);}\n @Override\n public Object getUnderlyingFileObject() {return null;}\n @Override\n public boolean isSymlink() {return false;}\n @Override\n public boolean isSystem() {return false;}\n @Override\n public String getOwner() {return null;}\n @Override\n public boolean canGetOwner() {return false;}\n @Override\n public String getGroup() {return null;}\n @Override\n public boolean canGetGroup() {return false;}\n @Override\n @UnsupportedFileOperation\n public short getReplication() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.GET_REPLICATION);\n }\n\n @Override\n @UnsupportedFileOperation\n public long getBlocksize() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.GET_BLOCKSIZE);\n }\n\n @Override\n @UnsupportedFileOperation\n public void changeReplication(short replication) throws IOException {\n throw new UnsupportedFileOperationException(FileOperation.CHANGE_REPLICATION);\n }\n\n}\n"
},
{
"path": "src/main/java/com/mucommander/bookmark/file/BookmarkOutputStream.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see bookmarks:// file system.\n * @author Nicolas Rinaudo\n */\nclass BookmarkRoot extends ProtocolFile implements BookmarkListener {\n /** Time at which the bookmarks were last modified. */\n private long lastModified;\n\n\n BookmarkRoot() throws IOException {this(FileURL.getFileURL(BookmarkProtocolProvider.BOOKMARK + \"://\"));}\n\n BookmarkRoot(FileURL url) {\n super(url);\n lastModified = System.currentTimeMillis();\n BookmarkManager.addBookmarkListener(this);\n }\n\n\n @Override\n public AbstractFile[] ls() throws IOException {\n // Retrieves all available bookmarks.\n Object[] buffer = BookmarkManager.getBookmarks().toArray();\n AbstractFile[] files = new AbstractFile[buffer.length];\n\n // Creates the associated instances of BookmarkFile\n for (int i = 0; i < files.length; i++) {\n files[i] = new BookmarkFile((Bookmark)buffer[i]);\n }\n return files;\n }\n\n @Override\n public String getName() {\n return \"\";\n }\n\n @Override\n public boolean isDirectory() {\n return true;\n }\n\n /**\n * Stores the current date as the date of last modification.\n */\n public void bookmarksChanged() {\n lastModified = System.currentTimeMillis();\n }\n\n /**\n * Returns the date at which the bookmark list was last modified.\n * @return the date at which the bookmark list was last modified.\n */\n @Override\n public long getLastModifiedDate() {\n return lastModified;\n }\n\n // The following methods are not used by BookmarkFile. They will throw an exception,\n // return an 'operation non supported' value or return a default value.\n\n @Override\n public AbstractFile getParent() {return null;}\n @Override\n @UnsupportedFileOperation\n public void delete() throws UnsupportedFileOperationException {throw new UnsupportedFileOperationException(FileOperation.DELETE);}\n @Override\n @UnsupportedFileOperation\n public void copyRemotelyTo(AbstractFile destFile) throws UnsupportedFileOperationException {throw new UnsupportedFileOperationException(FileOperation.COPY_REMOTELY);}\n @Override\n @UnsupportedFileOperation\n public void renameTo(AbstractFile destFile) throws UnsupportedFileOperationException {throw new UnsupportedFileOperationException(FileOperation.RENAME);}\n @Override\n @UnsupportedFileOperation\n public void setLastModifiedDate(long lastModified) throws UnsupportedFileOperationException {throw new UnsupportedFileOperationException(FileOperation.CHANGE_DATE);}\n @Override\n public long getSize() {return -1;}\n @Override\n public void setParent(AbstractFile parent) {}\n @Override\n public boolean exists() {return true;}\n @Override\n public FilePermissions getPermissions() {return BookmarkFile.PERMISSIONS;}\n @Override\n @UnsupportedFileOperation\n public void changePermission(int access, int permission, boolean enabled) throws UnsupportedFileOperationException {throw new UnsupportedFileOperationException(FileOperation.CHANGE_PERMISSION);}\n @Override\n public PermissionBits getChangeablePermissions() {return PermissionBits.EMPTY_PERMISSION_BITS;}\n @Override\n public boolean isSymlink() {return false;}\n @Override\n public boolean isSystem() {return false;}\n @Override\n @UnsupportedFileOperation\n public void mkdir() throws UnsupportedFileOperationException {throw new UnsupportedFileOperationException(FileOperation.CREATE_DIRECTORY);}\n @Override\n @UnsupportedFileOperation\n public InputStream getInputStream() throws UnsupportedFileOperationException {throw new UnsupportedFileOperationException(FileOperation.READ_FILE);}\n @Override\n @UnsupportedFileOperation\n public OutputStream getOutputStream() throws UnsupportedFileOperationException {throw new UnsupportedFileOperationException(FileOperation.WRITE_FILE);}\n @Override\n @UnsupportedFileOperation\n public OutputStream getAppendOutputStream() throws UnsupportedFileOperationException {throw new UnsupportedFileOperationException(FileOperation.APPEND_FILE);}\n @Override\n @UnsupportedFileOperation\n public RandomAccessInputStream getRandomAccessInputStream() throws UnsupportedFileOperationException {throw new UnsupportedFileOperationException(FileOperation.RANDOM_READ_FILE);}\n @Override\n @UnsupportedFileOperation\n public RandomAccessOutputStream getRandomAccessOutputStream() throws UnsupportedFileOperationException {throw new UnsupportedFileOperationException(FileOperation.RANDOM_WRITE_FILE);}\n @Override\n @UnsupportedFileOperation\n public long getFreeSpace() throws UnsupportedFileOperationException {throw new UnsupportedFileOperationException(FileOperation.GET_FREE_SPACE);}\n @Override\n @UnsupportedFileOperation\n public long getTotalSpace() throws UnsupportedFileOperationException {throw new UnsupportedFileOperationException(FileOperation.GET_TOTAL_SPACE);}\n @Override\n public Object getUnderlyingFileObject() {return null;}\n @Override\n public String getOwner() {return null;}\n @Override\n public boolean canGetOwner() {return false;}\n @Override\n public String getGroup() {return null;}\n @Override\n public boolean canGetGroup() {return false;}\n @Override\n @UnsupportedFileOperation\n public short getReplication() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.GET_REPLICATION);\n }\n\n @Override\n @UnsupportedFileOperation\n public long getBlocksize() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.GET_BLOCKSIZE);\n }\n\n @Override\n @UnsupportedFileOperation\n public void changeReplication(short replication) throws IOException {\n throw new UnsupportedFileOperationException(FileOperation.CHANGE_REPLICATION);\n }\n\n}\n"
},
{
"path": "src/main/java/com/mucommander/bookmark/file/package.html",
"content": "LinkedHashMap which provides fast retrieval and insertion\n * operations.\n * \n * LinkedHashMap is slow at that. \n * To minimize the impact this could have on performance, this operation is not systematically performed\n * for each call to get() and set() methods, unless the cache is full. \n * That means this implementation is not as aggressive as it could be in terms of releasing expired items' memory\n * but favors performance instead, which is what caches are for.\n *\n * @author Maxence Bernard\n */\npublic class FastLRUCache
The LRUCache implementation must however guarantee two things :\r\n * \r\n *
\r\n *\r\n * @author Maxence Bernard\r\n */\r\npublic abstract class LRUCachenull if:\r\n * \r\n *
\r\n *\r\n * @param key the cached item's key\r\n * @return the cached value corresponding to the specified key, or null if a value could not\r\n * found or has expired\r\n */\r\n public abstract V get(K key);\r\n\t\r\n /**\r\n * Adds a new key/value pair to the cache and marks it as the most recently used.\r\n *\r\n * \r\n *
\r\n *\r\n * @param key the key for the object to store\r\n * @param value the value to cache\r\n * @param timeToLive the time-to-live of the object in the cache in milliseconds, or -1 for no time-to-live,\r\n * the object will just be removed when it becomes the least recently used one.\r\n */\r\n public abstract void add(K key, V value, long timeToLive);\r\n\r\n\r\n /**\r\n * Convenience method, equivalent to add(key, value, -1).\r\n * @param key key\r\n * @param value value\r\n */\r\n public synchronized void add(K key, V value) {\r\n add(key, value, -1);\r\n }\r\n\t\r\n\r\n /**\r\n * Removes all items from this cache, leaving the cache in the same state as when it was just created.\r\n */\r\n public abstract void clearAll();\r\n\t\t\r\n\r\n /**\r\n * Returns the current size of this cache, i.e. the number of cached elements it contains.\r\n *
Note: Some items that have expired and have not yet been removed might be accounted for\r\n * in the returned size.\r\n *\r\n * @return the current size of this cache\r\n */\r\n public abstract int size();\r\n\r\n\r\n /**\r\n * Tests this LRUCache for corruption and throws a RuntimeException if something is wrong.\r\n */\r\n protected abstract void testCorruption() throws RuntimeException;\r\n\t\r\n\r\n /**\r\n * Test method : simple test case + stress/sanity test\r\n *\r\n * @param args command line arguments\r\n */\r\n public static void main(String[] args) {\r\n LRUCacheAssociationWriter is an {@link AssociationBuilder} that will send\n * all build messages it receives into an XML stream (as defined in {@link AssociationsXmlConstants}).\n *\n * @author Nicolas Rinaudo\n */\npublic class AssociationWriter implements AssociationsXmlConstants, AssociationBuilder {\n /** Where to write the custom command associations to. */\n private final XmlWriter out;\n\n /**\n * Builds a new writer that will send data to the specified output stream.\n * @param stream where to write the XML data.\n * @throws IOException if an I/O error occurs.\n */\n AssociationWriter(OutputStream stream) throws IOException {out = new XmlWriter(stream);}\n\n\n\n /**\n * Opens the root XML element.\n */\n @Override\n public void startBuilding() throws CommandException {\n try {\n out.startElement(ELEMENT_ROOT);\n out.println();\n } catch(IOException e) {\n throw new CommandException(e);\n }\n }\n\n /**\n * Closes the root XML element.\n */\n @Override\n public void endBuilding() throws CommandException {\n try {\n out.endElement(ELEMENT_ROOT);\n } catch(IOException e) {\n throw new CommandException(e);\n }\n }\n\n @Override\n public void startAssociation(String command) throws CommandException {\n XmlAttributes attr = new XmlAttributes();\n attr.add(ATTRIBUTE_COMMAND, command);\n\n try {\n out.startElement(ELEMENT_ASSOCIATION, attr);\n out.println();\n } catch(IOException e) {\n throw new CommandException(e);\n }\n }\n\n @Override\n public void endAssociation() throws CommandException {\n try {\n out.endElement(ELEMENT_ASSOCIATION);\n } catch(IOException e) {\n throw new CommandException(e);\n }\n }\n\n @Override\n public void setMask(String mask, boolean isCaseSensitive) throws CommandException {\n XmlAttributes attr = new XmlAttributes();\n attr.add(ATTRIBUTE_VALUE, mask);\n if (!isCaseSensitive) {\n attr.add(ATTRIBUTE_CASE_SENSITIVE, VALUE_FALSE);\n }\n writeStandaloneElement(attr, ELEMENT_MASK);\n }\n\n @Override\n public void setIsSymlink(boolean isSymlink) throws CommandException {\n XmlAttributes attr = new XmlAttributes();\n attr.add(ATTRIBUTE_VALUE, isSymlink ? VALUE_TRUE : VALUE_FALSE);\n writeStandaloneElement(attr, ELEMENT_IS_SYMLINK);\n }\n\n @Override\n public void setIsHidden(boolean isHidden) throws CommandException {\n XmlAttributes attr = new XmlAttributes();\n attr.add(ATTRIBUTE_VALUE, isHidden ? VALUE_TRUE : VALUE_FALSE);\n writeStandaloneElement(attr, ELEMENT_IS_HIDDEN);\n }\n\n @Override\n public void setIsReadable(boolean isReadable) throws CommandException {\n XmlAttributes attr = new XmlAttributes();\n attr.add(ATTRIBUTE_VALUE, isReadable ? VALUE_TRUE : VALUE_FALSE);\n writeStandaloneElement(attr, ELEMENT_IS_READABLE);\n }\n\n @Override\n public void setIsWritable(boolean isWritable) throws CommandException {\n XmlAttributes attr = new XmlAttributes();\n attr.add(ATTRIBUTE_VALUE, isWritable ? VALUE_TRUE : VALUE_FALSE);\n writeStandaloneElement(attr, ELEMENT_IS_WRITABLE);\n }\n\n @Override\n public void setIsExecutable(boolean isExecutable) throws CommandException {\n XmlAttributes attr = new XmlAttributes();\n attr.add(ATTRIBUTE_VALUE, isExecutable ? VALUE_TRUE : VALUE_FALSE);\n writeStandaloneElement(attr, ELEMENT_IS_EXECUTABLE);\n }\n\n private void writeStandaloneElement(XmlAttributes attr, String name) throws CommandException {\n try {\n out.writeStandAloneElement(name, attr);\n } catch (IOException e) {\n throw new CommandException(e);\n }\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/command/AssociationsXmlConstants.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see \n * <!ELEMENT associations (association*)>\n * \n * <!ELEMENT association (filename?,symlink?,hidden?,readable?,writable?,executable?)>\n * <!ATTLIST association command CDATA #REQUIRED>\n *\n * <!ELEMENT filename EMPTY>\n * <!ATTLIST filename value CDATA #REQUIRED>\n * <!ATTLIST filename case_sensitive (true|false) #IMPLIED>\n *\n * <!ELEMENT symlink EMPTY>\n * <!ATTLIST symlink value (true|false) #REQUIRED>\n *\n * <!ELEMENT hidden EMPTY>\n * <!ATTLIST hidden value (true|false) #REQUIRED>\n *\n * <!ELEMENT readable EMPTY>\n * <!ATTLIST readable value (true|false) #REQUIRED>\n *\n * <!ELEMENT writable EMPTY>\n * <!ATTLIST writable value (true|false) #REQUIRED>\n *\n * <!ELEMENT executable EMPTY>\n * <!ATTLIST executable value (true|false) #REQUIRED>\n *
\n *\n * @see AssociationReader\n * @see AssociationWriter\n * @author Nicolas Rinaudo\n */\ninterface AssociationsXmlConstants {\n /** Root element. */\n String ELEMENT_ROOT = \"associations\";\n /** Custom association definition element. */\n String ELEMENT_ASSOCIATION = \"association\";\n String ELEMENT_MASK = \"filename\";\n String ELEMENT_IS_SYMLINK = \"symlink\";\n String ELEMENT_IS_HIDDEN = \"hidden\";\n String ELEMENT_IS_READABLE = \"readable\";\n String ELEMENT_IS_WRITABLE = \"writable\";\n String ELEMENT_IS_EXECUTABLE = \"executable\";\n\n /** Name of the attribute containing the alias of the command to execute in this association. */\n String ATTRIBUTE_COMMAND = \"command\";\n String ATTRIBUTE_VALUE = \"value\";\n String ATTRIBUTE_CASE_SENSITIVE = \"case_sensitive\";\n String VALUE_TRUE = \"true\";\n String VALUE_FALSE = \"false\";\n}\n"
},
{
"path": "src/main/java/com/mucommander/command/Command.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see \n *
\n * Command.\n *
\n * It is important to remember that \\ character will escape the following character and be removed from the tokens.\" character will escape all characters until the next occurrence of \", except for \\.\" characters are not removed from the resulting tokens.\n * \n *
\n * $f is replaced by a file's full path.$n is replaced by a file's name.$e is replaced by a file's extension.$N is replaced by a file's name without its extension.$p is replaced by a file's parent's path.$j is replaced by the path of the folder in which the JVM was started.Command instance has been retrieved, execution tokens can be retrieved through the\n * {@link #getTokens(AbstractFile)} method. This will return a tokenized version of the command and replace any\n * keyword by the corresponding file value . It's also possible to skip keyword replacement through the {@link #getTokens()} method.\n * null, defaults to alias).\n * @param fileMask mask for files specification\n */\n public Command(String alias, String command, CommandType type, String displayName, String fileMask) {\n this.alias = alias;\n this.type = type;\n this.displayName = displayName;\n this.command = command;\n this.fileMask = fileMask;\n }\n\n /**\n * Creates a new command.\n * \n * {@link #Command(String, String, CommandType, String, String)\n * Command(}alias, command, {@link CommandType#NORMAL_COMMAND}, null, null)\n * .\n *\n * @param alias alias of the command.\n * @param command command that will be executed.\n */\n public Command(String alias, String command) {\n this(alias, command, CommandType.NORMAL_COMMAND, null, null);\n }\n\n /**\n * Creates a new command.\n * {@link #Command(String, String, CommandType, String, String) Command(}alias, command, type, null, null).\n *\n * @param alias alias of the command.\n * @param command command that will be executed.\n * @param type type of the command.\n */\n public Command(String alias, String command, CommandType type) {\n this(alias, command, type, null, null);\n }\n\n\n public Command(Command cmd) {\n this.alias = cmd.getAlias();\n this.type = cmd.getType();\n this.displayName = cmd.getDisplayName();\n this.command = cmd.getCommand();\n this.fileMask = cmd.getFileMask();\n }\n\n\n /**\n * Returns this command's tokens without performing keyword substitution.\n *\n * @return this command's tokens without performing keyword substitution.\n */\n public synchronized String[] getTokens() {\n return getTokens(command, (AbstractFile[]) null);\n }\n\n /**\n * Returns this command's tokens, replacing keywords by the corresponding values from the specified file.\n *\n * @param file file from which to retrieve keyword substitution values.\n * @return this command's tokens, replacing keywords by the corresponding values from the specified file.\n */\n public synchronized String[] getTokens(AbstractFile file) {\n return getTokens(command, file);\n }\n\n /**\n * Returns this command's tokens, replacing keywords by the corresponding values from the specified fileset.\n *\n * @param files files from which to retrieve keyword substitution values.\n * @return this command's tokens, replacing keywords by the corresponding values from the specified fileset.\n */\n public synchronized String[] getTokens(FileSet files) {\n return getTokens(command, files);\n }\n\n /**\n * Returns this command's tokens, replacing keywords by the corresponding values from the specified files.\n *\n * @param files files from which to retrieve keyword substitution values.\n * @return this command's tokens, replacing keywords by the corresponding values from the specified files.\n */\n public synchronized String[] getTokens(AbstractFile[] files) {\n return getTokens(command, files);\n }\n\n /**\n * Returns the specified command's tokens without performing keyword substitution.\n *\n * @param command command to tokenize.\n * @return the specified command's tokens without performing keyword substitution.\n */\n public static String[] getTokens(String command) {\n return getTokens(command, (AbstractFile[]) null);\n }\n\n /**\n * Returns the specified command's tokens after replacing keywords by the corresponding values from the specified file.\n *\n * @param command command to tokenize.\n * @param file file from which to retrieve keyword substitution values.\n * @return the specified command's tokens after replacing keywords by the corresponding values from the specified file.\n */\n public static String[] getTokens(String command, AbstractFile file) {\n return getTokens(command, new AbstractFile[]{file});\n }\n\n /**\n * Returns the specified command's tokens after replacing keywords by the corresponding values from the specified fileset.\n *\n * @param command command to tokenize.\n * @param files file from which to retrieve keyword substitution values.\n * @return the specified command's tokens after replacing keywords by the corresponding values from the specified fileset.\n */\n public static String[] getTokens(String command, FileSet files) {\n return getTokens(command, files.toArray(new AbstractFile[0]));\n }\n\n /**\n * Returns the specified command's tokens after replacing keywords by the corresponding values from the specified files.\n *\n * @param command command to tokenize.\n * @param files file from which to retrieve keyword substitution values.\n * @return the specified command's tokens after replacing keywords by the corresponding values from the specified files.\n */\n public static String[] getTokens(String command, AbstractFile[] files) {\n Listtrue if the specified character is a legal keyword.\n *\n * @param keyword character to check.\n * @return true if the specified character is a legal keyword, false otherwise.\n */\n private static boolean isLegalKeyword(char keyword) {\n return keyword == KEYWORD_PATH || keyword == KEYWORD_NAME || keyword == KEYWORD_PARENT ||\n keyword == KEYWORD_VM_PATH || keyword == KEYWORD_EXTENSION || keyword == KEYWORD_NAME_WITHOUT_EXTENSION;\n }\n\n /**\n * Gets the value from file that should be used to replace keyword.\n *\n * @param keyword character to replace.\n * @param file file from which to retrieve the replacement value.\n * @return the requested replacement value.\n */\n private static String getKeywordReplacement(char keyword, AbstractFile file) {\n return switch (keyword) {\n case KEYWORD_PATH -> file.getAbsolutePath();\n case KEYWORD_NAME -> file.getName();\n case KEYWORD_PARENT -> {\n AbstractFile parentFile = file.getParent();\n yield parentFile == null ? \"\" : parentFile.getAbsolutePath();\n }\n case KEYWORD_VM_PATH -> new File(System.getProperty(\"user.dir\")).getAbsolutePath();\n case KEYWORD_EXTENSION -> {\n String extension = file.getExtension();\n yield extension != null ? extension : \"\";\n }\n case KEYWORD_NAME_WITHOUT_EXTENSION -> file.getNameWithoutExtension();\n default -> throw new IllegalArgumentException();\n };\n }\n\n\n /**\n * Returns the original, un-tokenized command.\n *\n * @return the original, un-tokenized command.\n */\n public synchronized String getCommand() {\n return command;\n }\n\n /**\n * Returns this command's alias.\n *\n * @return this command's alias.\n */\n public synchronized String getAlias() {\n return alias;\n }\n\n /**\n * Returns the command's type.\n *\n * @return the command's type.\n */\n public synchronized CommandType getType() {\n return type;\n }\n\n public synchronized String getFileMask() {\n return fileMask;\n }\n\n /**\n * Returns the command's display name.\n * true if the command's display name has been set.\n *\n * @return true if the command's display name has been set, false otherwise.\n */\n synchronized boolean isDisplayNameSet() {\n return displayName != null;\n }\n\n @Override\n public int hashCode() {\n int hashCode;\n\n hashCode = alias.hashCode();\n hashCode = hashCode * 31 + command.hashCode();\n hashCode = hashCode * 31 + getDisplayName().hashCode();\n hashCode = hashCode * 31 + type.hashCode();\n\n return hashCode;\n }\n\n @Override\n public boolean equals(Object object) {\n if (!(object instanceof Command cmd)) {\n return false;\n }\n return command.equals(cmd.command) && alias.equals(cmd.alias) && type == cmd.type &&\n getDisplayName().equals(cmd.getDisplayName());\n }\n\n @Override\n public int compareTo(@NotNull Command command) {\n int buffer = getDisplayName().compareTo(command.getDisplayName());\n\n if (buffer != 0) {\n return buffer;\n }\n if ((buffer = getAlias().compareTo(command.getAlias())) != 0) {\n return buffer;\n }\n return this.command.compareTo(command.command);\n }\n\n\n @Override\n public String toString() {\n return alias + (displayName == null ? \"\" : \":\" + displayName) + \":\" + command + (fileMask != null ? \"[\" + fileMask + \"]\" : \"\");\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/command/CommandAssociation.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see CommandAssociation.\n * @param command command that must be executed if the association is matched.\n * @param filter IMAGE_FILTER that files must match in order to be taken into account by the association.\n */\n CommandAssociation(Command command, FileFilter filter) {\n this.command = command;\n this.fileFilter = filter;\n }\n\n /**\n * Returns true if the specified file matches the association.\n * @param file file to match against the association.\n * @return true if the specified file matches the association, false otherwise.\n */\n public boolean accept(AbstractFile file) {return fileFilter.match(file);}\n\n // - Command retrieval -----------------------------------------------------\n // -------------------------------------------------------------------------\n /**\n * Returns the command used in the association.\n * @return the command used in the association.\n */\n public Command getCommand() {return command;}\n\n public FileFilter getFilter() {return fileFilter;}\n}\n"
},
{
"path": "src/main/java/com/mucommander/command/CommandBuilder.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see CommandBuilder allows classes to query these lists regardless of\n * their source.\n *\n * CommandBuilder can rely on their methods to be called in the proper order,\n * and on both their {@link #startBuilding()} and {@link #endBuilding()} methods to be called. Classes that\n * interact with such instances must make sure this contract is respected.\n *\n * \n * public class CommandPrinter implements CommandBuilder {\n * public void startBuilding() {System.out.println(\"Beginning command list building...\");}\n *\n * public void endBuilding() {System.out.println(\"Done.\");}\n *\n * public void addCommand(Command command) throws CommandException {\n * System.out.println(\" - creating command '\" + command.getCommand() + \"' with alias '\" + command.getAlias() + \"'\");\n * }\n * }\n * \n * Passing an instance of CommandPrinter to {@link CommandManager#buildCommands(CommandBuilder, CommandType)}\n * will result in something like:\n * \n * Beginning command list building...\n * - creating command 'open $f' with alias 'open'\n * - creating command 'open -a Safari $f' with alias 'openURL'\n * Done.\n *
\n *\n * @author Nicolas Rinaudo\n * @see CommandReader\n * @see CommandManager#buildCommands(CommandBuilder, CommandType)\n */\npublic interface CommandBuilder {\n /**\n * Notifies the builder that command building is about to start.\n * @throws CommandException if an error occurs.\n */\n void startBuilding() throws CommandException;\n\n /**\n * Notifies the builder that command building is finished.\n * @throws CommandException if an error occurs.\n */\n void endBuilding() throws CommandException;\n\n /**\n * Notifies the builder that a new command has been found.\n * @param command command that has been found.\n * @throws CommandException if an error occurs.\n */\n void addCommand(Command command) throws CommandException;\n}\n"
},
{
"path": "src/main/java/com/mucommander/command/CommandException.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see null if the default one should be used. */\r\n private static AbstractFile associationFile;\r\n /** Whether the associations were modified since the last time they were saved. */\r\n private static boolean wereAssociationsModified;\r\n /** Default name of the association XML file. */\r\n private static final String DEFAULT_ASSOCIATION_FILE_NAME = \"associations.xml\";\r\n\r\n\r\n\r\n // - Commands definition ---------------------------------------------------\r\n // -------------------------------------------------------------------------\r\n\r\n /** Default name of the custom commands file. */\r\n private static final String DEFAULT_COMMANDS_FILE_NAME = \"commands.xml\";\r\n\r\n /** All known commands. */\r\n private static Mapnull if the default one should be used. */\r\n private static AbstractFile commandsFile;\r\n /** Whether the custom commands have been modified since the last time they were saved. */\r\n private static boolean wereCommandsModified;\r\n /** Default command used when no other command is found for a specific file type. */\r\n private static Command defaultCommand;\r\n\r\n\r\n /**\r\n * Prevents instances of CommandManager from being created.\r\n */\r\n private CommandManager() {}\r\n\r\n\r\n\r\n // - Command handling ------------------------------------------------------\r\n // -------------------------------------------------------------------------\r\n /**\r\n * Returns the tokens that compose the command that must be executed to open the specified file.\r\n * {@link #getTokensForFile(AbstractFile,boolean) getTokensForFile(}file, true).\r\n *\r\n * @param file file for which the opening command's tokens must be returned.\r\n * @return the tokens that compose the command that must be executed to open the specified file.\r\n */\r\n public static String[] getTokensForFile(AbstractFile file) {\r\n return getTokensForFile(file, true);\r\n }\r\n\r\n /**\r\n * Returns the tokens that compose the command that must be executed to open the specified file.\r\n * @param file file for which the opening command's tokens must be returned.\r\n * @param allowDefault whether to use the default command if none was found to match the specified file.\r\n * @return the tokens that compose the command that must be executed to open the specified file, null if not found.\r\n */\r\n public static String[] getTokensForFile(AbstractFile file, boolean allowDefault) {\r\n Command command = getCommandForFile(file, allowDefault);\r\n return command == null ? null : command.getTokens(file);\r\n }\r\n\r\n /**\r\n * Returns the command that must be executed to open the specified file.\r\n * {@link #getCommandForFile(AbstractFile,boolean) getCommandForFile(}file, true).\r\n *\r\n * @param file file for which the opening command must be returned.\r\n * @return the command that must be executed to open the specified file.\r\n */\r\n public static Command getCommandForFile(AbstractFile file) {\r\n return getCommandForFile(file, true);\r\n }\r\n\r\n private static Command getCommandForFile(AbstractFile file, Listnull if not found.\r\n */\r\n public static Command getCommandForFile(AbstractFile file, boolean allowDefault) {\r\n Command command = getCommandForFile(file, associations);\r\n // Goes through all known associations and checks whether file matches any.\r\n if (command != null) {\r\n return command;\r\n }\r\n\r\n // Goes through all system associations and checks whether file matches any.\r\n command = getCommandForFile(file, systemAssociations);\r\n if (command != null) {\r\n return command;\r\n }\r\n\r\n // We haven't found a command explicitly associated with 'file', but we might have a generic file opener\r\n if (defaultCommand != null) {\r\n return defaultCommand;\r\n }\r\n\r\n // We don't have a generic file opener, return the 'self execute' command if we're allowed.\r\n if (allowDefault) {\r\n return RUN_AS_EXECUTABLE_COMMAND;\r\n }\r\n return null;\r\n }\r\n\r\n /**\r\n * Returns a sorted collection of all registered commands.\r\n * @return a sorted collection of all registered commands.\r\n */\r\n public static Collectionnull otherwise.\r\n */\r\n public static Command getCommandForAlias(String alias, AbstractFile file) {\r\n ListsetAssociationFile(FileFactory.getFile(file)).\r\n *\r\n * @param path path to the custom associations file.\r\n * @throws FileNotFoundException if file is not accessible.\r\n * @see #getAssociationFile()\r\n * @see #loadAssociations()\r\n * @see #writeAssociations()\r\n */\r\n public static void setAssociationFile(String path) throws FileNotFoundException {\r\n AbstractFile file = FileFactory.getFile(path);\r\n if (file == null) {\r\n setAssociationFile(new File(path));\r\n } else {\r\n setAssociationFile(file);\r\n }\r\n }\r\n\r\n /**\r\n * Sets the path to the custom associations file.\r\n * setAssociationFile(FileFactory.getFile(file.getAbsolutePath())).\r\n *\r\n * @param file path to the custom associations file.\r\n * @throws FileNotFoundException if file is not accessible.\r\n * @see #getAssociationFile()\r\n * @see #loadAssociations()\r\n * @see #writeAssociations()\r\n */\r\n public static void setAssociationFile(File file) throws FileNotFoundException {\r\n setAssociationFile(FileFactory.getFile(file.getAbsolutePath()));\r\n }\r\n\r\n /**\r\n * Sets the path to the custom associations file.\r\n * @param file path to the custom associations file.\r\n * @throws FileNotFoundException if file is not accessible.\r\n * @see #getAssociationFile()\r\n * @see #loadAssociations()\r\n * @see #writeAssociations()\r\n */\r\n public static void setAssociationFile(AbstractFile file) throws FileNotFoundException {\r\n if (file.isBrowsable()) {\r\n throw new FileNotFoundException(\"Not a valid file: \" + file.getAbsolutePath());\r\n }\r\n\r\n associationFile = file;\r\n }\r\n\r\n /**\r\n * Loads the custom associations XML File.\r\n * setCommandFile(FileFactory.getFile(file));.\r\n *\r\n * @param path path to the custom commands file.\r\n * @throws FileNotFoundException if file is not accessible.\r\n * @see #getCommandFile()\r\n * @see #loadCommands()\r\n * @see #writeCommands()\r\n */\r\n public static void setCommandFile(String path) throws FileNotFoundException {\r\n AbstractFile file = FileFactory.getFile(path);\r\n\r\n if (file == null) {\r\n setCommandFile(new File(path));\r\n } else {\r\n setCommandFile(file);\r\n }\r\n }\r\n \r\n\r\n /**\r\n * Sets the path to the custom commands file.\r\n * setCommandFile(FileFactory.getFile(file.getAbsolutePath()));.\r\n *\r\n * @param file path to the custom commands file.\r\n * @throws FileNotFoundException if file is not accessible.\r\n * @see #getCommandFile()\r\n * @see #loadCommands()\r\n * @see #writeCommands()\r\n */\r\n public static void setCommandFile(File file) throws FileNotFoundException {setCommandFile(FileFactory.getFile(file.getAbsolutePath()));}\r\n\r\n /**\r\n * Sets the path to the custom commands file.\r\n * @param file path to the custom commands file.\r\n * @throws FileNotFoundException if file is not accessible.\r\n * @see #getCommandFile()\r\n * @see #loadCommands()\r\n * @see #writeCommands()\r\n */\r\n public static void setCommandFile(AbstractFile file) throws FileNotFoundException {\r\n // Makes sure file can be used as a command file.\r\n if (file.isBrowsable()) {\r\n throw new FileNotFoundException(\"Not a valid file: \" + file.getAbsolutePath());\r\n }\r\n\r\n commandsFile = file;\r\n }\r\n\r\n /**\r\n * Writes Normal registered commands to the custom commands file.\r\n * \n *
\n *\n * @param value String representation of type to analyze.\n * @return type equals {CommandsXmlConstants#VALUE_SYSTEM}, {@link #SYSTEM_COMMAND} will be returned.type equals {CommandsXmlConstants#VALUE_INVISIBLE}, {@link #INVISIBLE_COMMAND} will be returned.type's integer equivalent.\n */\n public static CommandType parseCommandType(String value) {\n \tif (value == null) {\n return NORMAL_COMMAND;\n }\n\n \tfor (CommandType type : CommandType.values()) {\n if (value.equals(type.value)) {\n return type;\n }\n }\n\n \treturn NORMAL_COMMAND;\n }\n\n @Override\n public String toString() {\n \treturn value;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/command/CommandWriter.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see CommandWriter is a {@link CommandBuilder} that will send\n * all build messages it receives into an XML stream (as defined in {@link CommandsXmlConstants}).\n *\n * @author Nicolas Rinaudo\n */\npublic class CommandWriter implements CommandsXmlConstants, CommandBuilder {\n /** Where to write the custom command associations to. */\n private final XmlWriter out;\n\n\n /**\n * Builds a new writer that will send data to the specified output stream.\n * @param stream where to write the XML data.\n * @throws IOException if an IO error occurs.\n */\n CommandWriter(OutputStream stream) throws IOException {\n out = new XmlWriter(stream);\n }\n\n\n /**\n * Opens the root XML element.\n */\n public void startBuilding() throws CommandException {\n try {\n out.startElement(ELEMENT_ROOT);\n out.println();\n } catch(IOException e) {\n throw new CommandException(e);\n }\n }\n\n /**\n * Closes the root XML element.\n */\n public void endBuilding() throws CommandException {\n try {\n out.endElement(ELEMENT_ROOT);\n } catch(IOException e) {\n throw new CommandException(e);\n }\n }\n\n /**\n * Writes the specified command's XML description.\n * @param command command that should be written.\n * @throws CommandException if an error occurs.\n */\n public void addCommand(Command command) throws CommandException {\n // Builds the XML description of the command.\n XmlAttributes attributes = new XmlAttributes();\n attributes.add(ATTRIBUTE_ALIAS, command.getAlias());\n attributes.add(ATTRIBUTE_VALUE, command.getCommand());\n attributes.add(ATTRIBUTE_FILEMASK, command.getFileMask());\n if (command.getType().toString() != null) {\n attributes.add(ATTRIBUTE_TYPE, command.getType().toString());\n }\n if (command.isDisplayNameSet()) {\n attributes.add(ATTRIBUTE_DISPLAY, command.getDisplayName());\n }\n\n // Writes the XML description.\n try {\n out.writeStandAloneElement(ELEMENT_COMMAND, attributes);\n } catch(IOException e) {\n throw new CommandException(e);\n }\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/command/CommandsXmlConstants.java",
"content": "/*\r\n * This file is part of muCommander, http://www.mucommander.com\r\n * Copyright (C) 2002-2012 Maxence Bernard\r\n *\r\n * muCommander is free software; you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation; either version 3 of the License, or\r\n * (at your option) any later version.\r\n *\r\n * muCommander is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see \r\n * <!ELEMENT commands (association*)>\r\n * \r\n * <!ELEMENT command EMPTY>\r\n * <!ATTLIST command value CDATA #REQUIRED>\r\n * <!ATTLIST command alias CDATA #REQUIRED>\r\n * <!ATTLIST command type (system|invisible) #IMPLIED>\r\n * <!ATTLIST command display CDATA #IMPLIED>\r\n *
\r\n * Where:\r\n * \r\n *
\r\n *\r\n * @see CommandReader\r\n * @see CommandWriter\r\n * @author Nicolas Rinaudo\r\n */\r\ninterface CommandsXmlConstants {\r\n /** Root element. */\r\n String ELEMENT_ROOT = \"commands\";\r\n /** Custom command definition element. */\r\n String ELEMENT_COMMAND = \"command\";\r\n\r\n\r\n /** Name of the attribute containing a command's display name. */\r\n String ATTRIBUTE_DISPLAY = \"display\";\r\n /** Name of the attribute containing a command's alias. */\r\n String ATTRIBUTE_ALIAS = \"alias\";\r\n /** Name of the attribute containing a command's value. */\r\n String ATTRIBUTE_VALUE = \"value\";\r\n String ATTRIBUTE_FILEMASK = \"filemask\";\r\n /** Name of the attribute containing a command's type. */\r\n String ATTRIBUTE_TYPE = \"type\";\r\n /** Describes system commands. */\r\n String VALUE_SYSTEM = \"system\";\r\n /** Describes invisible commands. */\r\n String VALUE_INVISIBLE = \"invisible\";\r\n}\r\n"
},
{
"path": "src/main/java/com/mucommander/command/PermissionsFileFilter.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2012 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see PermissionsFileFilter.\n * @param permission permission that will be checked against as defined in {@link com.mucommander.commons.file.FilePermissions}.\n * @param filter whether the specified permission flag must be set for a file to be accepted.\n */\n PermissionsFileFilter(int permission, boolean filter) {\n this.permission = permission;\n this.filter = filter;\n }\n\n public boolean accept(AbstractFile file) {\n return filter == file.getPermissions().getBitValue(USER_ACCESS, permission);\n }\n\n /**\n * Returns the permission that this IMAGE_FILTER will check.\n * @return the permission that this IMAGE_FILTER will check.\n */\n public int getPermission() {\n return permission;\n }\n\n /**\n * Returns true if files must have the IMAGE_FILTER's permission flag set in order to be accepted.\n * @return true if files must have the IMAGE_FILTER's permission flag set in order to be accepted, false otherwise.\n */\n public boolean getFilter() {\n return filter;\n }\n}\n\n"
},
{
"path": "src/main/java/com/mucommander/command/package.html",
"content": "\n Framework used to run system commands and associate them to file types.\n\n"
},
{
"path": "src/main/java/com/mucommander/commons/DummyDecoratedFile.java",
"content": "/*\n * This file is part of trolCommander, http://www.trolsoft.ru/en/soft/trolcommander\n * Copyright (C) 2013-2018 Oleg Trifonov\n *\n * trolCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * trolCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see DummyFile with overwritten {@link #toString()}} method that return a \"nice\" value\n * for local files (without 'file://localhost/')\n *\n * @author Oleg Trifonov\n */\npublic class DummyDecoratedFile extends DummyFile {\n\n private static final String LOCAL_FILE_PREFIX;\n\n static {\n String prefix = \"file://\" + FileURL.LOCALHOST;\n LOCAL_FILE_PREFIX = OsFamily.WINDOWS.isCurrent() ? prefix + '/' : prefix;\n }\n\n public DummyDecoratedFile(FileURL url) {\n super(url);\n }\n\n @Override\n public String toString() {\n String result = super.toString();\n if (result.startsWith(LOCAL_FILE_PREFIX)) {\n return result.substring(LOCAL_FILE_PREFIX.length());\n }\n return result;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/HasProgress.java",
"content": "/*\n * This file is part of trolCommander, http://www.trolsoft.ru/en/soft/trolcommander\n * Copyright (C) 2013-2016 Oleg Trifonov\n *\n * trolCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * trolCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see \n *
\n *\n * Enumeration into an Iterator.\n * @author Nicolas Rinaudo\n */\npublic class EnumeratorEnumerator. */\n private final Enumerationtrue if the iterator has more elements.\n * (In other words, returns true if {@link #next() next} would return an element rather than throwing an exception.)\n * @return true if the iterator has more elements, false otherwise.\n */\n @Override\n public boolean hasNext() {\n return enumeration.hasMoreElements();\n }\n\n /**\n * Returns the next element in the iteration.\n * @return the next element in the iteration.\n * @throws NoSuchElementException if there is no next element in the iteration.\n */\n @Override\n public T next() throws NoSuchElementException {\n return enumeration.nextElement();\n }\n\n /**\n * Operation not supported.\n * @throws UnsupportedOperationException whenever this method is called.\n */\n @Override\n public void remove() {\n throw new UnsupportedOperationException();\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/collections/VectorChangeListener.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see true if there are more sections in the history.\n * @return true if there are more sections in the history.\n */\n boolean hasSections() {\n return !sections.empty();\n }\n\n /**\n * Returns the next section in history.\n * @return the next section in history.\n */\n ConfigurationSection popSection() {\n return sections.pop();\n }\n\n\n /**\n * Move to the specified section.\n * @param name name of the current section's subsection in which to move.\n * @param create if true and name doesn't exist, it will be created.\n * @return true if we could move to name, false otherwise.\n */\n @Override\n public boolean moveTo(String name, boolean create) {\n if (super.moveTo(name, create)) {\n sections.push(getSection());\n return true;\n }\n return false;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/Configuration.java",
"content": "package com.mucommander.commons.conf;\n\nimport java.io.*;\nimport java.nio.charset.StandardCharsets;\nimport java.util.*;\n\n/**\n * Base class for all configuration related tasks.\n * Configuration instance's main goal is to act as a configuration data repository.\n * Once created, it can be used to {@link #getVariable(String) retrieve}, {@link #removeVariable(String) delete}\n * and {@link #setVariable(String,String) set} configuration variables.\n *\n * Naming conventions
\n *
\n * For example, startup_folder.right.last_folder is interpreted as a variable called\n * last_folder contained in a section called right, itself contained in\n * another section called startup_folder.
\n *\n * Variable types
\n * com.mucommander.commons.conf really only handles one type of variables, strings, it offers\n * tools to cast them as primitive Java types (int, long, float, double, boolean). This is done through the use\n * of the various primitive types' class implementation parseXXX method.
\n * When a variable hasn't been set but ant attempt is made to cast it, the standard Java default value will\n * be returned:\n * \n *
\n *\n * null0000falseConfiguration file format
\n * Configuration data location
\n * Configuration provides read and write methods that accept streams as parameters, it's\n * also possible to set the data source once and for all and let the API deal with the details. This can\n * be achieved through the {@link #setSource(ConfigurationSource) setSource} method.
\n * Note that a default implementation, {@link FileConfigurationSource}, is provided. It covers the most\n * common case of configuration sources, a local configuration file.
\n * For application writers who wish to be able to retrieve configuration files through a variety of file systems,\n * we suggest creating a source using the com.mucommander.file API.\n *\n * Monitoring configuration changes
\n *
\n * Note that LISTENERS are stored as weak references, meaning that application writers must ensure that they keep\n * direct references to the listener instances they register if they do not want them to be garbaged collected\n * out of existence randomly.\n *\n * @author Nicolas Rinaudo\n */\npublic class Configuration {\n /** Used to get access to the configuration source's input and output streams. */\n private ConfigurationSource source;\n /** Used to create objects that will read from the configuration source. */\n private ConfigurationReaderFactory readerFactory;\n /** Used to create objects that will write to the configuration source. */\n private ConfigurationWriterFactory writerFactory;\n /** Holds the content of the configuration file. */\n private final ConfigurationSection root = new ConfigurationSection();\n /** Contains all registered configuration LISTENERS, stored as weak references. */\n private final WeakHashMapConfiguration.\n * Configuration using the specified source.\n * Configuration using the specified format.\n * Configuration using the specified source and format.\n * @param source where the resulting instance will look for its configuration data.\n * @param reader factory for configuration readers.\n * @param writer factory for configuration writers.\n */\n public Configuration(ConfigurationSource source, ConfigurationReaderFactory reader, ConfigurationWriterFactory writer) {\n setSource(source);\n setReaderFactory(reader);\n setWriterFactory(writer);\n }\n\n\n /**\n * Sets the source that will be used to read and write configuration information.\n * @param s new configuration source.\n * @see #getSource()\n */\n public void setSource(ConfigurationSource s) {\n synchronized(sourceLock) {\n source = s;\n }\n }\n\n /**\n * Returns the current configuration source.\n * @return the current configuration source, or null if it hasn't been set.\n * @see #setSource(ConfigurationSource)\n */\n public ConfigurationSource getSource() {\n synchronized(sourceLock) {\n return source;\n }\n }\n\n\n /**\n * Sets the factory that will be used to create {@link ConfigurationReader reader} instances.\n * null parameter.\n *\n * @param f factory that will be used to create reader instances.\n * @see #getReaderFactory()\n */\n void setReaderFactory(ConfigurationReaderFactory f) {\n synchronized(readerLock) {\n readerFactory = f;\n }\n }\n\n /**\n * Returns the factory that is being used to create {@link ConfigurationReader reader} instances.\n * null parameter.\n *\n * @param f factory that will be used to create writer instances.\n * @see #getWriterFactory()\n */\n void setWriterFactory(ConfigurationWriterFactory f) {\n synchronized(writerLock) {\n writerFactory = f;\n }\n }\n\n /**\n * Returns the factory that is being used to create writer instances.\n * in.\n * @throws IOException if an I/O error occurs.\n * @throws ConfigurationException if a configuration error occurs.\n * @throws ConfigurationFormatException if a syntax error occurs in the configuration data.\n * @throws ConfigurationStructureException if the configuration data doesn't describe a valid configuration tree.\n * @see #read(InputStream)\n * @see #read(ConfigurationReader)\n * @see #read()\n */\n synchronized void read(Reader in, ConfigurationReader reader) throws IOException, ConfigurationException {\n reader.read(in, new ConfigurationLoader(root));\n }\n\n /**\n * Loads configuration from the specified input stream.\n * UTF-8 encoded.\n */\n @Deprecated\n public void read(InputStream in) throws ConfigurationException, IOException {\n read(new InputStreamReader(in, StandardCharsets.UTF_8), getReaderFactory().getReaderInstance());\n }\n\n /**\n * Loads configuration from the specified reader.\n * in.\n * @throws IOException if an I/O error occurs.\n * @throws ConfigurationException if a configuration error occurs.\n * @throws SourceConfigurationException if no {@link ConfigurationSource} has been set.\n * @throws ConfigurationFormatException if a syntax error occurs in the configuration data.\n * @throws ConfigurationStructureException if the configuration data doesn't describe a valid configuration tree.\n * @see #read(InputStream)\n * @see #read()\n * @see #read(Reader,ConfigurationReader)\n */\n public void read(ConfigurationReader reader) throws IOException, ConfigurationException {\n ConfigurationSource source = getSource(); // Configuration source.\n\n // Makes sure the configuration source has been properly set.\n if (source == null) {\n throw new SourceConfigurationException(\"Configuration source hasn't been set.\");\n }\n // Reads the configuration data.\n try (Reader in = source.getReader()) {\n read(in, reader);\n }\n }\n\n /**\n * Loads configuration.\n * fromVar to toVar.\n * fromVar will have been deleted. Note that if fromVar doesn't\n * exist, but toVar does, toVar will be deleted.\n *\n * \n *
\n * The removal event will always be triggered first.\n *\n * @param fromVar fully qualified name of the variable to rename.\n * @param toVar fully qualified name of the variable that will receive fromVar is removed.toVar is set.fromVar's value.\n */\n public void renameVariable(String fromVar, String toVar) {\n setVariable(toVar, removeVariable(fromVar));\n }\n\n /**\n * Sets the value of the specified variable.\n * false if it didn't modify name's value. Note that this doesn't\n * mean the call failed, but that name's value was already equal to value.\n *\n * true if this call resulted in a modification of the variable's value,\n * false otherwise.\n * @see #getVariable(String)\n * @see #getVariable(String,String)\n */\n public synchronized boolean setVariable(String name, String value) {\n ConfigurationExplorer explorer = new ConfigurationExplorer(root); // Used to navigate to the variable's parent section.\n\n // Moves to the parent section.\n String buffer = moveToParent(explorer, name, true); // Buffer for the variable's name trimmed of section information.\n\n // If the variable's value was actually modified, triggers an event.\n if (explorer.getSection().setVariable(buffer, value)) {\n triggerEvent(new ConfigurationEvent(this, name, value));\n return true;\n }\n return false;\n }\n\n /**\n * Sets the value of the specified variable.\n * false if it didn't modify name's value. This, however, is not a\n * way of indicating that the call failed: false is only ever returned if the previous value is equal\n * to the new value.\n *\n * true if this call resulted in a modification of the variable's value,\n * false otherwise.\n * @see #getIntegerVariable(String)\n * @see #getVariable(String,int)\n */\n public boolean setVariable(String name, int value) {\n return setVariable(name, ConfigurationSection.getValue(value));\n }\n\n /**\n * Sets the value of the specified variable.\n * false if it didn't modify name's value. This, however, is not a\n * way of indicating that the call failed: false is only ever returned if the previous value is equal\n * to the new value.\n *\n * true if this call resulted in a modification of the variable's value,\n * false otherwise.\n * @see #getListVariable(String,String)\n * @see #getVariable(String,List,String)\n */\n public boolean setVariable(String name, Listfalse if it didn't modify name's value. This, however, is not\n * a way of indicating that the call failed: false is only ever returned if the previous value is equal\n * to the new value.\n *\n * true if this call resulted in a modification of the variable's value,\n * false otherwise.\n * @see #getFloatVariable(String)\n * @see #getVariable(String,float)\n */\n public boolean setVariable(String name, float value) {return setVariable(name, ConfigurationSection.getValue(value));}\n\n /**\n * Sets the value of the specified variable.\n * false if it didn't modify name's value. This, however, is not a\n * way of indicating that the call failed: false is only ever returned if the previous value is equal\n * to the new value.\n *\n * true if this call resulted in a modification of the variable's value,\n * false otherwise.\n * @see #getBooleanVariable(String)\n * @see #getVariable(String,boolean)\n */\n public boolean setVariable(String name, boolean value) {\n return setVariable(name, ConfigurationSection.getValue(value));\n }\n\n /**\n * Sets the value of the specified variable.\n * false if it didn't modify name's value. This, however, is not a\n * way of indicating that the call failed: false is only ever returned if the previous value is equal\n * to the new value.\n *\n * true if this call resulted in a modification of the variable's value,\n * false otherwise.\n * @see #getLongVariable(String)\n * @see #getVariable(String,long)\n */\n public boolean setVariable(String name, long value) {\n return setVariable(name, ConfigurationSection.getValue(value));\n }\n\n /**\n * Sets the value of the specified variable.\n * false if it didn't modify name's value. This, however, is not a\n * way of indicating that the call failed: false is only ever returned if the previous value is equal\n * to the new value.\n *\n * true if this call resulted in a modification of the variable's value,\n * false otherwise.\n * @see #getDoubleVariable(String)\n * @see #getVariable(String,double)\n */\n public boolean setVariable(String name, double value) {return setVariable(name, ConfigurationSection.getValue(value));}\n\n\n /**\n * Returns the value of the specified variable.\n * @param name fully qualified name of the variable whose value should be retrieved.\n * @return the variable's value if set, null otherwise.\n * @see #setVariable(String,String)\n * @see #getVariable(String,String)\n */\n public synchronized String getVariable(String name) {\n // If the variable's 'path' doesn't exist, return null.\n ConfigurationExplorer explorer = new ConfigurationExplorer(root); // Used to navigate to the variable's parent section.\n name = moveToParent(explorer, name, false);\n return name == null ? null : explorer.getSection().getVariable(name);\n }\n\n /**\n * Returns the value of the specified variable as a {@link ValueList}.\n * @param name fully qualified name of the variable whose value should be retrieved.\n * @param separator character used to split the variable's value into a list.\n * @return the variable's value if set, null otherwise.\n * @see #setVariable(String,List,String)\n * @see #getVariable(String,List,String)\n */\n public ValueList getListVariable(String name, String separator) {\n return ConfigurationSection.getListValue(getVariable(name), separator);\n }\n\n /**\n * Returns the value of the specified variable as an integer.\n * @param name fully qualified name of the variable whose value should be retrieved.\n * @return the variable's value if set, 0 otherwise.\n * @throws NumberFormatException if the variable's value cannot be cast to an integer.\n * @see #setVariable(String,int)\n * @see #getVariable(String,int)\n */\n public int getIntegerVariable(String name) {\n return ConfigurationSection.getIntegerValue(getVariable(name));\n }\n\n /**\n * Returns the value of the specified variable as a long.\n * @param name fully qualified name of the variable whose value should be retrieved.\n * @return the variable's value if set, 0 otherwise.\n * @throws NumberFormatException if the variable's value cannot be cast to a long.\n * @see #setVariable(String,long)\n * @see #getVariable(String,long)\n */\n public long getLongVariable(String name) {\n return ConfigurationSection.getLongValue(getVariable(name));\n }\n\n /**\n * Returns the value of the specified variable as a float.\n * @param name fully qualified name of the variable whose value should be retrieved.\n * @return the variable's value if set, 0 otherwise.\n * @throws NumberFormatException if the variable's value cannot be cast to a float.\n * @see #setVariable(String,float)\n * @see #getVariable(String,float)\n */\n public float getFloatVariable(String name) {\n return ConfigurationSection.getFloatValue(getVariable(name));\n }\n\n /**\n * Returns the value of the specified variable as a double.\n * @param name fully qualified name of the variable whose value should be retrieved.\n * @return the variable's value if set, 0 otherwise.\n * @throws NumberFormatException if the variable's value cannot be cast to a double.\n * @see #setVariable(String,double)\n * @see #getVariable(String,double)\n */\n public double getDoubleVariable(String name) {\n return ConfigurationSection.getDoubleValue(getVariable(name));\n }\n\n /**\n * Returns the value of the specified variable as a boolean.\n * @param name fully qualified name of the variable whose value should be retrieved.\n * @return the variable's value if set, false otherwise.\n * @see #setVariable(String,boolean)\n * @see #getVariable(String,boolean)\n */\n public boolean getBooleanVariable(String name) {\n return ConfigurationSection.getBooleanValue(getVariable(name));\n }\n\n /**\n * Checks whether the specified variable has been set.\n * @param name fully qualified name of the variable to check for.\n * @return true if the variable is set, false otherwise.\n */\n public boolean isVariableSet(String name) {\n return getVariable(name) != null;\n }\n\n\n\n /**\n * Prunes dead branches from the specified configuration tree.\n * @param explorer used to backtrack through the configuration tree.\n */\n private void prune(BufferedConfigurationExplorer explorer) {\n // If we're at the root level, nothing to prune.\n if (!explorer.hasSections()) {\n return;\n }\n\n ConfigurationSection current = explorer.popSection();\n\n // Look for branches to prune until we've either found a non-empty one\n // or reached the root of the three.\n while (current.isEmpty() && current != root) {\n // Gets the current section's parent and prune.\n ConfigurationSection parent = explorer.hasSections() ? explorer.popSection() : root;\n parent.removeSection(current);\n current = parent;\n }\n }\n\n /**\n * Deletes the specified variable from the configuration.\n * null if it wasn't set.\n */\n public synchronized String removeVariable(String name) {\n BufferedConfigurationExplorer explorer = new BufferedConfigurationExplorer(root); // Used to navigate to the variable's parent section.\n String buffer = moveToParent(explorer, name, false); // Buffer for the variable's name trimmed of section information.\n\n // If the variable's 'path' doesn't exist, return null.\n if (buffer == null) {\n return null;\n }\n // If the variable was actually set, triggers an event.\n if ((buffer = explorer.getSection().removeVariable(buffer)) != null) {\n prune(explorer);\n triggerEvent(new ConfigurationEvent(this, name, null));\n }\n\n return buffer;\n }\n\n /**\n * Deletes the specified variable from the configuration.\n * null if it wasn't set.\n */\n public ValueList removeListVariable(String name, String separator) {\n return ConfigurationSection.getListValue(removeVariable(name), separator);\n }\n\n /**\n * Deletes the specified variable from the configuration.\n * 0 if it wasn't set.\n */\n public int removeIntegerVariable(String name) {\n return ConfigurationSection.getIntegerValue(removeVariable(name));\n }\n\n /**\n * Deletes the specified variable from the configuration.\n * 0 if it wasn't set.\n */\n public long removeLongVariable(String name) {\n return ConfigurationSection.getLongValue(removeVariable(name));\n }\n\n /**\n * Deletes the specified variable from the configuration.\n * 0 if it wasn't set.\n */\n public float removeFloatVariable(String name) {\n return ConfigurationSection.getFloatValue(removeVariable(name));\n }\n\n /**\n * Deletes the specified variable from the configuration.\n * 0 if it wasn't set.\n */\n public double removeDoubleVariable(String name) {\n return ConfigurationSection.getDoubleValue(removeVariable(name));\n }\n\n /**\n * Deletes the specified variable from the configuration.\n * false if it wasn't set.\n */\n public boolean removeBooleanVariable(String name) {\n return ConfigurationSection.getBooleanValue(removeVariable(name));\n }\n\n /**\n * Remove all variables and sub-sections under the root section\n */\n public void clear() {\n\t\troot.clear();\n\t}\n\n\n // - Advanced variable retrieval -----------------------------------------------------------------------------------\n // -----------------------------------------------------------------------------------------------------------------\n /**\n * Retrieves the value of the specified variable.\n * defaultValue before\n * returning it. If this happens, a configuration {@link ConfigurationEvent event} will\n * be sent to all registered LISTENERS.\n *\n * @param name name of the variable to retrieve.\n * @param defaultValue value to use if name is not set.\n * @return the specified variable's value.\n * @see #setVariable(String,String)\n * @see #getVariable(String)\n */\n public synchronized String getVariable(String name, String defaultValue) {\n ConfigurationExplorer explorer = new ConfigurationExplorer(root); // Used to navigate to the variable's parent section.\n\n // Navigates to the parent section. We do not have to check for null values here,\n // as the section will be created if it doesn't exist.\n String buffer = moveToParent(explorer, name, true); // Buffer for the variable's name trimmed of section information.\n\n // If the variable isn't set, set it to defaultValue and triggers an event.\n String value = explorer.getSection().getVariable(buffer); // Buffer for the variable's value.\n if (value == null) {\n explorer.getSection().setVariable(buffer, defaultValue);\n triggerEvent(new ConfigurationEvent(this, name, defaultValue));\n return defaultValue;\n }\n return value;\n }\n\n /**\n * Retrieves the value of the specified variable as a {@link ValueList}.\n * defaultValue before\n * returning it. If this happens, a configuration {@link ConfigurationEvent event} will\n * be sent to all registered LISTENERS.\n *\n * @param name name of the variable to retrieve.\n * @param defaultValue value to use if variable name is not set.\n * @param separator separator to use for defaultValue if variable name is not set.\n * @return the specified variable's value.\n * @see #setVariable(String,List,String)\n * @see #getListVariable(String,String)\n */\n public ValueList getVariable(String name, ListdefaultValue before\n * returning it. If this happens, a configuration {@link ConfigurationEvent event} will\n * be sent to all registered LISTENERS.\n *\n * @param name name of the variable to retrieve.\n * @param defaultValue value to use if name is not set.\n * @return the specified variable's value.\n * @throws NumberFormatException if the variable's value cannot be cast to an integer.\n * @see #setVariable(String,int)\n * @see #getIntegerVariable(String)\n */\n public int getVariable(String name, int defaultValue) {\n return ConfigurationSection.getIntegerValue(getVariable(name, ConfigurationSection.getValue(defaultValue)));\n }\n\n /**\n * Retrieves the value of the specified variable as a long.\n * defaultValue before\n * returning it. If this happens, a configuration {@link ConfigurationEvent event} will\n * be sent to all registered LISTENERS.\n *\n * @param name name of the variable to retrieve.\n * @param defaultValue value to use if name is not set.\n * @return the specified variable's value.\n * @throws NumberFormatException if the variable's value cannot be cast to a long.\n * @see #setVariable(String,long)\n * @see #getLongVariable(String)\n */\n public long getVariable(String name, long defaultValue) {\n return ConfigurationSection.getLongValue(getVariable(name, ConfigurationSection.getValue(defaultValue)));\n }\n\n /**\n * Retrieves the value of the specified variable as a float.\n * defaultValue before\n * returning it. If this happens, a configuration {@link ConfigurationEvent event} will\n * be sent to all registered LISTENERS.\n *\n * @param name name of the variable to retrieve.\n * @param defaultValue value to use if name is not set.\n * @return the specified variable's value.\n * @throws NumberFormatException if the variable's value cannot be cast to a float.\n * @see #setVariable(String,float)\n * @see #getFloatVariable(String)\n */\n public float getVariable(String name, float defaultValue) {\n return ConfigurationSection.getFloatValue(getVariable(name, ConfigurationSection.getValue(defaultValue)));\n }\n\n /**\n * Retrieves the value of the specified variable as a boolean.\n * defaultValue before\n * returning it. If this happens, a configuration {@link ConfigurationEvent event} will\n * be sent to all registered LISTENERS.\n *\n * @param name name of the variable to retrieve.\n * @param defaultValue value to use if name is not set.\n * @return the specified variable's value.\n * @see #setVariable(String,boolean)\n * @see #getBooleanVariable(String)\n */\n public boolean getVariable(String name, boolean defaultValue) {\n return ConfigurationSection.getBooleanValue(getVariable(name, ConfigurationSection.getValue(defaultValue)));\n }\n\n /**\n * Retrieves the value of the specified variable as a double.\n * defaultValue before\n * returning it. If this happens, a configuration {@link ConfigurationEvent event} will\n * be sent to all registered LISTENERS.\n *\n * @param name name of the variable to retrieve.\n * @param defaultValue value to use if name is not set.\n * @return the specified variable's value.\n * @throws NumberFormatException if the variable's value cannot be cast to a double.\n * @see #setVariable(String,double)\n * @see #getDoubleVariable(String)\n */\n public double getVariable(String name, double defaultValue) {\n return ConfigurationSection.getDoubleValue(getVariable(name, ConfigurationSection.getValue(defaultValue)));\n }\n\n\n\n // - Helper methods ------------------------------------------------------------------------------------------------\n // -----------------------------------------------------------------------------------------------------------------\n /**\n * Navigates the specified explorer to the parent section of the specified variable.\n * @param root where to start exploring from.\n * @param name name of the variable to seek.\n * @param create whether the path to the variable should be created if it doesn't exist.\n * @return the name of the variable trimmed of section information, null if not found.\n */\n private String moveToParent(ConfigurationExplorer root, String name, boolean create) {\n // Goes through each element of the path.\n StringTokenizer parser = new StringTokenizer(name, \".\");\n while (parser.hasMoreTokens()) {\n // If we've reached the variable's name, return it.\n name = parser.nextToken();\n if (!parser.hasMoreTokens())\n return name;\n\n // If we've reached a dead-end, return null.\n if (!root.moveTo(name, create)) {\n return null;\n }\n }\n return name;\n }\n\n\n\n // - Configuration listening ---------------------------------------------------------------------------------------\n // -----------------------------------------------------------------------------------------------------------------\n /**\n * Adds the specified object to the list of registered configuration LISTENERS.\n * @param listener object to register as a configuration listener.\n * @see #removeConfigurationListener(ConfigurationListener)\n */\n public void addConfigurationListener(ConfigurationListener listener) {\n LISTENERS.put(listener, null);}\n\n /**\n * Removes the specified object from the list of registered configuration LISTENERS.\n * @param listener object to remove from the list of registered configuration LISTENERS.\n * @see #addConfigurationListener(ConfigurationListener)\n */\n public void removeConfigurationListener(ConfigurationListener listener) {\n LISTENERS.remove(listener);}\n\n /**\n * Passes the specified event to all registered configuration LISTENERS.\n * @param event event to propagate.\n */\n private void triggerEvent(ConfigurationEvent event) {\n for (ConfigurationListener listener : LISTENERS.keySet()) {\n listener.configurationChanged(event);\n }\n }\n\n\n\n /**\n * Returns the configuration's root section.\n * @return the configuration's root section.\n */\n ConfigurationSection getRoot() {\n return root;\n }\n\n\n\n /**\n * Used to load configuration.\n * @author Nicolas Rinaudo\n */\n private class ConfigurationLoader implements ConfigurationBuilder {\n /** Parents of {@link #currentSection}. */\n private Stackcom.mucommander.commons.conf API comes with a default no-op implementation,\n * {@link DefaultConfigurationBuilder}. This can be used instead of ConfigurationBuilder\n * when only a subset of the possible events are of interest.\n *\n * @author Nicolas Rinaudo\n * @see DefaultConfigurationBuilder\n */\npublic interface ConfigurationBuilder {\n /**\n * Receives notification at the beginning of the configuration.\n * startSection event, even if the section is empty. All the section's content will be\n * reported, in order, before the corresponding {@link #endSection(String) endSection} event.\n *\n * @param name name of the new section.\n * @throws ConfigurationException any Configuration error, possibly wrapping another exception.\n */\n void startSection(String name) throws ConfigurationException;\n\n /**\n * Receives notification at the end of a section.\n * endSection\n * event, even if the section is empty.\n *\n * @param name name of the finished section.\n * @throws ConfigurationException any Configuration error, possibly wrapping another exception.\n */\n void endSection(String name) throws ConfigurationException;\n\n /**\n * Receives notification of variable definition.\n * ConfigurationEvent when the event occurs.\n *\n * @see ConfigurationListener\n * @see Configuration\n * @author Nicolas Rinaudo\n */\npublic class ConfigurationEvent {\n /** Name of the variable that has been modified. */\n private final String name;\n /** Variable's new value. */\n private final String value;\n /** Configuration to which the event relates. */\n private final Configuration configuration;\n\n\n /**\n * Creates a new configuration event.\n * name in configuration\n * configuration, and indicate that it has been set to value.\n *\n * null is an accepted value for parameter value, and will be\n * interpreted to mean that the variable has been deleted.\n *\n * @param configuration configuration to which the event relates.\n * @param name name of the variable that was modified.\n * @param value value of the variable that was modified.\n */\n public ConfigurationEvent(Configuration configuration, String name, String value) {\n this.name = name;\n this.value = value;\n this.configuration = configuration;\n }\n\n\n /**\n * Returns the configuration to which the event relates.\n * @return the configuration to which the event relates.\n */\n public Configuration getConfiguration() {\n return configuration;\n }\n\n /**\n * Returns the name of the variable that was modified.\n * test.somevar, this is what this method will return,\n * not somevar.\n *\n * @return the name of the variable that was modified.\n */\n public String getVariable() {\n return name;\n }\n\n /**\n * Returns the new value for the modified variable.\n * null.\n *\n * @return the new value for the modified variable.\n */\n public String getValue() {\n return value;\n }\n\n /**\n * Returns the new value for the modified variable cast as an integer.\n * false.\n *\n * @return the new value for the modified variable.\n */\n public boolean getBooleanValue() {\n return ConfigurationSection.getBooleanValue(value);\n }\n\n /**\n * Returns the new value for the modified variable as a long.\n * com.mucommander.commons.conf API\n * or the application. Application writers can subclass it to provide additional functionality. Different\n * classes of the com.mucommander.commons.conf API may throw this exception or any exception subclassed\n * from it.\n * ConfigurationException or an exception derived from it.\n *\n * @author Nicolas Rinaudo\n */\npublic class ConfigurationException extends Exception {\n /**\n * Creates a new configuration exception.\n * @param message the error message.\n */\n public ConfigurationException(String message) {super(message);}\n\n /**\n * Creates a new configuration exception wrapping an existing exception.\n * ConfigurationException.\n *\n * @param cause the exception to be wrapped in a ConfigurationException.\n */\n public ConfigurationException(Throwable cause) {super(cause);}\n\n /**\n * Creates a new configuration exception from an existing exception.\n * ConfigurationException.\n */\n public ConfigurationException(String message, Throwable cause) {super(message, cause);}\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/ConfigurationExplorer.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see true and name doesn't exist, it will be created.\n * @return true if we could move to name, false otherwise.\n */\n public boolean moveTo(String name, boolean create) {\n ConfigurationSection buffer = section.getSection(name); // Buffer for the subsection.\n // Checks whether the requested subsection exists.\n if (buffer == null) {\n // If it doesn't exist, either return false or create it depending on parameters.\n if (create) {\n section = section.addSection(name);\n return true;\n }\n return false;\n }\n\n section = buffer;\n return true;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/ConfigurationFormatException.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see com.mucommander.commons.conf API, format errors\n * are syntax errors in a configuration source.\n * ConfigurationFormatException might provide information\n * about the position in the source at which the error occurred. See the documentation of\n * {@link #getLineNumber() getLineNumber} and {@link #getColumnNumber() getColumnNumber} for more\n * information on location conventions.\n * ConfigurationFormatException subclasses {@link ConfigurationException}, it\n * inherits his capacity to wrap other exceptions.\n *\n * @author Nicolas Rinaudo\n */\npublic class ConfigurationFormatException extends ConfigurationException {\n /** Describes an unknown {@link #getLineNumber() line} or {@link #getColumnNumber() column} value.*/\n public static final int UNKNOWN_LOCATION = -1;\n\n\n /** Line at which the error occurred. */\n private int line = UNKNOWN_LOCATION;\n /** Column at which the error occurred. */\n private int column = UNKNOWN_LOCATION;\n\n\n /**\n * Creates a new configuration format exception.\n * @param message the error message.\n */\n public ConfigurationFormatException(String message) {super(message);}\n\n /**\n * Creates a new configuration format exception.\n * line and column.\n * See the documentation of {@link #getLineNumber() getLineNumber} and\n * {@link #getColumnNumber() getColumnNumber} for more information on location conventions.\n *\n * @param message the error message.\n * @param line line at which the error occurred.\n * @param column column at which the error occurred.\n */\n public ConfigurationFormatException(String message, int line, int column) {\n this(message);\n setLocationInformation(line, column);\n }\n\n /**\n * Creates a new configuration format exception wrapping an existing exception.\n * ConfigurationFormatException.\n *\n * @param cause the exception to be wrapped in a ConfigurationFormatException.\n */\n public ConfigurationFormatException(Throwable cause) {super(cause == null ? null : cause.getMessage(), cause);}\n\n /**\n * Creates a new configuration format exception wrapping an existing exception.\n * ConfigurationFormatException.\n * line and column.\n * See the documentation of {@link #getLineNumber() getLineNumber} and\n * {@link #getColumnNumber() getColumnNumber} for more information on location conventions.\n *\n * @param cause the exception to be wrapped in a ConfigurationFormatException.\n * @param line line at which the error occurred.\n * @param column column at which the error occurred.\n */\n public ConfigurationFormatException(Throwable cause, int line, int column) {\n this(cause);\n setLocationInformation(line, column);\n }\n\n /**\n * Creates a new configuration format exception from an existing exception.\n * ConfigurationFormatException.\n */\n public ConfigurationFormatException(String message, Throwable cause) {\n super(message, cause);\n }\n\n /**\n * Creates a new configuration format exception from an existing exception.\n * line and column.\n * See the documentation of {@link #getLineNumber() getLineNumber} and\n * {@link #getColumnNumber() getColumnNumber} for more information on location conventions.\n *\n * @param message the detail message.\n * @param cause the exception to be wrapped in a ConfigurationFormatException.\n * @param line line at which the error occurred.\n * @param column column at which the error occurred.\n */\n public ConfigurationFormatException(String message, Throwable cause, int line, int column) {\n this(message, cause);\n setLocationInformation(line, column);\n }\n\n\n /**\n * Sets the position in the stream at which the error occurred.\n * @param line line at which the error occurred.\n * @param column column at which the error occurred.\n */\n private void setLocationInformation(int line, int column) {\n this.line = line;\n this.column = column;\n }\n\n /**\n * Returns the line at which the error occurred.\n * 1 will describe the\n * first line in the configuration source.\n *\n * @return the line at which the error occurred, {@link #UNKNOWN_LOCATION} if the information is not\n * available or relevant.\n * @see #getColumnNumber()\n */\n public int getLineNumber() {return line;}\n\n /**\n * Returns the column at which the error occurred.\n * 1 will describe the first character in the current line.\n *\n * @return the column at which the error occurred, {@link #UNKNOWN_LOCATION} if the information is not\n * available or relevant.\n * @see #getLineNumber()\n */\n public int getColumnNumber() {return column;}\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/ConfigurationListener.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see com.mucommander.commons.conf package comes with a default implementation,\n * {@link XmlConfigurationReader}, which handles the standard muCommander configuration file format.\n * ConfigurationReader to be usable by\n * {@link Configuration configuration} instances, it must come with an associated implementation of\n * {@link ConfigurationReaderFactory}.\n * ConfigurationException.getCause().\n */\n void read(Reader in, ConfigurationBuilder builder) throws ConfigurationException, IOException;\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/ConfigurationReaderFactory.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see ConfigurationReaderFactory's sole purpose is to create instances of {@link ConfigurationReader}. In most cases, a\n * factory class will be associated with a reader class, and its code will look something like:\n * \n * public class MyReaderFactory implements ConfigurationReaderFactory {\n * public ConfigurationReader getReaderInstance() {return new MyReader();}\n * }\n * \n *\n * @author Nicolas Rinaudo\n * @see ConfigurationReader\n */\npublic interface ConfigurationReaderFactorynull if none.\n */\n public String removeVariable(String name) {\n return variables.remove(name);\n }\n\n /**\n * Returns the value of the specified variable.\n * @param name name of the variable whose value should be returned.\n * @return the value of the specified variable, or null if it wasn't set.\n */\n public String getVariable(String name) {\n return variables.get(name);\n }\n\n /**\n * Sets the specified variable to the specified value.\n * value is either null or an empty string,\n * the call will be equivalent to {@link #removeVariable(String)}.\n *\n * @param name name of the variable to set.\n * @param value value for the variable.\n * @return true if the variable's value was changed as a result of this call, false\n * otherwise.\n */\n public boolean setVariable(String name, String value) {\n // If the specified value is empty, deletes the variable.\n if (value == null || value.trim().isEmpty()) {\n // If the variable wasn't set, we haven't changed its value.\n if (getVariable(name) == null) {\n return false;\n }\n\n // Otherwise, deletes it and returns true.\n removeVariable(name);\n return true;\n }\n\n // Compares the variable's new and old values.\n String buffer = variables.put(name, value);\n return buffer == null || !buffer.equals(value);\n }\n\n /**\n * Returns a set on the names of the variables that are defined in the section.\n * true if the section contains any variable.\n * @return true if the section contains any variable, false otherwise.\n */\n public boolean hasVariables() {\n return !variables.isEmpty();\n }\n\n\n\n /**\n * Casts the specified value into an integer.\n * value is null, this method will return 0.\n *\n * @param value value to cast to an integer.\n * @return value as an integer.\n */\n public static int getIntegerValue(String value) {\n return value == null ? 0 : Integer.parseInt(value);\n }\n\n /**\n * Casts the specified value into a value list.\n * value is null, this method will return null.\n *\n * @param value value to cast to a value list.\n * @param separator string used to separate data in tokens.\n * @return value as a value list.\n */\n public static ValueList getListValue(String value, String separator) {\n return value == null ? null : new ValueList(value, separator);\n }\n\n /**\n * Casts the specified value into a float.\n * value is null, this method will return 0.\n *\n * @param value value to cast to a float.\n * @return value as a float.\n */\n public static float getFloatValue(String value) {\n return value == null ? 0 : Float.parseFloat(value);\n }\n\n /**\n * Casts the specified value into an boolean.\n * value is null, this method will return false.\n *\n * @param value value to cast to an boolean.\n * @return value as an boolean.\n */\n public static boolean getBooleanValue(String value) {\n return Boolean.TRUE.toString().equals(value);\n }\n\n /**\n * Casts the specified value into an long.\n * value is null, this method will return 0.\n *\n * @param value value to cast to an long.\n * @return value as an long.\n */\n public static long getLongValue(String value) {\n return value == null ? 0 : Long.parseLong(value);\n }\n\n /**\n * Casts the specified value into an double.\n * value is null, this method will return 0.\n *\n * @param value value to cast to an double.\n * @return value as an double.\n */\n public static double getDoubleValue(String value) {\n return value == null ? 0 : Double.parseDouble(value);\n }\n\n /**\n * Casts the specified value into a string.\n * @param value value to cast as a string.\n * @return value as a string.\n */\n public static String getValue(int value) {\n return Integer.toString(value);\n }\n\n /**\n * Casts the specified value into a string.\n * @param value value to cast as a string.\n * @param separator string to use as a separator.\n * @return value as a string.\n */\n public static String getValue(Listvalue as a string.\n */\n public static String getValue(float value) {\n return Float.toString(value);\n }\n\n /**\n * Casts the specified value into a string.\n * @param value value to cast as a string.\n * @return value as a string.\n */\n public static String getValue(boolean value) {\n return Boolean.toString(value);\n }\n\n /**\n * Casts the specified value into a string.\n * @param value value to cast as a string.\n * @return value as a string.\n */\n public static String getValue(long value) {\n return Long.toString(value);\n }\n\n /**\n * Casts the specified value into a string.\n * @param value value to cast as a string.\n * @return value as a string.\n */\n public static String getValue(double value) {\n return Double.toString(value);\n }\n\n\n\n // - Section access ------------------------------------------------------------------------------------------------\n // -----------------------------------------------------------------------------------------------------------------\n /**\n * Creates a subsection wit the specified name in the section.\n * null otherwise.\n */\n public ConfigurationSection removeSection(String name) {\n return sections.remove(name);\n }\n\n /**\n * Deletes the specified section.\n * true if the specified section was removed, false if it didn't exist.\n */\n public boolean removeSection(ConfigurationSection section) {\n Setnull otherwise.\n */\n public ConfigurationSection getSection(String name) {\n return sections.get(name);\n }\n\n /**\n * Returns an set on all of this section's subsections' names.\n * true if this section has subsections.\n * @return true if this section has subsections, false otherwise.\n */\n public boolean hasSections() {\n return !sections.isEmpty();\n }\n\n\n /**\n * Returns true if the section doesn't contain either variables or sub-sections.\n * true if the section doesn't contain either variables or sub-sections, false\n * otherwise.\n */\n public boolean isEmpty() {\n return !hasSections() && !hasVariables();\n }\n \n /**\n * Remove all variables and sub-sections of the section\n */\n public void clear() {\n\t\tvariables.clear();\n sections.clear();\n\t}\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/ConfigurationSource.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see com.mucommander.commons.conf package comes with a default implementation,\n * {@link FileConfigurationSource},\n * which will open input and output streams on a local file.\n *\n * @author Nicolas Rinaudo\n * @see FileConfigurationSource\n */\npublic interface ConfigurationSource {\n /**\n * Returns an input stream on the configuration source.\n * @return an input stream on the configuration source.\n * @throws IOException if any I/O error occurs.\n */\n Reader getReader() throws IOException;\n\n /**\n * Returns an output stream on the configuration source.\n * @return an output stream on the configuration source.\n * @throws IOException if any I/O error occurs.\n */\n Writer getWriter() throws IOException;\n \n /**\n * Returns whether this source exists\n * @return true if the source exists, false otherwise.\n *\n * @throws IOException if any I/O error occurs.\n */\n boolean isExists() throws IOException;\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/ConfigurationStructureException.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see com.mucommander.commons.conf API, structure errors\n * are inconsistencies in the structure of the configuration tree - a section closed more\n * than once, for example, or never closed at all.\n * ConfigurationStructureException subclasses {@link ConfigurationException}, it\n * inherits his capacity to wrap other exceptions.\n *\n * @author Nicolas Rinaudo\n */\npublic class ConfigurationStructureException extends ConfigurationException {\n /**\n * Creates a new configuration structure exception.\n * @param message the error message.\n */\n public ConfigurationStructureException(String message) {super(message);}\n\n /**\n * Creates a new configuration structure exception wrapping an existing exception.\n * ConfigurationStructureException.\n *\n * @param cause the exception to be wrapped in a ConfigurationStructureException.\n */\n public ConfigurationStructureException(Throwable cause) {super(cause);}\n\n /**\n * Creates a new configuration structure exception from an existing exception.\n * ConfigurationStructureException.\n */\n public ConfigurationStructureException(String message, Throwable cause) {super(message, cause);}\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/ConfigurationWriterFactory.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see ConfigurationWriterFactory's sole purpose is to create instances of writer. In most cases, a\n * factory class will be associated with a writer class, and its code will look something like:\n * \n * public class MyWriterFactory implements ConfigurationWriterFactory {\n * public ConfigurationWriter getWriterInstance() {return new MyWriter();}\n * }\n * \n *\n * @author Nicolas Rinaudo\n */\npublic abstract class ConfigurationWriterFactoryUTF-8 encoded.\n */\n @Deprecated\n public FileConfigurationSource(File file) {\n this(file, \"utf-8\");\n }\n\n /**\n * Creates a source on the specified file and charset.\n * @param file file in which the configuration data is located.\n * @param charset charset in which the file is encoded.\n */\n public FileConfigurationSource(File file, Charset charset) {\n this.file = file;\n this.charset = charset;\n }\n\n /**\n * Creates a source on the specified file and charset.\n * @param file file in which the configuration data is located.\n * @param charset charset in which the file is encoded.\n */\n FileConfigurationSource(File file, String charset) {\n this(file, Charset.forName(charset));\n }\n\n /**\n * Creates a source that will open streams on the specified file.\n * @param path path to the file in which the configuration data is located.\n * @deprecated Application developers should use {@link #FileConfigurationSource(String, Charset)} instead. This\n * constructor assumes the specified file to be UTF-8 encoded.\n */\n @Deprecated\n public FileConfigurationSource(String path) {\n this(new File(path));\n }\n\n /**\n * Creates a source on the specified file and charset.\n * @param path path to the file in which the configuration data is located.\n * @param charset charset in which the file is encoded.\n */\n FileConfigurationSource(String path, String charset) {\n this(new File(path), charset);\n }\n\n /**\n * Creates a source on the specified file and charset.\n * @param path path to the file in which the configuration data is located.\n * @param charset charset in which the file is encoded.\n */\n public FileConfigurationSource(String path, Charset charset) {\n this(new File(path), charset);\n }\n\n\n\n /**\n * Returns the file on which input and output streams are opened.\n * @return the file on which input and output streams are opened.\n */\n public File getFile() {\n return file;\n }\n\n /**\n * Returns the charset in which the {@link #getFile() configuration file} is encoded.\n * @return the charset in which the {@link #getFile() configuration file} is encoded.\n */\n public Charset getCharset() {\n return charset;\n }\n\n\n\n @Override\n public Reader getReader() throws IOException {\n InputStream is = new FileInputStream(file);\n return new BufferedReader(new InputStreamReader(is, charset));\n }\n\n @Override\n public Writer getWriter() throws IOException {\n return new OutputStreamWriter(new FileOutputStream(file), charset);\n }\n\n\t@Override\n\tpublic boolean isExists() {\n\t\treturn file.exists();\n\t}\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/ReaderConfigurationException.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see ReaderConfigurationException subclasses {@link ConfigurationException}, it\n * inherits his capacity to wrap other exceptions.\n *\n * @author Nicolas Rinaudo\n */\npublic class ReaderConfigurationException extends ConfigurationException {\n /**\n * Creates a new reader configuration exception.\n * @param message the error message.\n */\n public ReaderConfigurationException(String message) {super(message);}\n\n /**\n * Creates a new reader configuration exception wrapping an existing exception.\n * ReaderConfigurationException.\n *\n * @param cause the exception to be wrapped in a ReaderConfigurationException.\n */\n public ReaderConfigurationException(Throwable cause) {super(cause);}\n\n /**\n * Creates a new reader configuration exception from an existing exception.\n * ReaderConfigurationException.\n */\n public ReaderConfigurationException(String message, Throwable cause) {super(message, cause);}\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/SourceConfigurationException.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see SourceConfigurationException subclasses {@link ConfigurationException}, it\n * inherits his capacity to wrap other exceptions.\n *\n * @author Nicolas Rinaudo\n */\npublic class SourceConfigurationException extends ConfigurationException {\n /**\n * Creates a new source configuration exception.\n * @param message the error message.\n */\n public SourceConfigurationException(String message) {super(message);}\n\n /**\n * Creates a new source configuration exception wrapping an existing exception.\n * SourceConfigurationException.\n *\n * @param cause the exception to be wrapped in a SourceConfigurationException.\n */\n public SourceConfigurationException(Throwable cause) {super(cause);}\n\n /**\n * Creates a new source configuration exception from an existing exception.\n * SourceConfigurationException.\n */\n public SourceConfigurationException(String message, Throwable cause) {super(message, cause);}\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/ValueIterator.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see ValueIterator wrapping the specified iterator.\n * @param iterator iterator to wrap.\n */\n ValueIterator(Iteratortrue if the iteration has more elements.\n * (In other words, returns true if next would return an element rather than throwing an exception.)\n * @return true if the iteration has more elements.\n */\n @Override\n public boolean hasNext() {\n return iterator.hasNext();\n }\n\n /**\n * Returns the next element in the iteration.\n * @return the next element in the iteration.\n * @throws NoSuchElementException if the iteration has no more elements.\n */\n @Override\n public String next() {\n return iterator.next();\n }\n\n /**\n * Throws an UnsupportedOperationException.\n */\n @Override\n public void remove() {\n throw new UnsupportedOperationException();\n }\n\n\n\n /**\n * Returns the next value in the iterator as a string.\n * @return the next value in the iterator as a string.\n * @throws NoSuchElementException if the iteration has no more elements.\n */\n public String nextValue() {\n return iterator.next();\n }\n\n /**\n * Returns the next value in the iterator as a integer.\n * @return the next value in the iterator as a integer.\n * @throws NoSuchElementException if the iteration has no more elements.\n * @throws NumberFormatException if the value cannot be cast to an integer.\n */\n public int nextIntegerValue() {\n return ConfigurationSection.getIntegerValue(nextValue());\n }\n\n /**\n * Returns the next value in the iterator as a float.\n * @return the next value in the iterator as a float.\n * @throws NoSuchElementException if the iteration has no more elements.\n * @throws NumberFormatException if the value cannot be cast to a float.\n */\n public float nextFloatValue() {\n return ConfigurationSection.getFloatValue(nextValue());\n }\n\n /**\n * Returns the next value in the iterator as a long.\n * @return the next value in the iterator as a long.\n * @throws NoSuchElementException if the iteration has no more elements.\n * @throws NumberFormatException if the value cannot be cast to a long.\n */\n public long nextLongValue() {\n return ConfigurationSection.getLongValue(nextValue());\n }\n\n /**\n * Returns the next value in the iterator as a double.\n * @return the next value in the iterator as a double.\n * @throws NoSuchElementException if the iteration has no more elements.\n * @throws NumberFormatException if the value cannot be cast to a double.\n */\n public double nextDoubleValue() {\n return ConfigurationSection.getDoubleValue(nextValue());\n }\n\n /**\n * Returns the next value in the iterator as a boolean.\n * @return the next value in the iterator as a boolean.\n * @throws NoSuchElementException if the iteration has no more elements.\n */\n public boolean nextBooleanValue() {\n return ConfigurationSection.getBooleanValue(nextValue());\n }\n\n /**\n * Returns the next value in the iterator as a {@link ValueList}.\n * @param separator stirng used to tokenise the next value.\n * @return the next value in the iterator as a {@link ValueList}.\n * @throws NoSuchElementException if the iteration has no more elements.\n */\n public ValueList nextListValue(String separator) {\n return ConfigurationSection.getListValue(nextValue(), separator);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/ValueList.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see StringTokenizer and stored as a java.util.List.\n * List methods, this class provides the same value casting mechanisms as\n * {@link Configuration} and {@link ConfigurationEvent}. These have been extended to iterators through the\n * {@link #valueIterator()} method.\n *\n * @author Nicolas Rinaudo\n */\npublic class ValueList extends ArrayListValueList initialised with the specified data.\n * @param data data contained by the list.\n * @param separator string used to separate data in tokens.\n */\n public ValueList(String data, String separator) {\n StringTokenizer tokenizer = new StringTokenizer(data, separator);\n while(tokenizer.hasMoreTokens()) {\n add(tokenizer.nextToken());\n }\n }\n\n\n /**\n * Returns the value found at the specified index of the list as a string.\n * @param index index of the value to retrieve.\n * @return the value found at the specified index of the list as a string.\n */\n public String valueAt(int index) {\n return get(index);\n }\n\n /**\n * Returns the value found at the specified index of the list as an integer.\n * @param index index of the value to retrieve.\n * @return the value found at the specified index of the list as an integer.\n * @throws NumberFormatException if the value cannot be cast to an integer.\n */\n public int integerValueAt(int index) {\n return ConfigurationSection.getIntegerValue(valueAt(index));\n }\n\n /**\n * Returns the value found at the specified index of the list as a float.\n * @param index index of the value to retrieve.\n * @return the value found at the specified index of the list as a float.\n * @throws NumberFormatException if the value cannot be cast to a float.\n */\n public float floatValueAt(int index) {\n return ConfigurationSection.getFloatValue(valueAt(index));\n }\n\n /**\n * Returns the value found at the specified index of the list as a double.\n * @param index index of the value to retrieve.\n * @return the value found at the specified index of the list as a double.\n * @throws NumberFormatException if the value cannot be cast to a double.\n */\n public double doubleValueAt(int index) {\n return ConfigurationSection.getDoubleValue(valueAt(index));\n }\n\n /**\n * Returns the value found at the specified index of the list as a long.\n * @param index index of the value to retrieve.\n * @return the value found at the specified index of the list as a long.\n * @throws NumberFormatException if the value cannot be cast to a long.\n */\n public long longValueAt(int index) {\n return ConfigurationSection.getLongValue(valueAt(index));\n }\n\n /**\n * Returns the value found at the specified index of the list as an boolean.\n * @param index index of the value to retrieve.\n * @return the value found at the specified index of the list as an boolean.\n */\n public boolean booleanValueAt(int index) {\n return ConfigurationSection.getBooleanValue(valueAt(index));\n }\n\n /**\n * Returns the value found at the specified index of the list as a {@link ValueList}.\n * @param index index of the value to retrieve.\n * @param separator string used to split the value into tokens.\n * @return the value found at the specified index of the list as a {@link ValueList}.\n */\n public ValueList listValueAt(int index, String separator) {\n return ConfigurationSection.getListValue(valueAt(index), separator);\n }\n\n /**\n * Returns a {@link ValueIterator} on the list.\n * @return a {@link ValueIterator} on the list.\n */\n public ValueIterator valueIterator() {\n return new ValueIterator(iterator());\n }\n\n\n\n /**\n * Returns a string representation of the specified list.\n * @param data values to represent as a string.\n * @param separator string used to separate one element from the other.\n * @return a string representation of the specified list.\n */\n public static String toString(List data, String separator) {\n StringBuilder buffer = new StringBuilder();\n Iterator values = data.iterator();\n\n // Deals with the first value separately.\n if (values.hasNext()) {\n buffer.append(values.next().toString());\n }\n\n // All subsequent values will be concatenated after a separator.\n while (values.hasNext()) {\n buffer.append(separator);\n buffer.append(values.next().toString());\n }\n\n // Returns the final value.\n return buffer.toString();\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/WriterConfigurationException.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see WriterConfigurationException subclasses {@link ConfigurationException}, it\n * inherits his capacity to wrap other exceptions.\n * @author Nicolas Rinaudo\n */\npublic class WriterConfigurationException extends ConfigurationException {\n /**\n * Creates a new writer configuration exception.\n * @param message the error message.\n */\n public WriterConfigurationException(String message) {\n super(message);\n }\n\n /**\n * Creates a new writer configuration exception wrapping an existing exception.\n * WriterConfigurationException.\n *\n * @param cause the exception to be wrapped in a WriterConfigurationException.\n */\n public WriterConfigurationException(Throwable cause) {\n super(cause);\n }\n\n /**\n * Creates a new writer configuration exception from an existing exception.\n * WriterConfigurationException.\n */\n public WriterConfigurationException(String message, Throwable cause) {\n super(message, cause);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/XmlConfigurationReader.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see XmlConfigurationReader is fairly simple:\n * \n *
\n *\n * prefs, but this isn't enforced. It\n * will be excluded from section names.\n * \n * <prefs>\n * <some>\n * Random CDATA\n * <section>\n * <var1>value1</var1>\n * <var2>value2</var2>\n * </section>\n * </some>\n * </prefs>\n *
\n * This will be interpreted as follows:\n * \n *
\n *\n * @author Nicolas Rinaudo\n * @see XmlConfigurationWriter\n */\npublic class XmlConfigurationReader extends DefaultHandler implements ConfigurationReader {\n /** Factory used to create {@link XmlConfigurationReader} instances. */\n public static final ConfigurationReaderFactoryRandom CDATA will be ignored.some.section.var1 will be created with a value of value1.some.section.var2 will be created with a value of value2.in a passes build messages to builder.\n * @param in input stream from which to read the configuration data.\n * @param builder object to notify of build events.\n * @throws IOException if an I/O error occurs.\n * @throws ConfigurationFormatException if a configuration file format occurs.\n * @throws ConfigurationException if a non-specific error occurs.\n */\n public void read(Reader in, ConfigurationBuilder builder) throws IOException, ConfigurationException {\n this.builder = builder;\n locator = null;\n try {\n SAXParserFactory.newInstance().newSAXParser().parse(new InputSource(in), this);\n } catch (ParserConfigurationException e) {\n throw new ConfigurationException(\"Failed to create a SAX parser\", e);\n } catch (SAXParseException e) {\n throw new ConfigurationFormatException(e.getMessage(), e.getLineNumber(), e.getColumnNumber());\n } catch (SAXException e) {\n throw new ConfigurationFormatException(e.getException() == null ? e : e.getException());\n }\n }\n\n\n\n // - XML handling --------------------------------------------------------------------------------------------------\n // -----------------------------------------------------------------------------------------------------------------\n /**\n * This method is public as an implementation side effect and should never be called directly.\n */\n @Override\n public void characters(char[] ch, int start, int length) {buffer.append(ch, start, length);}\n\n /**\n * This method is public as an implementation side effect and should never be called directly.\n */\n @Override\n public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {\n depth++;\n if (depth == 1) {\n return;\n }\n\n if (itemName != null) {\n try {\n builder.startSection(itemName);\n } catch(Exception e) {\n throw new SAXParseException(e.getMessage(), locator, e);\n }\n }\n buffer.setLength(0);\n itemName = qName;\n isVariable = true;\n }\n\n /**\n * This method is public as an implementation side effect and should never be called directly.\n */\n @Override\n public void endElement(String uri, String localName, String qName) throws SAXException {\n depth--;\n if (depth == 0) {\n return;\n }\n\n // If the current element doesn't have subsections, considers it to be a variable.\n if(isVariable) {\n String value = buffer.toString().trim();\n\n // Ignores empty values, otherwise notifies the builder of a new variable.\n if(!value.isEmpty()) {\n try {\n builder.addVariable(qName, value);\n } catch(Exception e) {\n throw new SAXParseException(e.getMessage(), locator, e);\n }\n }\n }\n\n // The current element is a container, closes it.\n else {\n try {\n builder.endSection(qName);\n } catch(Exception e) {\n throw new SAXParseException(e.getMessage(), locator, e);\n }\n }\n\n isVariable = false;\n itemName = null;\n }\n\n /**\n * This method is public as an implementation side effect and should never be called directly.\n */\n @Override\n public void startDocument() throws SAXException {\n try {\n builder.startConfiguration();\n } catch(Exception e) {\n throw new SAXParseException(e.getMessage(), locator, e);\n }\n }\n\n /**\n * This method is public as an implementation side effect and should never be called directly.\n */\n @Override\n public void endDocument() throws SAXException {\n try {\n builder.endConfiguration();\n } catch(Exception e) {\n throw new SAXParseException(e.getMessage(), locator, e);\n }\n }\n\n /**\n * This method is public as an implementation side effect and should never be called directly.\n */\n @Override\n public void setDocumentLocator(Locator locator) {\n this.locator = locator;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/XmlConfigurationWriter.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see startElement call). */\n private final Attributes emptyAttributes = new AttributesImpl();\n /** Root element name. */\n protected final String rootElementName;\n\n\n static {\n FACTORY = new ConfigurationWriterFactoryIOException that might have occurred.\n */\n public void startSection(String name) throws ConfigurationException {\n startElement(name);\n }\n\n /**\n * Ends a configuration section.\n * @param name name of the closed section.\n * @throws ConfigurationException as a wrapper for any IOException that might have occurred.\n */\n public void endSection(String name) throws ConfigurationException {\n endElement(name);\n }\n\n /**\n * Creates a new variable in the current section.\n * @param name name of the new variable.\n * @param value value of the new variable.\n * @throws ConfigurationException as a wrapper for any IOException that might have occurred.\n */\n public void addVariable(String name, String value) throws ConfigurationException {\n char[] data;\n\n try {\n startElement(name);\n data = value.toCharArray();\n out.characters(data, 0, data.length);\n endElement(name);\n } catch(SAXException e) {\n throw new ConfigurationException(e);\n }\n }\n\n /**\n * Writes the XML header.\n * @throws ConfigurationException as a wrapper for any exception that might have occurred.\n */\n public void startConfiguration() throws ConfigurationException {\n try {\n out.startDocument();\n startElement(rootElementName);\n } catch(SAXException e) {\n throw new ConfigurationException(e);\n }\n }\n\n /**\n * Writes the XML footer.\n * @throws ConfigurationException as a wrapper for any IOException that might have occurred.\n */\n public void endConfiguration() throws ConfigurationException {\n try {\n endElement(rootElementName);\n out.endDocument();\n } catch(SAXException e) {\n throw new ConfigurationException(e);\n }\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/conf/package-info.java",
"content": "/**\n * Provides classes to deal with software configuration.\n * Configuration variables
\n * section.subsection.name where:\n * \n *
\n * section and subsection are both sections.name is the variable's name.\n *
\n * Loading and storing configuration
\n * com.mucommander.commons.conf package offers various ways of loading and storing configuration.
\n * The most obvious way is by using the {@link com.mucommander.commons.conf.Configuration#read(java.io.Reader) read} and\n * {@link com.mucommander.commons.conf.Configuration#write(java.io.Writer)} methods, but this has the disadvantage\n * of forcing application writers to manage streams themselves.
\n * The preferred method is to create a dedicated {@link com.mucommander.commons.conf.ConfigurationSource} class and\n * register it through {@link com.mucommander.commons.conf.Configuration#setSource(ConfigurationSource) setSource}.\n * This allows an instance of {@link com.mucommander.commons.conf.Configuration} to know how to read from and write to\n * its configuration file (or socket or any other medium that provides input and output streams).\n *\n * Changing the default configuration format
\n * \n *
\n *\n * Listening to the configuration
\n * \n *
\n */\npackage com.mucommander.commons.conf;"
},
{
"path": "src/main/java/com/mucommander/commons/file/AbstractArchiveEntryFile.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see AbstractArchiveEntryFile represents a file entry inside an archive.\n * An AbstractArchiveEntryFile is always associated with an {@link ArchiveEntry} object which contains\n * information about the entry (name, size, date, ...) and with an {@link AbstractArchiveFile} which acts as an entry\n * repository and provides operations such as listing a directory entry's files, adding or removing entries\n * (if the archive is writable), etc...\n *\n * AbstractArchiveEntryFile implements {@link com.mucommander.commons.file.AbstractFile} by delegating methods to\n * the ArchiveEntry and AbstractArchiveFile instances.\n * AbstractArchiveEntryFile is agnostic to the actual archive format. In other words, there is no need to\n * extend this class for a particular archive format, ArchiveEntry and AbstractArchiveFile\n * provide a generic framework that isolates from the archive format's specifics.\n * \n *
\n *\n * @see AbstractArchiveFile\n * @see ArchiveEntry\n * @author Maxence Bernard\n */\npublic abstract class AbstractArchiveEntryFile extends AbstractFile {\n\n /** The archive file that contains this entry */\n final AbstractArchiveFile archiveFile;\n\n /** This entry file's parent, can be the archive file itself if this entry is located at the top level */\n protected AbstractFile parent;\n\n /** The ArchiveEntry object that contains information about this entry */\n final protected ArchiveEntry entry;\n\n\n /**\n * Creates a new AbstractArchiveEntryFile.\n *\n * @param url the FileURL instance that represents this file's location\n * @param archiveFile the AbstractArchiveFile instance that contains this entry\n * @param entry the ArchiveEntry object that contains information about this entry\n */\n protected AbstractArchiveEntryFile(FileURL url, AbstractArchiveFile archiveFile, ArchiveEntry entry) {\n super(url);\n this.archiveFile = archiveFile;\n this.entry = entry;\n }\n\n\n /**\n * Returns the ArchiveEntry instance that contains information about the archive entry (path, size, date, ...).\n *\n * @return the ArchiveEntry instance that contains information about the archive entry (path, size, date, ...)\n */\n public ArchiveEntry getEntry() {\n return entry;\n }\n\n /**\n * Returns the {@link AbstractArchiveFile} that contains the entry represented by this file.\n *\n * @return the AbstractArchiveFile that contains the entry represented by this file\n */\n AbstractArchiveFile getArchiveFile() {\n return archiveFile;\n }\n\n\n /**\n * Returns the relative path of this entry, with respect to the archive file. The path separator of the returned\n * path is the one returned by {@link #getSeparator()}. As a relative path, the returned path does not start\n * with a separator character.\n *\n * @return the relative path of this entry, with respect to the archive file.\n */\n private String getRelativeEntryPath() {\n String path = entry.getPath();\n\n // Replace all occurrences of the entry's separator by the archive file's separator, only if the separator is\n // not \"/\" (i.e. the entry path separator).\n String separator = getSeparator();\n if (!separator.equals(\"/\")) {\n path = path.replace(\"/\", separator);\n }\n\n return path;\n }\n\n\n /////////////////////////////////\n // AbstractFile implementation //\n /////////////////////////////////\n\n @Override\n public long getLastModifiedDate() {\n return entry.getLastModifiedDate();\n }\n\n @Override\n public long getSize() {\n return entry.getSize();\n }\n\t\n @Override\n public boolean isDirectory() {\n return entry.isDirectory();\n }\n\n @Override\n public boolean isArchive() {\n // Archive entries files may be wrapped by archive files but they are not archive files per se\n return false;\n }\n\n @Override\n public AbstractFile[] ls() throws IOException {\n return archiveFile.ls(this, null, null);\n }\n\n @Override\n public AbstractFile[] ls(FilenameFilter filter) throws IOException {\n return archiveFile.ls(this, filter, null);\n }\n\t\n @Override\n public AbstractFile[] ls(FileFilter filter) throws IOException {\n return archiveFile.ls(this, null, filter);\n }\n\n @Override\n public AbstractFile getParent() {\n return parent;\n }\n\t\n @Override\n public void setParent(AbstractFile parent) {\n this.parent = parent;\t\n }\n\n /**\n * Returns true if this entry exists within the archive file.\n *\n * @return true if this entry exists within the archive file\n */\n @Override\n public boolean exists() {\n return entry.exists();\n }\n\t\n @Override\n public FilePermissions getPermissions() {\n // Return the entry's permissions\n return entry.getPermissions();\n }\n\n @Override\n public void changePermission(int access, int permission, boolean enabled) throws IOException {\n changePermissions(ByteUtils.setBit(getPermissions().getIntValue(), (permission << (access*3)), enabled));\n }\n\n @Override\n public String getOwner() {\n return entry.getOwner();\n }\n\n @Override\n public boolean canGetOwner() {\n return entry.getOwner()!=null;\n }\n\n @Override\n public String getGroup() {\n return entry.getGroup();\n }\n\n @Override\n public boolean canGetGroup() {\n return entry.getGroup()!=null;\n }\n\n /**\n * Always returns false.\n */\n @Override\n public boolean isSymlink() {\n return false;\n }\n\n /**\n * Always returns false.\n */\n @Override\n public boolean isSystem() {\n return false;\n }\n\n /**\n * Delegates to the archive file's {@link AbstractArchiveFile#getFreeSpace()} method.\n *\n * @throws IOException if an I/O error occurred\n * @throws UnsupportedFileOperationException if the underlying archive file does not support\n * {@link FileOperation#GET_FREE_SPACE} operations.\n */\n @Override\n public long getFreeSpace() throws IOException {\n return archiveFile.getFreeSpace();\n }\n\n /**\n * Delegates to the archive file's {@link AbstractArchiveFile#getTotalSpace()} method.\n *\n * @throws IOException if an I/O error occurred\n * @throws UnsupportedFileOperationException if the underlying archive file does not support\n * {@link FileOperation#GET_TOTAL_SPACE} operations.\n */\n @Override\n public long getTotalSpace() throws IOException {\n return archiveFile.getTotalSpace();\n }\n\n /**\n * Delegates to the archive file's {@link AbstractArchiveFile#getEntryInputStream(ArchiveEntry,ArchiveEntryIterator)}}\n * method.\n *\n * @throws UnsupportedFileOperationException if the underlying archive file does not support\n * {@link FileOperation#READ_FILE} operations.\n */\n @Override\n public InputStream getInputStream() throws IOException {\n return archiveFile.getEntryInputStream(entry, null);\n }\n\n /**\n * Always throws an {@link UnsupportedFileOperationException}: append is not available for archive entries.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public OutputStream getAppendOutputStream() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.APPEND_FILE);\n }\n\n /**\n * Always throws an {@link UnsupportedFileOperationException}: random read access is not available for archive\n * entries.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public RandomAccessInputStream getRandomAccessInputStream() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.RANDOM_READ_FILE);\n }\n\n /**\n * Always throws an {@link UnsupportedFileOperationException}: random write access is not available for archive\n * entries.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public RandomAccessOutputStream getRandomAccessOutputStream() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.RANDOM_WRITE_FILE);\n }\n\n /**\n * Always throws an {@link UnsupportedFileOperationException} when called.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public void copyRemotelyTo(AbstractFile destFile) throws UnsupportedFileOperationException {\n // TODO: we could consider adding remote copy support to RWArchiveEntryFile\n throw new UnsupportedFileOperationException(FileOperation.COPY_REMOTELY);\n }\n\n /**\n * Always throws an {@link UnsupportedFileOperationException} when called.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public void renameTo(AbstractFile destFile) throws UnsupportedFileOperationException {\n // TODO: we could consider adding renaming support to RWArchiveEntryFile\n throw new UnsupportedFileOperationException(FileOperation.RENAME);\n }\n\n /**\n * Returns the same ArchiveEntry instance as {@link #getEntry()}.\n */\n @Override\n public Object getUnderlyingFileObject() {\n return entry;\n }\n\n \n ////////////////////////\n // Overridden methods //\n ////////////////////////\n\n /**\n * This method is overridden to return the separator of the {@link #getArchiveFile() archive file} that contains\n * this entry.\n *\n * @return the separator of the archive file that contains this entry\n */\n @Override\n public String getSeparator() {\n return archiveFile.getSeparator();\n }\n\n /**\n * This method is overridden to use the archive file's absolute path as the base path of this entry file.\n */\n @Override\n public String getAbsolutePath() {\n // Use the archive file's absolute path and append the entry's relative path to it\n return archiveFile.getAbsolutePath(true)+getRelativeEntryPath();\n }\n\n /**\n * This method is overridden to use the archive file's canonical path as the base path of this entry file.\n */\n @Override\n public String getCanonicalPath() {\n // Use the archive file's canonical path and append the entry's relative path to it\n return archiveFile.getCanonicalPath(true)+getRelativeEntryPath();\n }\n\n /**\n * This method is overridden to return the archive's root folder.\n */\n @Override\n public AbstractFile getRoot() {\n return archiveFile.getRoot();\n }\n\n /**\n * This method is overridden to blindly return false, an archive entry cannot be a root folder.\n *\n * @return false, always\n */\n @Override\n public boolean isRoot() {\n return false;\n }\n\n /**\n * This method is overridden to return the archive's volume folder.\n */\n @Override\n public AbstractFile getVolume() {\n return archiveFile.getVolume();\n }\n\n @Override\n @UnsupportedFileOperation\n public short getReplication() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.GET_REPLICATION);\n }\n\n @Override\n @UnsupportedFileOperation\n public long getBlocksize() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.GET_BLOCKSIZE);\n }\n\n @Override\n @UnsupportedFileOperation\n public void changeReplication(short replication) throws IOException {\n throw new UnsupportedFileOperationException(FileOperation.CHANGE_REPLICATION);\n }\n\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/AbstractArchiveFile.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see AbstractArchiveFile is the superclass of all archive files. It allows archive file to be browsed as if\n * they were regular directories, independently of the underlying protocol used to access the actual file.\n * AbstractArchiveFile extends {@link ProxyFile} to delegate the AbstractFile\n * implementation to the actual archive file and overrides some methods to provide the added functionality.
\n * There are two kinds of AbstractArchiveFile, both of which extend this class:\n * \n *
\n * When implementing a new archive file/format, either AbstractROArchiveFile or AbstractRWArchiveFile\n * should be subclassed, but not this class.\n *\n * ls() methods is called to list the archive's contents,\n * {@link #getEntryIterator()} is called to retrieve a list of *all* the entries contained by the archive, not only the\n * ones at the top level but also the ones nested one of several levels below. Using this list of entries, it creates\n * a tree to map the structure of the archive and list the content of any particular directory within the archive.\n * This tree is recreated (getEntryIterator() is called again) only if the archive file has changed, i.e.\n * if its date has changed since the tree was created.\n *\n * ls() are {@link AbstractArchiveEntryFile} instances which use an {@link ArchiveEntry}\n * object to retrieve the entry's attributes. In turn, these AbstractArchiveEntryFile instances query the\n * associated AbstractArchiveFile to list their content.\n *
From an implementation perspective, one only needs to deal with {@link ArchiveEntry} instances, all the nuts\n * and bolts are taken care of by this class.\n *\n * AbstractArchiveFile may or may not actually be an archive:\n * {@link #isArchive()} returns true only if the file currently exists and is not a directory. The value\n * returned by {@link #isArchive()} may change over time as the file is modified. When an\n * AbstractArchiveFile is not currently an archive, it acts just as a 'normal' file and delegates\n * ls() methods to the underlying {@link AbstractFile}\n *\n * @see com.mucommander.commons.file.FileFactory\n * @see com.mucommander.commons.file.ArchiveFormatProvider\n * @see com.mucommander.commons.file.ArchiveEntry\n * @see AbstractArchiveEntryFile\n * @see com.mucommander.commons.file.archiver.Archiver\n * @author Maxence Bernard\n */\npublic abstract class AbstractArchiveFile extends ProxyFile {\n private static Logger logger;\n\n /** Archive entries tree */\n private ArchiveEntryTree entryTreeRoot;\n\n /** Date this file had when the entries tree was created. Used to detect if the archive file has changed and entries\n * need to be reloaded */\n private long entryTreeDate;\n\n /** The password to use for a password-protected archive */\n protected String password;\n\n /** Caches {@link AbstractArchiveEntryFile} instances so that there is only one AbstractArchiveEntryFile\n * corresponding to the same entry at any given time, to avoid attribute inconsistencies. The key is the\n * corresponding ArchiveEntry. */\n private WeakHashMapnull if the tree hasn't been intialized yet.\n *\n * @return the ArchiveEntryTree instance corresponding to the root of the archive entry tree\n */\n ArchiveEntryTree getArchiveEntryTree() {\n return entryTreeRoot;\n }\n\n /**\n * Returns the contents of the specified folder entry.\n *\n * @throws UnsupportedFileOperationException if {@link FileOperation#READ_FILE} operations are not supported by the\n * underlying file protocol.\n */\n protected AbstractFile[] ls(AbstractArchiveEntryFile entryFile, FilenameFilter filenameFilter, FileFilter fileFilter) throws IOException {\n // Make sure the entries tree is created and up-to-date\n checkEntriesTree(); \n\n if (!entryFile.isBrowsable()) {\n throw new IOException();\n }\n\n DefaultMutableTreeNode matchNode = entryTreeRoot.findEntryNode(entryFile.getEntry().getPath());\n if (matchNode == null) {\n throw new IOException();\n }\n\n return ls(matchNode, entryFile, filenameFilter, fileFilter);\n }\n\n /**\n * Returns the contents (direct children) of the specified tree node.\n *\n * @throws UnsupportedFileOperationException if {@link FileOperation#READ_FILE} operations are not supported by the\n * underlying file protocol.\n */\n private AbstractFile[] ls(DefaultMutableTreeNode treeNode, AbstractFile parentFile, FilenameFilter filenameFilter, FileFilter fileFilter) throws IOException {\n AbstractFile[] files;\n int nbChildren = treeNode.getChildCount();\n\n // No FilenameFilter, create entry files and store them directly into an array\n if (filenameFilter == null) {\n files = new AbstractFile[nbChildren];\n\n for (int c=0; c < nbChildren; c++) {\n files[c] = getArchiveEntryFile((ArchiveEntry)(((DefaultMutableTreeNode)treeNode.getChildAt(c)).getUserObject()), parentFile);\n }\n }\n // Use provided FilenameFilter and temporarily store created entry files that match the filter in a Vector\n else {\n Listls() is called. It will not be called anymore,\n * unless the file's date has changed since the last time one of the ls() methods was called.\n *\n * @return an iterator of {@link ArchiveEntry} that iterates through all the entries of this archive\n * @throws IOException if an error occurred while reading the archive, either because the archive is corrupt or\n * because of an I/O error\n * @throws UnsupportedFileOperationException if {@link FileOperation#READ_FILE} operations are not supported by the\n * underlying file protocol.\n */\n public abstract ArchiveEntryIterator getEntryIterator() throws IOException;\n\n /**\n * Returns an InputStream to read from the given archive entry. The specified {@link ArchiveEntry}\n * instance must be one of the entries that were returned by the {@link ArchiveEntryIterator} returned by\n * {@link #getEntryIterator()}.\n *\n * @param entry the archive entry to read\n * @param entryIterator the iterator that is used to iterate through entries by the caller (if any). This parameter\n * may be null, but when it is known, specifying may improve the performance of this method\n * by an order of magnitude.\n * @return an InputStream to read from the given archive entry\n * @throws IOException if an error occurred while reading the archive, either because the archive is corrupt or\n * because of an I/O error, or if the given entry wasn't found in the archive\n * @throws UnsupportedFileOperationException if {@link FileOperation#READ_FILE} operations are not supported by the \n * underlying file protocol.\n */\n public abstract InputStream getEntryInputStream(ArchiveEntry entry, ArchiveEntryIterator entryIterator) throws IOException;\n\n /**\n * Returns true if this archive file is writable, i.e. is capable of adding and deleting entries from\n * the underlying archive file.\n *\n * false and\n * true. This method may be overridden by AbstractRWArchiveFile implementations if write\n * access is only available under certain conditions, for example if it requires random write access to the\n * proxied archive file (which may not always be available).\n * Therefore, this method should be used to test if an AbstractArchiveFile is writable, rather than\n * testing if it is an instance of AbstractRWArchiveFile.\n *\n * @return true if this archive is writable, i.e. is capable of adding and deleting entries from\n * the underlying archive file.\n */\n public abstract boolean isWritable();\n\n\n @Override\n public boolean isArchive() {\n return exists() && !isDirectory();\n }\n\n\n /**\n * This method is overridden to list and return the topmost entries contained by this archive.\n * The returned files are {@link AbstractArchiveEntryFile} instances.\n *\n * @return the topmost entries contained by this archive\n * @throws IOException if the archive entries could not be listed\n * @throws UnsupportedFileOperationException if {@link FileOperation#READ_FILE} operations are not supported by the\n * underlying file protocol.\n */\n @Override\n public AbstractFile[] ls() throws IOException {\n // Delegate to the ancestor if this file isn't actually an archive\n if (!isArchive())\n return super.ls();\n\n // Make sure the entries tree is created and up-to-date\n checkEntriesTree();\n\n return ls(entryTreeRoot, this, null, null);\n }\n\n /**\n * This method is overridden to list and return the topmost entries contained by this archive, filtering out\n * the ones that do not match the specified {@link FilenameFilter}. The returned files are {@link AbstractArchiveEntryFile}\n * instances.\n *\n * @param filter the FilenameFilter to be used to filter files out from the list, may be null\n * @return the topmost entries contained by this archive\n * @throws IOException if the archive entries could not be listed\n * @throws UnsupportedFileOperationException if {@link FileOperation#READ_FILE} operations are not supported by the\n * underlying file protocol.\n */\n @Override\n public AbstractFile[] ls(FilenameFilter filter) throws IOException {\n // Delegate to the ancestor if this file isn't actually an archive\n if (!isArchive())\n return super.ls(filter);\n\n // Make sure the entries tree is created and up-to-date\n checkEntriesTree();\n\n return ls(entryTreeRoot, this, filter, null);\n }\n\n /**\n * This method is overridden to list and return the topmost entries contained by this archive, filtering out\n * the ones that do not match the specified {@link FileFilter}. The returned files are {@link AbstractArchiveEntryFile} instances.\n *\n * @param filter the FilenameFilter to be used to filter files out from the list, may be null\n * @return the topmost entries contained by this archive\n * @throws IOException if the archive entries could not be listed\n * @throws UnsupportedFileOperationException if {@link FileOperation#READ_FILE} operations are not supported by the\n * underlying file protocol.\n */\n @Override\n public AbstractFile[] ls(FileFilter filter) throws IOException {\n // Delegate to the ancestor if this file isn't actually an archive\n if (!isArchive()) {\n return super.ls(filter);\n }\n\n // Make sure the entries tree is created and up-to-date\n checkEntriesTree();\n\n return ls(entryTreeRoot, this, null, filter);\n }\n\n public String getPassword() {\n return password;\n }\n\n public void setPassword(String password) {\n this.password = password;\n }\n\n // Note: do not override #isDirectory() to always return true, as AbstractArchiveFile instances may be created when\n // the file does not exist yet, and then be mkdir(): in that case, the file will be a directory and not an archive.\n\n private static Logger getLogger() {\n if (logger == null) {\n logger = LoggerFactory.getLogger(AbstractArchiveFile.class);\n }\n return logger;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/AbstractFile.java",
"content": "/*\r\n * This file is part of muCommander, http://www.mucommander.com\r\n * Copyright (C) 2002-2010 Maxence Bernard\r\n *\r\n * muCommander is free software; you can redistribute it and/or modify\r\n * it under the terms of the GNU Lesser General Public License as published by\r\n * the Free Software Foundation, either version 3 of the License, or\r\n * (at your option) any later version.\r\n *\r\n * muCommander is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU Lesser General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU Lesser General Public License\r\n * along with this program. If not, see AbstractFile is the superclass of all files.\r\n *\r\n * getFile\r\n * methods should be used to get a file instance from a path or {@link FileURL} location.\r\n *\r\n * @see com.mucommander.commons.file.FileFactory\r\n * @see com.mucommander.commons.file.impl.ProxyFile\r\n * @author Maxence Bernard\r\n */\r\npublic abstract class AbstractFile implements FileAttributes, PermissionTypes, PermissionAccesses {\r\n\r\n /** URL representing this file */\r\n protected final FileURL fileURL;\r\n\r\n /** Default path separator */\r\n protected final static String DEFAULT_SEPARATOR = \"/\";\r\n\r\n /** Size of the read/write buffer */\r\n // Note: raising buffer size from 8192 to 65536 makes a huge difference in SFTP read transfer rates but beyond\r\n // 65536, no more gain (not sure why).\r\n protected final static int IO_BUFFER_SIZE = 65536;\r\n\r\n\r\n /**\r\n * Used for method getPushBackInputStream()\r\n */\r\n private MuPushbackInputStream pushbackInputStream;\r\n\r\n\r\n /**\r\n * Creates a new file instance with the given URL.\r\n *\r\n * @param url the FileURL instance that represents this file's location\r\n */\r\n protected AbstractFile(FileURL url) {\r\n this.fileURL = url;\r\n }\r\n\r\n\r\n /**\r\n * Returns the {@link FileURL} instance that represents this file's location.\r\n *\r\n * @return the FileURL instance that represents this file's location\r\n */\r\n public FileURL getURL() {\r\n return fileURL;\r\n }\r\n\r\n\r\n /**\r\n * Creates and returns a java.net.URL referring to the same location as the {@link FileURL} associated\r\n * with this AbstractFile.\r\n * The java.net.URL is created from the string representation of this file's FileURL.\r\n * Thus, any credentials this FileURL contains are preserved, but properties are lost.\r\n *\r\n * URL uses this {@link AbstractFile} to access the associated resource, via the\r\n * underlying URLConnection which delegates to this class.\r\n *\r\n * java.net.URL.\r\n *\r\n * @return a java.net.URL referring to the same location as this FileURL\r\n * @throws java.net.MalformedURLException if the java.net.URL could not parse the location of this FileURL\r\n */\r\n public URL getJavaNetURL() throws MalformedURLException {\r\n return new URL(null, getURL().toString(true), new CompatURLStreamHandler(this));\r\n }\r\n\r\n\r\n /**\r\n * Returns this file's name.\r\n *\r\n * FileURL\r\n * as returned by {@link FileURL#getFilename()}. If the filename is null (e.g. http://google.com), the\r\n * FileURL's host will be returned instead. If the host is null (e.g. smb://), an empty\r\n * String will be returned. Thus, the returned name will never be null.\r\n *\r\n * null if this file's name doesn't have an extension.\r\n *\r\n *
\r\n * - it contains at least one . character
\r\n * - the last . is not the last character of the filename
\r\n * - the last . is not the first character of the filename\r\n *\r\n * @return this file's extension, null if this file's name doesn't have an extension\r\n */\r\n public String getExtension() {\r\n return getExtension(getName());\r\n }\r\n\r\n \r\n /**\r\n * Returns the absolute path to this file:\r\n * \r\n *
\r\n * AbstractFile representing the canonical path of this file, or this if the\r\n * absolute and canonical path of this file are identical.
\r\n * Note that the returned file may or may not exist, for example if this file is a symlink to a file that doesn't \r\n * exist.\r\n *\r\n * @return an AbstractFile representing the canonical path of this file, or this if the absolute and canonical\r\n * path of this file are identical.\r\n */\r\n public AbstractFile getCanonicalFile() {\r\n String canonicalPath = getCanonicalPath(false);\r\n if (canonicalPath.equals(getAbsolutePath(false))) {\r\n return this;\r\n }\r\n\r\n try {\r\n FileURL canonicalURL = FileURL.getFileURL(canonicalPath);\r\n canonicalURL.setCredentials(fileURL.getCredentials());\r\n\r\n return FileFactory.getFile(canonicalURL);\r\n } catch (IOException e) {\r\n return this;\r\n }\r\n }\r\n\r\n\r\n /**\r\n * Returns the path separator used by this file.\r\n *\r\n * true if this file is hidden.\r\n *\r\n * true if this\r\n * file's name starts with '.'. This method should be overridden if the underlying filesystem has a notion\r\n * of hidden files.\r\n *\r\n * @return true if this file is hidden\r\n */\t\r\n public boolean isHidden() {\r\n return getName().startsWith(\".\");\r\n }\r\n\r\n /**\r\n * Returns true if this file is executable.\r\n *\r\n * @return true if this file is executable\r\n */\r\n public boolean isExecutable() {\r\n if (OsFamily.WINDOWS.isCurrent()) {\r\n if (isDirectory()) {\r\n return false;\r\n }\r\n String ext = getExtension();\r\n return ext != null && (ext.equalsIgnoreCase(\"exe\") || ext.equalsIgnoreCase(\"com\") || ext.equalsIgnoreCase(\"bat\") || ext.equalsIgnoreCase(\"cmd\"));\r\n }\r\n return !isDirectory() && getPermissions().getBitValue(USER_ACCESS, EXECUTE_PERMISSION);\r\n }\r\n\r\n /**\r\n * Return true if the application can read this file.\r\n * TODO: need to be overridden with a correct check for each file type.\r\n *\r\n * @return true if the application can read this file.\r\n * **/\r\n public boolean canRead() {\r\n return true;\r\n }\r\n\r\n /**\r\n * Returns the root folder of this file, i.e. the top-level parent folder that has no parent folder. The returned\r\n * folder necessarily contains this file, directly or indirectly. If this file already is a root folder, the same\r\n * file will be returned.\r\n * /.\r\n *\r\n * @return the root folder that contains this file\r\n */\r\n public AbstractFile getRoot() {\r\n FileURL rootURL = (FileURL)getURL().clone();\r\n rootURL.setPath(\"/\");\r\n\r\n return FileFactory.getFile(rootURL);\r\n }\r\n\r\n /**\r\n * Returns true if this file is a root folder.\r\n * true if this file's URL path is /.\r\n *\r\n * @return true if this file is a root folder\r\n */\r\n public boolean isRoot() {\r\n return getURL().getPath().equals(\"/\");\r\n }\r\n\r\n /**\r\n * Returns the volume on which this file is located, or this if this file is itself a volume.\r\n * The returned file may never be null. Furthermore, the returned file may not always\r\n * {@link #exists() exist}, for instance if the returned volume corresponds to a removable drive that's currently\r\n * unavailable. If the returned file does exist, it must always be a {@link #isDirectory() directory}.\r\n * In other words, archive files may not be considered as volumes.\r\n * InputStream to read this file's contents, starting at the specified offset (in bytes).\r\n * A java.io.IOException is thrown if the file doesn't exist.\r\n *\r\n * InputStream implementations is very slow as it causes the bytes to be read and discarded.\r\n * For this reason, file implementations that do not provide random read access may want to override this method\r\n * if a more efficient implementation can be provided.\r\n *\r\n * @param offset the offset in bytes from the beginning of the file, must be not negative\r\n * @throws IOException if this file cannot be read or is a folder.\r\n * @throws UnsupportedFileOperationException if this method relies on a file operation that is not supported\r\n * or not implemented by the underlying filesystem.\r\n * @return an InputStream to read this file's contents, skipping the specified number of bytes\r\n */\r\n public InputStream getInputStream(long offset) throws IOException {\r\n // Use random access input stream when available\r\n if (isFileOperationSupported(FileOperation.RANDOM_READ_FILE)) {\r\n RandomAccessInputStream rais = getRandomAccessInputStream();\r\n rais.seek(offset);\r\n\r\n return rais;\r\n }\r\n\r\n InputStream in = getInputStream();\r\n\r\n // Skip exactly the specified number of bytes\r\n StreamUtils.skipFully(in, offset);\r\n\r\n return in;\r\n }\r\n\t\r\n\r\n /**\r\n * Copies the contents of the given InputStream to this file, appending or overwriting the file\r\n * if it exists. It is noteworthy that the provided InputStream will not be closed by this method.\r\n * \r\n * InputStream and use it to write the file.\r\n * For this reason, it is recommended to use this method to write a file, rather than copying streams manually using\r\n * {@link #getOutputStream()}\r\n *\r\n * length parameter is optional. Setting its value help certain protocols which need to know\r\n * the length in advance. This is the case for instance for some HTTP-based protocols like Amazon S3, which require\r\n * the Content-Length header to be set in the request. Callers should thus set the length if it is\r\n * known.\r\n *\r\n * -1 if unknown.\r\n * @throws FileTransferException if something went wrong while reading from the InputStream or writing to this file\r\n */\r\n public void copyStream(InputStream in, boolean append, long length) throws FileTransferException {\r\n OutputStream out;\r\n\r\n try {\r\n out = append ? getAppendOutputStream() : getOutputStream();\r\n } catch (UnsupportedFileOperationException e) {\r\n throw new FileTransferException(FileTransferException.UNSUPPORTED_OPERATION, e);\r\n } catch (IOException e) {\r\n throw new FileTransferException(FileTransferException.OPENING_DESTINATION, e);\r\n }\r\n\r\n try {\r\n StreamUtils.copyStream(in, out, IO_BUFFER_SIZE);\r\n } finally {\r\n // Close stream even if copyStream() threw an IOException\r\n try {\r\n out.close();\r\n } catch(IOException e) {\r\n throw new FileTransferException(FileTransferException.CLOSING_DESTINATION, e);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * Copies this file to a specified destination file, overwriting the destination if it exists. If this file is a\r\n * directory, any file or directory it contains will also be copied.\r\n *\r\n * \r\n *
\r\n *\r\n *
\r\n * In that case, no clean up is performed if an error occurs in the midst of a transfer: files that have been copied\r\n * (even partially) are left in the destination.
\r\n * It is also worth noting that symbolic links are not copied to the destination when encountered: neither the link\r\n * nor the linked file is copied\r\n *\r\n * @param destFile the destination file to copy this file to\r\n * @throws IOException in any of the error cases listed above\r\n */\r\n public final void copyTo(AbstractFile destFile) throws IOException {\r\n // First, try to perform a remote copy of the file if the operation is supported\r\n if (isFileOperationSupported(FileOperation.COPY_REMOTELY)) {\r\n try {\r\n copyRemotelyTo(destFile);\r\n return; // Operation was a success, all done.\r\n } catch (IOException ignore) {}\r\n }\r\n\r\n // Fall back to copying the file manually\r\n checkCopyPrerequisites(destFile, false);\r\n\r\n // Copy the file and its contents if the file is a directory\r\n copyRecursively(this, destFile);\r\n }\r\n\r\n /**\r\n * Moves this file to a specified destination file, overwriting the destination if it exists. If this file is a\r\n * directory, any file or directory it contains will also be moved.\r\n * After normal completion, this file will not exist anymore: {@link #exists()} will return false.\r\n *\r\n * \r\n *
\r\n *\r\n *
\r\n * In that case, deletion of the source occurs only after all files have been successfully transferred.\r\n * No clean up is performed if an error occurs in the midst of a transfer: files that have been copied\r\n * (even partially) are left in the destination.
\r\n * It is also worth noting that symbolic links are not moved to the destination when encountered: neither the link\r\n * nor the linked file is moved, and the symlink file is deleted.\r\n *\r\n * @param destFile the destination file to move this file to\r\n * @throws IOException in any of the error cases listed above\r\n */\r\n public final void moveTo(AbstractFile destFile) throws IOException {\r\n // First, try to rename the file if the operation is supported\r\n if (isFileOperationSupported(FileOperation.RENAME)) {\r\n try {\r\n renameTo(destFile);\r\n // Rename was a success, all done.\r\n return;\r\n } catch (IOException ignore) {}\r\n }\r\n\r\n // Fall back to moving the file manually\r\n\r\n copyTo(destFile);\r\n\r\n // Delete the source file and its contents now that it has been copied OK.\r\n // Note that the file won't be deleted if copyTo() failed (threw an IOException)\r\n try {\r\n deleteRecursively();\r\n } catch(IOException e) {\r\n throw new FileTransferException(FileTransferException.DELETING_SOURCE);\r\n }\r\n }\r\n\r\n /**\r\n * Creates this file as an empty, non-directory file. This method will fail (throw an IOException)\r\n * if this file already exists. Note that this method may not always yield a zero-byte file (see below).\r\n *\r\n * true.\r\n *\r\n * @param filter the FileFilter to be used to filter files out from the list, may be null\r\n * @return the children files that this file contains\r\n * @throws IOException if this operation is not possible (file is not browsable) or if an error occurred.\r\n * @throws UnsupportedFileOperationException if this method relies on a file operation that is not supported\r\n * or not implemented by the underlying filesystem.\r\n */\r\n public AbstractFile[] ls(FileFilter filter) throws IOException {\r\n return filter == null ? ls() : filter.filter(ls());\r\n }\r\n\r\n\r\n /**\r\n * Returns the children files that this file contains, filtering out files that do not match the specified FilenameFilter.\r\n * For this operation to be successful, this file must be 'browsable', i.e. {@link #isBrowsable()} must return\r\n * true.\r\n *\r\n * null\r\n * @return the children files that this file contains\r\n * @throws IOException if this operation is not possible (file is not browsable) or if an error occurred.\r\n * @throws UnsupportedFileOperationException if this method relies on a file operation that is not supported\r\n * or not implemented by the underlying filesystem.\r\n */\r\n public AbstractFile[] ls(FilenameFilter filter) throws IOException {\r\n return filter == null ? ls() : filter.filter(ls());\r\n }\r\n\r\n\r\n /**\r\n * Changes this file's permissions to the specified permissions int.\r\n * The permissions int should be constructed using the permission types and accesses defined in\r\n * {@link com.mucommander.commons.file.PermissionTypes} and {@link com.mucommander.commons.file.PermissionAccesses}.\r\n *\r\n * \r\n *
\r\n *\r\n * \r\n *
\r\n *\r\n * @return a string representation of this file's permissions\r\n */\r\n public String getPermissionsString() {\r\n FilePermissions permissions = getPermissions();\r\n if (permissions == null) {\r\n return isSymlink() ? \"l???\" : isDirectory() ? \"d???\" : \"-???\";\r\n }\r\n int supportedPerms = permissions.getMask().getIntValue();\r\n\r\n StringBuilder sb = new StringBuilder();\r\n sb.append(isSymlink() ? 'l' : isDirectory() ? 'd' : '-');\r\n\r\n int perms = permissions.getIntValue();\r\n\r\n int bitShift = USER_ACCESS *3;\r\n\r\n // Permissions go by triplets (rwx), there are 3 of them for respectively 'owner', 'group' and 'other' accesses.\r\n // The first one ('owner') will always be displayed, regardless of the permission bit mask. 'Group' and 'other'\r\n // will be displayed only if the permission mask contains information about them (at least one permission bit).\r\n for (int a = USER_ACCESS; a >= OTHER_ACCESS; a--) {\r\n if (a == USER_ACCESS || (supportedPerms & (7<d---, no matter\r\n * what permission values the FilePermissions returned by {@link #getPermissions()} contains-rwxrwxrwxAbstractFile methods.\r\n * true is returned, this doesn't ensure that the file operation will succeed:\r\n * additional conditions may be required for the operation to succeed and the corresponding method may throw an\r\n * IOException if those conditions are not met.\r\n *\r\n * @param op a file operation\r\n * @return true if the specified file operation is supported by this filesystem.\r\n * @see FileOperation\r\n */\r\n public boolean isFileOperationSupported(FileOperation op) {\r\n return isFileOperationSupported(op, getClass());\r\n }\r\n\r\n\r\n\r\n /**\r\n * Returns true if this file is browsable. A file is considered browsable if it contains children files\r\n * that can be retrieved by calling the ls() methods. Archive files will usually return\r\n * true, as will directories (directories are always browsable).\r\n *\r\n * @return true if this file is browsable\r\n */\r\n public final boolean isBrowsable() {\r\n return isDirectory() || isArchive();\r\n }\r\n\r\n /**\r\n * Returns the name of the file without its extension.\r\n *\r\n *
\r\n * - it contains at least one . character
\r\n * - the last . is not the last character of the filename
\r\n * - the last . is not the first character of the filename
\r\n * If this file has no extension, its full name is returned.\r\n *\r\n * @return this file's name, without its extension.\r\n * @see #getName()\r\n * @see #getExtension()\r\n */\r\n public final String getNameWithoutExtension() {\r\n String name = getName();\r\n int position = name.lastIndexOf('.');\r\n\r\n if (position <= 0 || position == name.length() - 1) {\r\n return name;\r\n }\r\n\r\n return name.substring(0, position);\r\n }\r\n\r\n /**\r\n * Shorthand for {@link #getAbsolutePath()}.\r\n *\r\n * @return the value returned by {@link #getAbsolutePath()}.\r\n */\r\n public final String getPath() {\r\n return getAbsolutePath();\r\n }\r\n\r\n /**\r\n * Returns the absolute path to this file.\r\n * A separator character will be appended to the returned path if true is passed.\r\n *\r\n * @param appendSeparator if true, a separator will be appended to the returned path\r\n * @return the absolute path to this file\r\n */\r\n public final String getAbsolutePath(boolean appendSeparator) {\r\n String path = getAbsolutePath();\r\n return appendSeparator?addTrailingSeparator(path): removeTrailingSeparator(path);\r\n }\r\n\r\n\r\n /**\r\n * Returns the canonical path to this file, resolving any symbolic links or '..' and '.' occurrences.\r\n * A separator character will be appended to the returned path if true is passed.\r\n *\r\n * @param appendSeparator if true, a separator will be appended to the returned path\r\n * @return the canonical path to this file\r\n */\r\n public final String getCanonicalPath(boolean appendSeparator) {\r\n String path = getCanonicalPath();\r\n return appendSeparator ? addTrailingSeparator(path) : removeTrailingSeparator(path);\r\n }\r\n\r\n\r\n /**\r\n * Returns a child of this file, whose path is the concatenation of this file's path and the given relative path.\r\n * Although this method does not enforce it, the specified path should be relative, i.e. should not start with\r\n * a separator.
\r\n * An IOException may be thrown if the child file could not be instantiated but the returned file\r\n * instance should never be null.\r\n *\r\n * @param relativePath the child's path, relative to this file's path\r\n * @return an AbstractFile representing the requested child file, never null\r\n * @throws IOException if the child file could not be instantiated\r\n */\r\n public final AbstractFile getChild(String relativePath) throws IOException {\r\n FileURL childURL = (FileURL)getURL().clone();\r\n childURL.setPath(addTrailingSeparator(childURL.getPath()) + relativePath);\r\n\r\n return FileFactory.getFile(childURL, true);\r\n }\r\n\r\n /**\r\n * Convenience method that acts as {@link #getChild(String)} except that it does not throw {@link IOException} but\r\n * returns null if the child could not be instantiated.\r\n *\r\n * @param relativePath the child's path, relative to this file's path\r\n * @return an AbstractFile representing the requested child file, null if it could not be instantiated\r\n */\r\n public final AbstractFile getChildSilently(String relativePath) {\r\n try {\r\n return getChild(relativePath);\r\n } catch(IOException e) {\r\n return null;\r\n }\r\n }\r\n\r\n /**\r\n * Returns a direct child of this file, whose path is the concatenation of this file's path and the given filename.\r\n * An IOException will be thrown in any of the following cases:\r\n * \r\n *
\r\n * This method never returns null.\r\n *\r\n * IOException) if this file already exists. It may also fail because of an I/O error ;\r\n * in this case, this method will not remove the parent directories it has created (if any).\r\n *\r\n * @throws IOException if this file already exists or if an I/O error occurred.\r\n * @throws UnsupportedFileOperationException if this method relies on a file operation that is not supported\r\n * or not implemented by the underlying filesystem.\r\n */\r\n public final void mkdirs() throws IOException {\r\n AbstractFile parent = getParent();\r\n if (parent != null && !parent.exists()) {\r\n parent.mkdirs();\r\n }\r\n\r\n mkdir();\r\n }\r\n\r\n\r\n /**\r\n * Convenience method that creates a file as a direct child of this directory.\r\n * This method will fail if this file is not a directory.\r\n *\r\n * @param name name of the file to create\r\n * @throws IOException if the file could not be created, either because the file already exists or for any\r\n * other reason.\r\n * @throws UnsupportedFileOperationException if this method relies on a file operation that is not supported\r\n * or not implemented by the underlying filesystem.\r\n */\r\n public final void mkfile(String name) throws IOException {\r\n getChild(name).mkfile();\r\n }\r\n\r\n\r\n /**\r\n * Returns the immediate ancestor of this AbstractFile if it has one, this otherwise:\r\n * \r\n *
\r\n *\r\n * @return the immediate ancestor of this ProxyFile, returns this\r\n * AbstractFile if it has one, this otherwise\r\n */\r\n public final AbstractFile getAncestor() {\r\n if (this instanceof ProxyFile) {\r\n return ((ProxyFile) this).getProxiedFile();\r\n }\r\n return this;\r\n }\r\n\r\n /**\r\n * Returns the first ancestor of this file that is an instance of the given Class or of a subclass of it,\r\n * or this if this instance's class matches those criteria. Returns null if this\r\n * file has no such ancestor.\r\n *
\r\n * Note that this method will always return this if AbstractFile.class is specified.\r\n *\r\n * @param abstractFileClass a Class corresponding to an AbstractFile subclass\r\n * @return the first ancestor of this file that is an instance of the given Class or of a subclass of the given\r\n * Class, or this if this instance's class matches those criteria. Returns null if this\r\n * file has no such ancestor.\r\n */\r\n public final this will be returned.\r\n *\r\n * @return returns the top-most ancestor of this file, this if this file has no ancestor\r\n */\r\n public final AbstractFile getTopAncestor() {\r\n AbstractFile topAncestor = this;\r\n while (topAncestor.hasAncestor()) {\r\n topAncestor = topAncestor.getAncestor();\r\n }\r\n\r\n return topAncestor;\r\n }\r\n\r\n /**\r\n * Returns true if this AbstractFile has an ancestor, i.e. if this file is a\r\n * {@link ProxyFile}, false otherwise.\r\n *\r\n * @return true if this AbstractFile has an ancestor, false otherwise.\r\n */\r\n public final boolean hasAncestor() {\r\n return this instanceof ProxyFile;\r\n }\r\n\r\n /**\r\n * Returns true if this file is or has an ancestor (immediate or not) that is an instance of the given\r\n * Class or of a subclass of the Class. Note that the specified must correspond to an\r\n * AbstractFile subclass. Specifying any other Class will always yield to this method returning\r\n * false. Also note that this method will always return true if\r\n * AbstractFile.class is specified.\r\n *\r\n * @param abstractFileClass a Class corresponding to an AbstractFile subclass\r\n * @return true if this file has an ancestor (immediate or not) that is an instance of the given Class\r\n * or of a subclass of the given Class.\r\n */\r\n public final boolean hasAncestor(Class abstractFileClass) {\r\n AbstractFile ancestor = this;\r\n AbstractFile lastAncestor;\r\n\r\n do {\r\n if (abstractFileClass.isAssignableFrom(ancestor.getClass())) {\r\n return true;\r\n }\r\n lastAncestor = ancestor;\r\n ancestor = ancestor.getAncestor();\r\n } while (lastAncestor != ancestor);\r\n\r\n return false;\r\n }\r\n\r\n\r\n /**\r\n * Returns true if this file is a parent folder of the given file, or if the two files are equal.\r\n *\r\n * @param file the AbstractFile to test\r\n * @return true if this file is a parent folder of the given file, or if the two files are equal\r\n */\r\n public final boolean isParentOf(AbstractFile file) {\r\n return isBrowsable() && file.getCanonicalPath(true).startsWith(getCanonicalPath(true));\r\n }\r\n\r\n /**\r\n * Convenience method that returns the parent {@link AbstractArchiveFile} that contains this file. If this file\r\n * is an {@link AbstractArchiveFile} or an ancestor of {@link AbstractArchiveFile}, this is returned.\r\n * If this file is neither contained by an archive nor is an archive, null is returned.\r\n *\r\n * null if the JVM is running on a headless environment.\r\n *\r\n * @param preferredResolution the preferred icon resolution\r\n * @return an icon representing this file, null if the JVM is running on a headless environment\r\n * @see com.mucommander.commons.file.FileFactory#getDefaultFileIconProvider()\r\n * @see com.mucommander.commons.file.icon.FileIconProvider#getFileIcon(AbstractFile, java.awt.Dimension)\r\n */\r\n public final Icon getIcon(Dimension preferredResolution) {\r\n return FileFactory.getDefaultFileIconProvider().getFileIcon(this, preferredResolution);\r\n }\r\n\r\n /**\r\n * Returns an icon representing this file, using the default {@link com.mucommander.commons.file.icon.FileIconProvider}\r\n * registered in {@link FileFactory}. The default preferred resolution for the icon is 16x16 pixels.\r\n * This method may return null if the JVM is running on a headless environment.\r\n *\r\n * @return an icon representing this file, null if the JVM is running on a headless environment\r\n * @see com.mucommander.commons.file.FileFactory#getDefaultFileIconProvider()\r\n * @see com.mucommander.commons.file.icon.FileIconProvider#getFileIcon(AbstractFile, java.awt.Dimension)\r\n */\r\n public final Icon getIcon() {\r\n // Note: the Dimension object is created here instead of returning a final static field, because creating\r\n // a Dimension object triggers the AWT and Swing classes loading. Since these classes are not\r\n // needed in a headless environment, we want them to be loaded only if strictly necessary.\r\n return getIcon(new java.awt.Dimension(16, 16));\r\n }\r\n\r\n\r\n /**\r\n * Returns a checksum of this file (also referred to as hash or digest) calculated by reading this\r\n * file's contents and feeding the bytes to the given MessageDigest, until EOF is reached.\r\n *\r\n * MessageDigest after the checksum has been calculated.\r\n *\r\n * @param algorithm the algorithm to use for calculating the checksum\r\n * @return this file's checksum, as an hexadecimal string\r\n * @throws IOException if an I/O error occurred while calculating the checksum\r\n * @throws NoSuchAlgorithmException if the specified algorithm does not correspond to any MessageDigest registered\r\n * with the Java Cryptography Extension.\r\n * @throws UnsupportedFileOperationException if this method relies on a file operation that is not supported\r\n * or not implemented by the underlying filesystem.\r\n */\r\n public final String calculateChecksum(String algorithm) throws IOException, NoSuchAlgorithmException {\r\n return calculateChecksum(MessageDigest.getInstance(algorithm));\r\n }\r\n\r\n /**\r\n * Returns a checksum of this file (also referred to as hash or digest) calculated by reading this\r\n * file's contents and feeding the bytes to the given MessageDigest, until EOF is reached.\r\n *\r\n * MessageDigest.\r\n *\r\n * MessageDigest after the checksum has been calculated.\r\n *\r\n * @param messageDigest the MessageDigest to use for calculating the checksum\r\n * @return this file's checksum, as an hexadecimal string\r\n * @throws IOException if an I/O error occurred while calculating the checksum\r\n * @throws UnsupportedFileOperationException if this method relies on a file operation that is not supported\r\n * or not implemented by the underlying filesystem.\r\n */\r\n public final String calculateChecksum(MessageDigest messageDigest) throws IOException {\r\n try (InputStream in = getInputStream()) {\r\n return calculateChecksum(in, messageDigest);\r\n }\r\n }\r\n\r\n\r\n /**\r\n * Tests if the given path contains a trailing separator, and if not, adds one to the returned path.\r\n * The separator used is the one returned by {@link #getSeparator()}.\r\n *\r\n * @param path the path for which to add a trailing separator\r\n * @return the path with a trailing separator\r\n */\r\n public final String addTrailingSeparator(String path) {\r\n // Even though getAbsolutePath() is not supposed to return a trailing separator, root folders ('/', 'c:\\' ...)\r\n // are exceptions that's why we still have to test if path ends with a separator\r\n String separator = getSeparator();\r\n if (!path.endsWith(separator)) {\r\n return path + separator;\r\n }\r\n return path;\r\n }\r\n\r\n /**\r\n * Tests if the given path contains a trailing separator, and if it does, removes it from the returned path.\r\n * The separator used is the one returned by {@link #getSeparator()}.\r\n *\r\n * @param path the path for which to remove the trailing separator\r\n * @return the path free of a trailing separator\r\n */\r\n protected final String removeTrailingSeparator(String path) {\r\n // Remove trailing slash if path is not '/' or trailing backslash if path does not end with ':\\'\r\n // (Reminder: C: is C's current folder, while C:\\ is C's root)\r\n String separator = getSeparator();\r\n if (path.endsWith(separator)\r\n && !((separator.equals(\"/\") && path.length() == 1) || (separator.equals(\"\\\\\") && path.charAt(path.length()-2)==':')))\r\n path = path.substring(0, path.length()-1);\r\n return path;\r\n }\r\n\r\n\r\n /**\r\n * Checks the prerequisites of a copy (or move) operation.\r\n * Throws a {@link FileTransferException} if any of the following conditions are true, does nothing otherwise:\r\n * \r\n *
\r\n *\r\n * @param destFile the destination file to copy this file to\r\n * @param allowCaseVariations prevents throwing an exception if both file names are a case variation of one another\r\n * @throws FileTransferException in any of the cases listed above, use {@link FileTransferException#getReason()} to\r\n * know the reason.\r\n */\r\n protected final void checkCopyPrerequisites(AbstractFile destFile, boolean allowCaseVariations) throws FileTransferException {\r\n boolean isAllowedCaseVariation = false;\r\n\r\n // Throw an exception of a specific kind if the source and destination files refer to the same file\r\n boolean filesEqual = this.equalsCanonical(destFile);\r\n if (filesEqual) {\r\n // If case variations are allowed and the destination filename is a case variation of the source,\r\n // do not throw an exception.\r\n if (allowCaseVariations) {\r\n String sourceFileName = getName();\r\n String destFileName = destFile.getName();\r\n if (sourceFileName.equalsIgnoreCase(destFileName) && !sourceFileName.equals(destFileName)) {\r\n isAllowedCaseVariation = true;\r\n }\r\n }\r\n\r\n if (!isAllowedCaseVariation) {\r\n throw new FileTransferException(FileTransferException.SOURCE_AND_DESTINATION_IDENTICAL);\r\n }\r\n }\r\n\r\n // Throw an exception if source is a parent of destination\r\n if (!filesEqual && isParentOf(destFile)) { // Note: isParentOf(destFile) returns true if both files are equal\r\n throw new FileTransferException(FileTransferException.SOURCE_PARENT_OF_DESTINATION);\r\n }\r\n\r\n // Throw an exception if the source file does not exist\r\n if (!exists()) {\r\n throw new FileTransferException(FileTransferException.FILE_NOT_FOUND);\r\n }\r\n }\r\n\r\n /**\r\n * Checks the prerequisites of a {@link #copyRemotelyTo(AbstractFile)} operation.\r\n * This method starts by verifying the following requirements and throws an allowCaseVariations is true\r\n * and the destination filename is a case variation of the sourceIOException if one of them\r\n * isn't met:\r\n * \r\n *
\r\n * If all those requirements are met, {@link #checkCopyPrerequisites(AbstractFile, boolean)} is called with the\r\n * destination file and allowDifferentHosts is trueallowCaseVariations flag to perform prerequisites verifications.\r\n *\r\n * @param destFile the destination file to copy this file to\r\n * @param allowCaseVariations prevents throwing an exception if both file names are a case variation of one another\r\n * @param allowDifferentHosts prevents throwing an exception if both files have the same host\r\n * @throws FileTransferException in any of the cases listed above, use {@link FileTransferException#getReason()} to\r\n * know the reason.\r\n * @see #checkCopyPrerequisites(AbstractFile, boolean)\r\n */\r\n protected final void checkCopyRemotelyPrerequisites(AbstractFile destFile, boolean allowCaseVariations, boolean allowDifferentHosts) throws IOException {\r\n if (!fileURL.schemeEquals(fileURL)\r\n || !destFile.getTopAncestor().getClass().equals(getTopAncestor().getClass())\r\n || (!allowDifferentHosts && !destFile.getURL().hostEquals(fileURL)))\r\n throw new IOException();\r\n\r\n checkCopyPrerequisites(destFile, allowCaseVariations);\r\n }\r\n\r\n /**\r\n * Checks the prerequisites of a {@link #renameTo(AbstractFile)} operation.\r\n * This method starts by verifying the following requirements and throws an IOException if one of them\r\n * isn't met:\r\n * \r\n *
\r\n * If all those requirements are met, {@link #checkCopyPrerequisites(AbstractFile, boolean)} is called with the\r\n * destination file and allowDifferentHosts is trueallowCaseVariations flag to perform further prerequisites verifications.\r\n *\r\n * @param destFile the destination file to copy this file to\r\n * @param allowCaseVariations prevents throwing an exception if both file names are a case variation of one another\r\n * @param allowDifferentHosts prevents throwing an exception if both files have the same host\r\n * @throws FileTransferException in any of the cases listed above, use {@link FileTransferException#getReason()} to\r\n * know the reason.\r\n * @see #checkCopyPrerequisites(AbstractFile, boolean)\r\n */\r\n protected final void checkRenamePrerequisites(AbstractFile destFile, boolean allowCaseVariations, boolean allowDifferentHosts) throws IOException {\r\n checkCopyRemotelyPrerequisites(destFile, allowCaseVariations, allowDifferentHosts);\r\n }\r\n\r\n /**\r\n * Copies the source file to the destination one and recurses on directory contents.\r\n * This method assumes that the destination file does not exists, this must be checked prior to calling this method.\r\n * Symbolic links are skipped when encountered: neither the link nor the linked file are copied.\r\n *\r\n * @param sourceFile the file to copy\r\n * @param destFile the destination file\r\n * @throws FileTransferException if an error occurred while copying the file\r\n */\r\n protected final void copyRecursively(AbstractFile sourceFile, AbstractFile destFile) throws FileTransferException {\r\n if (sourceFile.isSymlink()) {\r\n return;\r\n }\r\n\r\n if (sourceFile.isDirectory()) {\r\n try {\r\n destFile.mkdir();\r\n } catch(IOException e) {\r\n throw new FileTransferException(FileTransferException.WRITING_DESTINATION);\r\n }\r\n\r\n AbstractFile[] children;\r\n try {\r\n children = sourceFile.ls();\r\n } catch(IOException e) {\r\n throw new FileTransferException(FileTransferException.READING_SOURCE);\r\n }\r\n\r\n AbstractFile destChild;\r\n for (AbstractFile child : children) {\r\n try {\r\n destChild = destFile.getDirectChild(child.getName());\r\n } catch (IOException e) {\r\n throw new FileTransferException(FileTransferException.OPENING_DESTINATION);\r\n }\r\n copyRecursively(child, destChild);\r\n }\r\n } else {\r\n// try (InputStream in = sourceFile.getInputStream()) {\r\n// destFile.copyStream(in, false, sourceFile.getSize());\r\n// } catch (IOException e) {\r\n// throw new FileTransferException(FileTransferException.OPENING_SOURCE);\r\n// }\r\n InputStream in;\r\n\r\n try {\r\n in = sourceFile.getInputStream();\r\n } catch(IOException e) {\r\n throw new FileTransferException(FileTransferException.OPENING_SOURCE);\r\n }\r\n\r\n try {\r\n destFile.copyStream(in, false, sourceFile.getSize());\r\n } finally {\r\n // Close stream even if copyStream() threw an IOException\r\n try {\r\n in.close();\r\n } catch (IOException e) {\r\n throw new FileTransferException(FileTransferException.CLOSING_SOURCE);\r\n }\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * Deletes the given file. If the file is a directory, enclosing files are deleted recursively.\r\n * Symbolic links to directories are simply deleted, without deleting the contents of the linked directory.\r\n *\r\n * @param file the file to delete\r\n * @throws IOException if an error occurred while deleting a file or listing a directory's contents\r\n * @throws UnsupportedFileOperationException if this method relies on a file operation that is not supported\r\n * or not implemented by the underlying filesystem.\r\n */\r\n private void deleteRecursively(AbstractFile file) throws IOException {\r\n if (file.isDirectory() && !file.isSymlink()) {\r\n AbstractFile[] children = file.ls();\r\n for (AbstractFile child : children) {\r\n deleteRecursively(child);\r\n }\r\n }\r\n\r\n file.delete();\r\n }\r\n\r\n /**\r\n * Convenience method that calls {@link #changePermissions(int)} with the given permissions' int value.\r\n *\r\n * @param permissions new permissions for this file\r\n * @throws IOException if the permissions couldn't be changed, either because of insufficient permissions or because\r\n * of an I/O error.\r\n * @throws UnsupportedFileOperationException if this method relies on a file operation that is not supported\r\n * or not implemented by the underlying filesystem.\r\n */\r\n public final void changePermissions(FilePermissions permissions) throws IOException {\r\n changePermissions(permissions.getIntValue());\r\n }\r\n\r\n /**\r\n * This method is a shorthand for {@link #importPermissions(AbstractFile, FilePermissions)} called with\r\n * {@link FilePermissions#DEFAULT_DIRECTORY_PERMISSIONS} if this file is a directory or\r\n * {@link FilePermissions#DEFAULT_FILE_PERMISSIONS} if this file is a regular file.\r\n *\r\n * @param sourceFile the file from which to import permissions\r\n * @throws IOException if the permissions couldn't be changed, either because of insufficient permissions or because\r\n * of an I/O error.\r\n * @throws UnsupportedFileOperationException if this method relies on a file operation that is not supported\r\n * or not implemented by the underlying filesystem.\r\n */\r\n public final void importPermissions(AbstractFile sourceFile) throws IOException {\r\n importPermissions(sourceFile, isDirectory()\r\n ? FilePermissions.DEFAULT_DIRECTORY_PERMISSIONS\r\n : FilePermissions.DEFAULT_FILE_PERMISSIONS);\r\n }\r\n\r\n /**\r\n * Imports the given source file's permissions, overwriting this file's permissions. Only the bits that are\r\n * supported by the source file (as reported by the permissions' mask) are preserved. Other bits are be\r\n * set to those of the specified default permissions.\r\n * See {@link SimpleFilePermissions#padPermissions(FilePermissions, FilePermissions)} for more information about\r\n * permissions padding.\r\n *\r\n * @param sourceFile the file from which to import permissions\r\n * @param defaultPermissions default permissions to use\r\n * @throws IOException if the permissions couldn't be changed, either because of insufficient permissions or because\r\n * of an I/O error.\r\n * @throws UnsupportedFileOperationException if this method relies on a file operation that is not supported\r\n * or not implemented by the underlying filesystem.\r\n * @see SimpleFilePermissions#padPermissions(FilePermissions, FilePermissions)\r\n */\r\n public final void importPermissions(AbstractFile sourceFile, FilePermissions defaultPermissions) throws IOException {\r\n changePermissions(SimpleFilePermissions.padPermissions(sourceFile.getPermissions(), defaultPermissions).getIntValue());\r\n }\r\n\r\n\r\n ////////////////////\r\n // Static methods //\r\n ////////////////////\r\n\r\n /**\r\n * Returns true if the specified file operation and corresponding method is supported by the\r\n * given AbstractFile implementation.
\r\n * See the {@link FileOperation} enum for a complete list of file operations and their corresponding\r\n * AbstractFile methods.\r\n *\r\n * @param op a file operation\r\n * @param c the file implementation to test\r\n * @return true if the specified file operation is supported by this filesystem.\r\n * @see FileOperation\r\n */\r\n public static boolean isFileOperationSupported(FileOperation op, Class c) {\r\n Method method = op.getCorrespondingMethod(c);\r\n return method != null && !method.isAnnotationPresent(UnsupportedFileOperation.class);\r\n }\r\n\r\n /**\r\n * Returns the given filename's extension, null if the filename doesn't have an extension.\r\n *\r\n *
\r\n * - it contains at least one . character
\r\n * - the last . is not the last character of the filename
\r\n * - the last . is not the first character of the filename\r\n *\r\n * .). For instance,\r\n * this method will return \"ext\" for a file named \"name.ext\", not \".ext\".\r\n *\r\n * @param filename a filename, not a full path\r\n * @return the given filename's extension, null if the filename doesn't have an extension\r\n */\r\n public static String getExtension(String filename) {\r\n int lastDotPos = filename.lastIndexOf('.');\r\n if (lastDotPos <= 0) {\r\n return null;\r\n }\r\n int len = filename.length();\r\n if (lastDotPos == len-1) {\r\n return null;\r\n }\r\n return filename.substring(lastDotPos+1, len);\r\n }\r\n\r\n\r\n /**\r\n * Returns the given filename without its extension (base name). if the filename doesn't have an extension, returns the filename as received\r\n *\r\n *
\r\n * - it contains at least one . character
\r\n * - the last . is not the last character of the filename
\r\n * - the last . is not the first character of the filename\r\n *\r\n * @return the file's base name - without its extension, if the filename doesn't have an extension returns the filename as received\r\n */\r\n public String getBaseName() {\r\n String fileName = getName();\r\n int lastDotPos = fileName.lastIndexOf('.');\r\n if (lastDotPos <= 0 || lastDotPos == fileName.length()-1) {\r\n return fileName;\r\n }\r\n \r\n return fileName.substring(0, lastDotPos);\r\n }\r\n \r\n /**\r\n * Returns the checksum (also referred to as hash or digest) of the given InputStream\r\n * calculated by reading the stream and feeding the bytes to the given MessageDigest until EOF is\r\n * reached.\r\n *\r\n * InputStream, and does not reset the\r\n * MessageDigest after the checksum has been calculated.\r\n *\r\n * @param in the InputStream for which to calculate the checksum\r\n * @param messageDigest the MessageDigest to use for calculating the checksum\r\n * @return the given InputStream's checksum, as an hexadecimal string\r\n * @throws IOException if an I/O error occurred while calculating the checksum\r\n */\r\n public static String calculateChecksum(InputStream in, MessageDigest messageDigest) throws IOException {\r\n ChecksumInputStream cin = new ChecksumInputStream(in, messageDigest);\r\n try {\r\n StreamUtils.readUntilEOF(cin);\r\n return cin.getChecksumString();\r\n } catch (IOException e) {\r\n throw new FileTransferException(FileTransferException.READING_SOURCE);\r\n }\r\n }\r\n\r\n \r\n ////////////////////////\r\n // Overridden methods //\r\n ////////////////////////\r\n\r\n /**\r\n * Tests a file for equality by comparing both files' {@link #getURL() URL}. Returns true if the URL\r\n * of this file and the specified one are equal according to {@link FileURL#equals(Object, boolean, boolean)} called\r\n * with credentials and properties comparison enabled.\r\n *\r\n * true if the URL of this file and the specified one are equal\r\n * @see FileURL#equals(Object, boolean, boolean)\r\n * @see #equalsCanonical(Object)\r\n */\r\n public boolean equals(Object o) {\r\n return o instanceof AbstractFile && getURL().equals(((AbstractFile) o).getURL(), true, true);\r\n }\r\n\r\n /**\r\n * Tests a file for equality by comparing both files' {@link #getCanonicalPath() canonical path}.\r\n * Returns true if the canonical path of this file and the specified one are equal.\r\n *\r\n * java.lang.String#equals(Object) to compare paths, which\r\n * in some rare cases may return false for non-ascii/Unicode paths that have the same written\r\n * representation but are not equal according to java.lang.String#equals(Object). Handling such cases\r\n * would require a locale-aware String comparison which is not an option here.\r\n *\r\n * true if the canonical path of this file and the specified one are equal.\r\n * @see #equals(Object)\r\n */\r\n public boolean equalsCanonical(Object o) {\r\n if (o instanceof AbstractFile) {\r\n // TODO: resolve hostnames ?\r\n return getCanonicalPath(false).equals(((AbstractFile)o).getCanonicalPath(false));\r\n }\r\n return false;\r\n }\r\n\r\n /**\r\n * Returns the hashCode of this file's {@link #getURL() URL}.\r\n *\r\n * @return the hashCode of this file's {@link #getURL() URL}.\r\n */\r\n public int hashCode() {\r\n return getURL().hashCode();\r\n }\r\n\r\n /**\r\n * Returns a String representation of this file. The returned String is this file's path as returned by\r\n * {@link #getAbsolutePath()}.\r\n */\r\n public String toString() {\r\n return getAbsolutePath();\r\n }\r\n\r\n\r\n //////////////////////\r\n // Abstract methods //\r\n //////////////////////\r\n\r\n /**\r\n * Returns this file's last modified date, in milliseconds since the epoch (00:00:00 GMT, January 1, 1970).\r\n *\r\n * @return this file's last modified date, in milliseconds since the epoch (00:00:00 GMT, January 1, 1970)\r\n */\r\n public abstract long getLastModifiedDate();\r\n\r\n /**\r\n * Returns this file's creation date, in milliseconds since the epoch (00:00:00 GMT, January 1, 1970).\r\n *\r\n * @throws IOException if an I/O error occurred\r\n * @return creation date\r\n */\r\n public long getCreationDate() throws IOException {\r\n throw new IOException(\"operation not supported\");\r\n }\r\n\r\n /**\r\n * Returns this file's last access date, in milliseconds since the epoch (00:00:00 GMT, January 1, 1970).\r\n *\r\n * @throws IOException if an I/O error occurred\r\n * @return last access date\r\n */\r\n public long getLastAccessDate() throws IOException {\r\n throw new IOException(\"operation not supported\");\r\n }\r\n\r\n /**\r\n * Changes this file's last modified date to the specified one. Throws an IOException if the date\r\n * couldn't be changed, either because of insufficient permissions or because of an I/O error.\r\n *\r\n * 0 if this file doesn't exist, -1 if the size is\r\n * undetermined.\r\n *\r\n * @return this file's size in bytes, 0 if this file doesn't exist, -1 if the size is undetermined\r\n */\r\n public abstract long getSize();\r\n\t\r\n /**\r\n * Returns this file's parent, null if it doesn't have one.\r\n *\r\n * @return this file's parent, null if it doesn't have one\r\n */\r\n public abstract AbstractFile getParent();\r\n\t\r\n /**\r\n * Sets this file's parent. null can be specified if this file doesn't have a parent.\r\n *\r\n * @param parent the new parent of this file\r\n */\r\n public abstract void setParent(AbstractFile parent);\r\n\r\n /**\r\n * Returns true if this file exists.\r\n *\r\n * @return true if this file exists\r\n */\r\n public abstract boolean exists();\r\n\r\n /**\r\n * Returns this file's permissions, as a {@link FilePermissions} object. Note that this file may only support\r\n * certain permission bits, use the {@link com.mucommander.commons.file.FilePermissions#getMask() permission mask} to find\r\n * out which bits are supported.\r\n *\r\n * null.\r\n *\r\n * @return this file's permissions, as a FilePermissions object\r\n */\r\n public abstract FilePermissions getPermissions();\r\n\r\n /**\r\n * Returns a bit mask describing the permission bits that can be changed on this file when calling\r\n * {@link #changePermission(int, int, boolean)} and {@link #changePermissions(int)}.\r\n *\r\n * @return a bit mask describing the permission bits that can be changed on this file\r\n */\r\n public abstract PermissionBits getChangeablePermissions();\r\n\r\n /**\r\n * Changes the specified permission bit.\r\n *\r\n * AbstractFile implementation (cannot be retrieved or\r\n * the filesystem doesn't have any notion of owner) or not available for this particular file, null\r\n * will be returned.\r\n *\r\n * @return information about the owner of this file\r\n */\r\n public abstract String getOwner();\r\n\r\n\r\n /**\r\n * Returns information about the owner of this file. The kind of information that is returned is implementation-dependant.\r\n * It may typically be a username (e.g. 'bob') or a user ID (e.g. '501').\r\n * If the owner information is not available to the AbstractFile implementation (cannot be retrieved or\r\n * the filesystem doesn't have any notion of owner) or not available for this particular file, null\r\n * will be returned.\r\n *\r\n * @return information about the owner of this file\r\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\r\n * or is not implemented.\r\n */\r\n public abstract short getReplication() throws UnsupportedFileOperationException;\r\n\r\n\r\n /**\r\n * Returns information about the owner of this file. The kind of information that is returned is implementation-dependant.\r\n * It may typically be a username (e.g. 'bob') or a user ID (e.g. '501').\r\n * If the owner information is not available to the AbstractFile implementation (cannot be retrieved or\r\n * the filesystem doesn't have any notion of owner) or not available for this particular file, null\r\n * will be returned.\r\n *\r\n * @return information about the owner of this file\r\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\r\n * or is not implemented.\r\n */\r\n public abstract long getBlocksize() throws UnsupportedFileOperationException;\r\n\r\n /**\r\n * Returns true if this file implementation is able to return some information about file owners, not\r\n * necessarily for all files or this file in particular but at least for some of them. In other words, a\r\n * true return value doesn't mean that {@link #getOwner()} will necessarily return a non-null value,\r\n * but rather that there is a chance that it does.\r\n *\r\n * @return true if this file implementation is able to return information about file owners \r\n */\r\n public abstract boolean canGetOwner();\r\n\r\n /**\r\n * Returns information about the group this file belongs to. The kind of information that is returned is implementation-dependant.\r\n * It may typically be a group name (e.g. 'www-data') or a group ID (e.g. '501').\r\n * If the group information is not available to the AbstractFile implementation (cannot be retrieved or\r\n * the filesystem doesn't have any notion of owner) or not available for this particular file, null\r\n * will be returned.\r\n *\r\n * @return information about the owner of this file\r\n */\r\n public abstract String getGroup();\r\n\r\n /**\r\n * Returns true if this file implementation is able to return some information about file groups, not\r\n * necessarily for all files or this file in particular but at least for some of them. In other words, a\r\n * true return value doesn't mean that {@link #getGroup()} will necessarily return a non-null value,\r\n * but rather that there is a chance that it does.\r\n *\r\n * @return true if this file implementation is able to return information about file groups\r\n */\r\n public abstract boolean canGetGroup();\r\n\r\n /**\r\n * Returns true if this file is a directory, false in any of the following cases:\r\n * \r\n *
\r\n *\r\n * @return true if this file is a directory, false in any of the cases listed above\r\n */\r\n public abstract boolean isDirectory();\r\n\r\n /**\r\n * Returns true if this file is an archive.\r\n * true if this file is an archive.\r\n */\r\n public abstract boolean isArchive();\r\n\r\n /**\r\n * Returns true if this file is a symbolic link. Symbolic links need to be handled with special care,\r\n * especially when manipulating files recursively.\r\n *\r\n * @return true if this file is a symbolic link\r\n */\r\n public abstract boolean isSymlink();\r\n\r\n /**\r\n * Returns true if this file is a system file.\r\n * Note that system file attribute depends on the OS, so we can know it only for local files:\r\n * - For MAC OS, {@link MacOsSystemFolder} defines the group of system files\r\n * - On Windows, files has special attribute that mark them as system files\r\n *\r\n * @return true if this file is a system file\r\n */\r\n public abstract boolean isSystem();\r\n\t\r\n /**\r\n * Returns the children files that this file contains. For this operation to be successful, this file must be\r\n * 'browsable', i.e. {@link #isBrowsable()} must return true.\r\n * This method may return a zero-length array if it has no children but may never return null.\r\n *\r\n * IOException) if this file\r\n * already exists.\r\n *\r\n * InputStream to read the contents of this file.\r\n * Throws an IOException in any of the following cases:\r\n * \r\n *
\r\n * This method may never return null.\r\n *\r\n * InputStream to read the contents of this file\r\n * @throws IOException in any of the cases listed above\r\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\r\n * or is not implemented.\r\n */\r\n public abstract InputStream getInputStream() throws IOException;\r\n\r\n /**\r\n * Returns an OutputStream to write the contents of this file, overwriting the existing contents, if any.\r\n * This file will be created as a zero-byte file if it does not yet exist.\r\n * IOException in any of the following cases, but may never return\r\n * null:\r\n * \r\n *
\r\n *\r\n * OutputStream to write the contents of this file\r\n * @throws IOException in any of the cases listed above\r\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\r\n * or is not implemented.\r\n */\r\n public abstract OutputStream getOutputStream() throws IOException;\r\n\r\n /**\r\n * Returns an OutputStream to write the contents of this file, appending the existing contents, if any.\r\n * This file will be created as a zero-byte file if it does not yet exist.\r\n * IOException in any of the following cases, but may never return\r\n * null:\r\n * \r\n *
\r\n *\r\n * OutputStream to write the contents of this file\r\n * @throws IOException in any of the cases listed above\r\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\r\n * or is not implemented.\r\n */\r\n public abstract OutputStream getAppendOutputStream() throws IOException;\r\n\r\n /**\r\n * Returns a {@link RandomAccessInputStream} to read the contents of this file with random access.\r\n * Throws an IOException in any of the following cases:\r\n * \r\n *
\r\n * This method may never return null.\r\n *\r\n * RandomAccessInputStream to read the contents of this file with random access\r\n * @throws IOException in any of the cases listed above\r\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\r\n * or is not implemented.\r\n */\r\n public abstract RandomAccessInputStream getRandomAccessInputStream() throws IOException;\r\n\r\n /**\r\n * Returns a {@link RandomAccessOutputStream} to write the contents of this file with random access.\r\n * This file will be created as a zero-byte file if it does not yet exist.\r\n * Throws an IOException in any of the following cases:\r\n * \r\n *
\r\n * This method may never return null.\r\n *\r\n * RandomAccessOutputStream to write the contents of this file with random access\r\n * @throws IOException in any of the cases listed above\r\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\r\n * or is not implemented.\r\n */\r\n public abstract RandomAccessOutputStream getRandomAccessOutputStream() throws IOException;\r\n\r\n /**\r\n * Deletes this file and this file only (does not recurse on folders).\r\n * Throws an IOException in any of the following cases:\r\n * \r\n *
\r\n *\r\n * false.\r\n *\r\n * \r\n *
\r\n *\r\n * \r\n *
\r\n *\r\n * -1 if this information is\r\n * not available.\r\n *\r\n * -1 if this information is\r\n * not available.\r\n * @throws IOException if an I/O error occurred\r\n * @throws UnsupportedFileOperationException if this operation is not supported by the underlying filesystem,\r\n * or is not implemented.\r\n */\r\n public abstract long getFreeSpace() throws IOException;\r\n\r\n /**\r\n * Returns the total space (in bytes) of the disk/volume where this file is.\r\n *\r\n * AbstractFile. Note however that the\r\n * returned Object type may change over time, if the underlying API used to provide access to the filesystem\r\n * changes, so this method should be used only as a last resort.\r\n *\r\n * null is returned.\r\n *\r\n * @return the file Object of the underlying API providing access to the filesystem, null if there\r\n * is none\r\n */\r\n public abstract Object getUnderlyingFileObject();\r\n\r\n\r\n\r\n /**\r\n * Returns the stream which can be re-used for file reading.\r\n * All method calls will return the same class until the stream was closed.\r\n * If the stream has been created but has insufficient buffer size it will be recreated.\r\n * This method used for the file viewer and editor etc. to prevent multiple re-opening of files (and archives).\r\n *\r\n * @param bufferSize minimum size of buffer for PushbackInputStream.\r\n * @return he stream which can be re-used for file reading\r\n * @throws IOException if an I/O error occurred\r\n */\r\n public synchronized PushbackInputStream getPushBackInputStream(final int bufferSize) throws IOException {\r\n if (pushbackInputStream == null) {\r\n pushbackInputStream = new MuPushbackInputStream(getInputStream(), bufferSize);\r\n } else if (pushbackInputStream.getBufferSize() < bufferSize) {\r\n pushbackInputStream.close();\r\n pushbackInputStream = new MuPushbackInputStream(getInputStream(), bufferSize);\r\n }\r\n return pushbackInputStream;\r\n }\r\n\r\n\r\n /**\r\n * Closes PushbackStream if it exists\r\n * @throws IOException if an I/O error occurred\r\n */\r\n public void closePushbackInputStream() throws IOException {\r\n if (pushbackInputStream != null) {\r\n pushbackInputStream.close();\r\n }\r\n }\r\n\r\n public boolean isLocalFile() {\r\n return FileProtocols.FILE.equals(fileURL.getScheme()) && hasAncestor(LocalFile.class);\r\n }\r\n\r\n\r\n /**\r\n *\r\n */\r\n private class MuPushbackInputStream extends PushbackInputStream implements HasProgress {\r\n\r\n private final InputStream src;\r\n\r\n// public MuPushbackInputStream(InputStream in) {\r\n// super(in);\r\n// src = in;\r\n// }\r\n\r\n MuPushbackInputStream(InputStream in, int size) {\r\n super(in, size);\r\n src = in;\r\n }\r\n\r\n @Override\r\n public void close() throws IOException {\r\n synchronized (AbstractFile.this) {\r\n super.close();\r\n src.close();\r\n pushbackInputStream = null;\r\n }\r\n }\r\n\r\n int getBufferSize() {\r\n return buf.length;\r\n }\r\n\r\n @Override\r\n public int getProgress() {\r\n return hasProgress() ? ((HasProgress)in).getProgress() : -1;\r\n }\r\n\r\n @Override\r\n public boolean hasProgress() {\r\n return in instanceof HasProgress;\r\n }\r\n }\r\n}\r\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/AbstractFileClassLoader.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see ClassLoader implementation capable of loading classes from instances of {@link AbstractFile}.\n * AbstractFileClassLoader.\n * @param parent parent of the class loader.\n */\n public AbstractFileClassLoader(ClassLoader parent) {\n super(parent);\n files = new Vector<>();\n }\n\n /**\n * Creates a new AbstractFileClassLoader that uses the system classloader as a parent.\n */\n public AbstractFileClassLoader() {\n this(ClassLoader.getSystemClassLoader());\n }\n\n\n /**\n * Adds the specified file to the class loader's classpath.\n * file is not browsable.\n */\n public void addFile(AbstractFile file) {\n // Makes sure the specified file is browsable.\n if (!file.isBrowsable()) {\n throw new IllegalArgumentException();\n }\n // Only adds the file if it's not already there.\n if (!contains(file)) {\n files.add(file);\n }\n }\n\n /**\n * Returns an iterator on all files in this loader's classpath.\n * @return an iterator on all files in this loader's classpath.\n */\n public Iteratortrue if this loader's classpath already contains the specified file.\n * @param file file to look for.\n * @return true if this loader's classpath already contains the specified file.\n */\n public boolean contains(AbstractFile file) {\n return files.contains(file);\n }\n\n\n\n // - Resource access -------------------------------------------------------\n // -------------------------------------------------------------------------\n /**\n * Tries to locate the specified resource and returns an AbstractFile instance on it.\n * @param name name of the resource to locate.\n * @return an {@link AbstractFile} instance describing the requested resource if found, null otherwise.\n */\n private AbstractFile findResourceAsFile(String name) {\n for (AbstractFile file : files) {\n try {\n // If the requested resource could be found, returns it.\n final AbstractFile child = file.getChild(name);\n if (child.exists()) {\n return child;\n }\n } catch(IOException ignore) {\n if (LOGGER != null) {\n LOGGER.info(\"\");\n }\n }\n // Treats error as a simple 'resource not found' case and keeps looking for\n // one with the correct name that will load.\n }\n\n // The requested resource wasn't found.\n return null;\n }\n\n /**\n * Returns an input stream on the requested resource.\n * @param name name of the resource to open.\n * @return an input stream on the requested resource, null if not found.\n */\n @Override\n public InputStream getResourceAsStream(String name) {\n InputStream in = getParent().getResourceAsStream(name); // Input stream on the resource.\n\n // Tries the parent first, to respect the delegation model.\n if (in != null) {\n return in;\n }\n\n // Tries to locate the resource in the extended classpath if it wasn't found in the parent.\n AbstractFile file = findResourceAsFile(name); // File representing the resource.\n if (file != null) {\n try {\n return file.getInputStream();\n } catch(Exception e) {\n if (LOGGER != null) {\n LOGGER.info(\"\", e);\n }\n }\n }\n\n // Couldn't find the resource.\n return null;\n }\n\n /**\n * Tries to find the requested resource.\n * @param name name of the resource to locate.\n * @return the URL of the requested resource if found, null otherwise.\n */\n @Override\n protected URL findResource(String name) {\n AbstractFile file = findResourceAsFile(name); // Path to the requested resource.\n\n // Tries to find the resource.\n if (file == null) {\n return null;\n }\n\n // Tries to retrieve an URL on the resource.\n try {\n return file.getJavaNetURL();\n } catch(Exception e) {\n return null;\n }\n }\n\n /**\n * Tries to find all the resources with the specified name.\n * @param name of the resources to find.\n * @return an enumeration containing the URLs of all the resources that match name.\n */\n @Override\n protected Enumerationnull otherwise.\n */\n @Override\n protected String findLibrary(String name) {\n AbstractFile file = findResourceAsFile(name); // Path of the requested library.\n return file == null ? null : file.getAbsolutePath();\n }\n\n\n\n // - Class loading ---------------------------------------------------------\n // -------------------------------------------------------------------------\n /**\n * Loads and returns the class defined by the specified name and path.\n * @param name name of the class to load.\n * @param file file containing the class' bytecode.\n * @return the class defined by the specified name and path.\n * @throws IOException if an error occurs.\n */\n private Class loadClass(String name, AbstractFile file) throws IOException {\n byte[] buffer = new byte[(int)file.getSize()]; // Buffer for the class' bytecode.\n int offset = 0; // Current offset in buffer.\n\n try (InputStream in = file.getInputStream()) {\n // Loads the content of file in buffer.\n while (offset != buffer.length) {\n offset += in.read(buffer, offset, buffer.length - offset);\n }\n // Loads the class.\n return defineClass(name, buffer, 0, buffer.length);\n }\n }\n\n /**\n * Tries to find and load the specified class.\n * @param name fully qualified name of the class to load.\n * @return the requested Class if found, null otherwise.\n * @throws ClassNotFoundException if the requested class was not found.\n */\n @Override\n protected Class findClass(String name) throws ClassNotFoundException {\n AbstractFile file = findResourceAsFile(name.replace('.', '/') + \".class\"); // File containing the class' bytecode.\n\n // Tries to locate the specified class and, if found, load it.\n if (file != null) {\n try {\n return loadClass(name, file);\n } catch(IOException e) {\n if (LOGGER != null) {\n LOGGER.info(\"\", e);\n }\n }\n }\n throw new ClassNotFoundException(name);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/AbstractROArchiveFile.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see AbstractROArchiveFile represents a read-only archive file. This class is abstract and implemented\n * by read-only archive files.\n *\n * AbstractROArchiveFile implementations only have to provide two methods:\n * \n *
\n * The {@link #isWritable()} method is implemented to always returns false.\n *\n * @author Maxence Bernard\n */\npublic abstract class AbstractROArchiveFile extends AbstractArchiveFile {\n\n /**\n * Creates an AbstractROArchiveFile on top of the given file.\n *\n * @param file the file on top of which to create the archive\n */\n protected AbstractROArchiveFile(AbstractFile file) {\n super(file);\n }\n\n\n /**\n * Returns false: AbstractROArchiveFile implementations are not capable of adding or\n * deleting entries.\n *\n * @return false\n */\n @Override\n public final boolean isWritable() {\n return false;\n }\n\n\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/AbstractRWArchiveFile.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see AbstractRWArchiveFile represents a read-write archive file. This class is abstract and implemented by\n * all read-write archive files.\n * In addition to the read-only operations defined by {@link com.mucommander.commons.file.AbstractArchiveFile}, it provides\n * abstract methods for adding and deleting entries from the archive.\n *\n * The {@link #isWritable()} method implemented by this class always returns true. However,\n * write operations may not always be available depending on the underlying file (e.g. if random file access is\n * required). In that case, {@link #isWritable ()} should be overridden to return true only when\n * write operations are available.\n *\n * @author Maxence Bernard\n */\npublic abstract class AbstractRWArchiveFile extends AbstractArchiveFile {\n\n /**\n * Creates an AbstractRWArchiveFile on top of the given file.\n *\n * @param file the file on top of which to create the archive\n */\n protected AbstractRWArchiveFile(AbstractFile file) {\n super(file);\n }\n\n\n\n /**\n * Returns true: AbstractRWArchiveFile implementations are by definition capable of adding\n * or deleting entries. This method should be overridden if the implementation is capable of providing write access\n * only under certain conditions, for example if it requires random access to the proxied archive file which may not\n * always be available depending on the underlying file. If that is the case, this method should return\n * true only when all conditions for providing write operations are met.\n *\n * @return true, always\n */\n @Override\n public boolean isWritable() {\n return true;\n }\n\n\n /**\n * Adds the given entry to the archive and returns an OutputStream to write the entry's contents\n * if the entry is a regular file, null if the entry is a directory.\n * Throws an IOException if the entry already exists in the archive or if an I/O error occurs.\n *\n * @param entry the entry to add to the archive\n * @return an OutputStream to write the entry's contents if the entry is a regular file, null if the entry is a directory\n * @throws IOException if the entry already exists in the archive or if an I/O error occurs\n * @throws UnsupportedFileOperationException if {@link FileOperation#WRITE_FILE} operations are not supported by\n * the underlying file protocol.\n */\n public abstract OutputStream addEntry(ArchiveEntry entry) throws IOException, UnsupportedFileOperationException;\n\n /**\n * Deletes the specified entry from the archive. Throws an IOException if the entry doesn't exist\n * in the archive or if an I/O error occurs.\n *\n * @param entry the entry to delete from the archive\n * @throws IOException if the entry doesn't exist in the archive or if an I/O error occurs\n * @throws UnsupportedFileOperationException if {@link FileOperation#WRITE_FILE} operations are not supported by\n * the underlying file protocol.\n */\n public abstract void deleteEntry(ArchiveEntry entry) throws IOException, UnsupportedFileOperationException;\n\n /**\n * Updates the specified entry in the archive with the attributes contained in the {@link ArchiveEntry} object.\n * Throws an IOException if the entry doesn't exist in the archive or if an I/O error occurs.\n *\n * true if the entry exists in the archive\n */\n public ArchiveEntry(String path, boolean directory, long date, long size, boolean exists) {\n setPath(path);\n setDate(date);\n setSize(size);\n setDirectory(directory);\n setExists(exists);\n }\n\n\n /**\n * Returns the depth of this entry based on the number of path delimiters ({@link #SEPARATOR_CHAR}) its path\n * contains. Top-level entries have a depth of 1.\n *\n * @return the depth of this entry\n */\n public int getDepth() {\n return getDepth(getPath());\n }\n\n /**\n * Returns the depth of the specified entry path, based on the number of path delimiters ({@link #SEPARATOR_CHAR})\n * it contains. Top-level entries have a depth of 1.\n *\n * @param entryPath the path for which to calculate the depth\n * @return the depth of the given entry path\n */\n static int getDepth(String entryPath) {\n return PathUtils.getDepth(entryPath, SEPARATOR_STRING);\n }\n\n /**\n * Extracts this entry's filename from its path and returns it.\n *\n * @return this entry's filename\n */\n public String getName() {\n String path = getPath();\n int len = path.length();\n // Remove trailing '/' if any\n if (path.charAt(len-1) == SEPARATOR_CHAR) {\n path = path.substring(0, --len);\n }\n\n int lastSlash = path.lastIndexOf(SEPARATOR_CHAR);\n return lastSlash == -1 ? path : path.substring(lastSlash+1, len);\n }\n\n /**\n * Returns an archive format-dependent object providing extra information about this entry, typically an object from\n * a 3rd party library ; null if this entry has none.\n *\n * @return an object providing extra information about this entry, null if this entry has none\n */\n public Object getEntryObject() {\n return entryObject;\n }\n\n /**\n * Sets an archive format-dependent object providing extra information about this entry, typically an object from\n * a 3rd party library ; null for none.\n *\n * @param entryObject an object providing extra information about this entry, null for none\n */\n public void setEntryObject(Object entryObject) {\n this.entryObject = entryObject;\n }\n\n\n /**\n * Returns the file permissions of this entry. This method is overridden to return default permissions\n * ({@link FilePermissions#DEFAULT_DIRECTORY_PERMISSIONS} for directories, {@link FilePermissions#DEFAULT_FILE_PERMISSIONS}\n * for regular files), when none have been set.\n *\n * @return the file permissions of this entry\n */\n @Override\n public FilePermissions getPermissions() {\n FilePermissions permissions = super.getPermissions();\n if (permissions == null) {\n return isDirectory() ? FilePermissions.DEFAULT_DIRECTORY_PERMISSIONS : FilePermissions.DEFAULT_FILE_PERMISSIONS;\n }\n\n return permissions;\n }\n\n /**\n * Overridden to invalidates any previously computed hash code.\n *\n * @param path new path to set\n */\n @Override\n public void setPath(String path) {\n super.setPath(path);\n // Invalidate any previously\n hashCode = 0;\n }\n\n /**\n * Returns true if the given object is an ArchiveEntry whose path is equal to this one,\n * according to {@link PathUtils#pathEquals(String, String, String)} (trailing slash-insensitive comparison).\n *\n * @param o the object to test\n * @return true if the given object is an ArchiveEntry whose path is equal to this one\n * @see PathUtils#pathEquals(String, String, String)\n */\n public boolean equals(Object o) {\n return o instanceof ArchiveEntry && PathUtils.pathEquals(getPath(), ((ArchiveEntry) o).getPath(), SEPARATOR_STRING);\n\n }\n\n /**\n * This method is overridden to return a hash code that is consistent with {@link #equals(Object)},\n * so that url1.equals(url2) implies url1.hashCode()==url2.hashCode().\n */\n public int hashCode() {\n if (hashCode != 0) { // Return any previously computed hashCode. Note that setPath invalidates the hashCode.\n return hashCode;\n }\n\n String path = getPath();\n\n // #equals(Object) is trailing separator insensitive, so the hashCode must be trailing separator invariant\n hashCode = path.endsWith(SEPARATOR_STRING) ? path.substring(0, path.length()-1).hashCode() : path.hashCode();\n\n return hashCode;\n }\n\n @Override\n public String toString() {\n return \" ArchiveEntry(\" + entryObject + \")\";\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/ArchiveEntryIterator.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see Iterator, with\n * several differences:\n *\n * \n *
\n *\n * @see com.mucommander.commons.file.SingleArchiveEntryIterator\n * @see com.mucommander.commons.file.WrapperArchiveEntryIterator\n * @author Maxence Bernard\n */\npublic interface ArchiveEntryIterator {\n\n /**\n * Returns the next entry in this iterator, IOExceptionhasNext method, because it wouldn't map very well onto certain formats that don't know\n * if there is a next entry until the current entry has been consumed.null if this iterator has no more entries.\n *\n * @return true if this iterator has a next entry\n * @throws IOException if an error occurred while reading the archive, either because the archive is corrupt or\n * because of an I/O error\n */\n ArchiveEntry nextEntry() throws IOException;\n\n /**\n * Closes this iterator and releases all the resources it holds. This method must be called when this iterator\n * is not needed anymore.\n *\n * @throws IOException if an error occurred while closing the resources\n */\n void close() throws IOException;\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/ArchiveEntryTree.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see ArchiveEntryTree also acts as the root node: all entry nodes\n * are children of it (direct or indirect).\n *\n * @author Maxence Bernard\n */\nclass ArchiveEntryTree extends DefaultMutableTreeNode {\n private static Logger logger;\n\n /**\n * Creates a new empty tree.\n */\n ArchiveEntryTree() {\n }\n\n /**\n * Adds the given entry to the archive tree, creating parent nodes as necessary.\n *\n * @param entry the entry to add to the tree\n */\n void addArchiveEntry(ArchiveEntry entry) {\n String entryPath = entry.getPath();\n int entryDepth = entry.getDepth();\n int slashPos = 0;\n DefaultMutableTreeNode node = this;\n for (int d = 1; d <= entryDepth; d++) {\n if (d == entryDepth && !entry.isDirectory()) {\n // create a leaf node for the entry\n entry.setExists(true); // the entry has to exist\n node.add(new DefaultMutableTreeNode(entry, true));\n break;\n }\n\n String subPath = d==entryDepth?entryPath:entryPath.substring(0, (slashPos=entryPath.indexOf('/', slashPos)+1));\n\n int nbChildren = node.getChildCount();\n DefaultMutableTreeNode childNode = null;\n boolean matchFound = false;\n for (int c = 0; c < nbChildren; c++) {\n childNode = (DefaultMutableTreeNode)node.getChildAt(c);\n // Path comparison is 'trailing slash insensitive'\n if (PathUtils.pathEquals(((ArchiveEntry)childNode.getUserObject()).getPath(), subPath, \"/\")) {\n // Found a match\n matchFound = true;\n break;\n }\n }\n\n if (matchFound) {\n if (d == entryDepth) {\n getLogger().trace(\"Replacing entry for node {}\", childNode);\n childNode.setUserObject(entry); // Replace existing entry\n } else {\n node = childNode;\n }\n } else {\n if (d == entryDepth) {\n // create a leaf node for the entry\n entry.setExists(true); // the entry has to exist\n node.add(new DefaultMutableTreeNode(entry, true));\n } else {\n getLogger().trace(\"Creating node for {}\", subPath);\n childNode = new DefaultMutableTreeNode(new ArchiveEntry(subPath, true, entry.getLastModifiedDate(), 0, true), true);\n node.add(childNode);\n node = childNode;\n }\n }\n }\n }\n\n\n /**\n * Finds and returns the node that corresponds to the specified entry path, null if no entry matching\n * the path could be found.\n *\n * AbstractArchiveFile .\n *\n * @param file file to map as an AbstractArchiveFile.\n * @return a new instance of AbstractArchiveFile that matches the specified URL.\n * @throws IOException if an error occurs.\n */\n AbstractArchiveFile getFile(AbstractFile file) throws IOException;\n\n\n /**\n * Returns the FilenameFilter that matches filenames to be associated with this archive format.\n *\n * @return the FilenameFilter that matches filenames to be associated with this archive format\n */\n FilenameFilter getFilenameFilter();\n\n String[] getFileExtensions();\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/AuthException.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see IOException that is thrown whenever an operation failed due to the lack of,\n * invalid or insufficient credentials. A URL associated with the exception gives the location where the error\n * occurred, and the set of credentials that were used (if any).\n *\n * @author Maxence Bernard\n */\npublic class AuthException extends IOException {\n\n protected FileURL fileURL;\n protected String msg;\n\n /**\n * Creates a new AuthException instance, without any associated exception.\n *\n * @param fileURL the location where the error occurred, with the set of credentials that were used (if any).\n */\n public AuthException(FileURL fileURL) {\n this(fileURL, null);\n }\n\t\n /**\n * Creates a new AuthException instance that was caused by the given exception.\n *\n * @param fileURL the location where the error occurred, with the set of credentials that were used (if any)\n * @param msg a message describing the error, null if there is none\n */\n public AuthException(FileURL fileURL, String msg) {\n super(msg);\n\n this.fileURL = fileURL;\n if (msg != null) {\n this.msg = msg.trim();\n }\n }\n\t\n\n /**\n * Returns the location where the error occurred, with the set of credentials that were used (if any).\n *\n * @return the location where the error occurred, with the set of credentials that were used (if any)\n */\n public FileURL getURL() {\n return fileURL;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/AuthenticationType.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see null.\n *\n * @return the login part.\n */\n public String getLogin() {\n return login;\n }\n\t\n /**\n * Returns the password part. The returned password may be an empty string but never null.\n *\n * @return the password part.\n */\n public String getPassword() {\n return password;\n }\n\n /**\n * Returns the password as a masked string, each of the characters replaced by '*' characters.\n *\n * @return the password as a masked string.\n */\n public String getMaskedPassword() {\n int passwordLength = password.length();\n return \"*\".repeat(passwordLength);\n }\n\n /**\n * Returns true if these credentials are empty.\n * true if these credentials are empty, false otherwise.\n */\n public boolean isEmpty() {\n return \"\".equals(login) && \"\".equals(password);\n }\n\n\n /**\n * This method is equivalent to calling {@link #equals(Object, boolean)} with false:\n * two Credentials instances with the same login but a different password are considered equal.\n *\n * @param o the Object to test for equality\n * @return true if this and the specified instance are equal\n * @see #equals(Object, boolean)\n */\n @Override\n public boolean equals(Object o) {\n return equals(o, false);\n }\n\n /**\n * Returns true if these Credentials and the specified instance are equal. For credentials to be equal,\n * their login (as returned by {@link #getLogin()} must be equal. If the password-sensitive parameter is enabled,\n * their passwords (as returned by {@link #getPassword()} must also match.\n *\n * null are considered equal: if a null instance is specified,\n * true is returned if these Credentials are {@link #isEmpty() empty}).\n *\n * @param o the Object to test for equality\n * @param passwordSensitive true if passwords need to be equal for credentials instances to match\n * @return true if this and the specified instance are equal\n */\n public boolean equals(Object o, boolean passwordSensitive) {\n // Empty Credentials and null are equivalent\n if (o == null) {\n return isEmpty();\n }\n if (!(o instanceof Credentials)) { // Note: this class is declared final so we don't need to worry about subclasses\n return false;\n }\n\n Credentials credentials = (Credentials)o;\n return credentials.login.equals(this.login) && (!passwordSensitive || credentials.password.equals(this.password));\n }\n\n /**\n * Returns a cloned instance of these Credentials.\n *\n * @return a cloned instance of these Credentials\n */\n @Override\n public Object clone() {\n try {\n return super.clone();\n } catch (CloneNotSupportedException e) {\n // Should never happen\n return null;\n }\n }\n\n public String toString() {\n return login;\n }\n\n public int hashCode() {\n // Do not take into account the password, as #equals(Object) is password-insensitive\n return login.hashCode();\n }\n}\n\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/DefaultPathCanonizer.java",
"content": "package com.mucommander.commons.file;\n\nimport java.util.Vector;\n\n/**\n * @author Maxence Bernard\n */\npublic class DefaultPathCanonizer implements PathCanonizer {\n\n /** Path separator */\n private final String separator;\n\n /** The string replacement for '~' path fragments, null for no tilde replacement */\n private final String tildeReplacement;\n\n\n /**\n * Creates a new path canonizer using the specified path separator and no tilde replacement.\n *\n * @param separator the path separator that delimits path fragments\n */\n public DefaultPathCanonizer(String separator) {\n this(separator, null);\n }\n\n /**\n * Creates a new path canonizer using the specified path separator and tilde replacement string\n * (if not null).\n *\n * @param separator the path separator that delimits path fragments\n * @param tildeReplacement if not null, path fragments equal to '~' will be replaced by this string.\n */\n public DefaultPathCanonizer(String separator, String tildeReplacement) {\n this.separator = separator;\n this.tildeReplacement = tildeReplacement;\n }\n\n\n /**\n * Returns a canonical value of the given path, where '.' and '..' path fragments are factored out,\n * and '~' fragments replaced by the string specified in the constructor (if not null).\n *\n * @param path the path to canonize\n * @return the canonized path\n */\n @Override\n public String canonize(String path) {\n // Todo: use PathTokenizer?\n\n if (!path.equals(\"/\")) {\n int pos;\t // position of current path separator\n int pos2 = 0;\t// position of next path separator\n int separatorLen = separator.length();\n String dir;\t\t// Current directory\n String dirWS;\t// Current directory without trailing separator\n Vector
\n * The multi-arg constructor allows to create a scheme handler with specific values.\n * \"/\". This behavior can be modified by overriding getRealm.\n *\n * @see com.mucommander.commons.file.FileURL#getDefaultHandler()\n * @see com.mucommander.commons.file.SchemeHandler\n * @author Maxence Bernard\n */\npublic class DefaultSchemeHandler implements SchemeHandler {\n\n protected SchemeParser parser;\n protected int standardPort;\n protected String pathSeparator;\n protected AuthenticationType authenticationType;\n protected Credentials guestCredentials;\n\n /**\n * Creates a DefaultSchemeHandler with default values that suit schemes in which the scheme name is not included\n\t * in the URL (local and unc locations):\n * \n *
\n */\n public DefaultSchemeHandler() {\n this(new DefaultSchemeParser(), -1, System.getProperty(\"file.separator\"), AuthenticationType.NO_AUTHENTICATION, null);\n }\n\n /**\n * Creates a DefaultSchemeHandler with the specified values.\n *\n * @param parser the parser that takes care of parsing URL strings and turning them into FileURL\n * @param standardPort the scheme's standard port, -1null-1 for none\n * @param pathSeparator the scheme's path separator, cannot be null\n * @param authenticationType the type of authentication used by the scheme's file protocol\n * @param guestCredentials the scheme's guest credentials, null for none\n */\n public DefaultSchemeHandler(SchemeParser parser, int standardPort, String pathSeparator, AuthenticationType authenticationType, Credentials guestCredentials) {\n this.parser = parser;\n this.standardPort = standardPort;\n this.pathSeparator = pathSeparator;\n this.authenticationType = authenticationType;\n this.guestCredentials = guestCredentials;\n }\n\n\n //////////////////////////////////\n // SchemeHandler implementation //\n //////////////////////////////////\n\n /**\n * Returns the parser that was passed to the constructor.\n *\n * @return the parser that was passed to the constructor\n */\n public SchemeParser getParser() {\n return parser;\n }\n\n /**\n * Returns the authentication type that was passed to the constructor.\n *\n * @return the authentication type that was passed to the constructor\n */\n public AuthenticationType getAuthenticationType() {\n return authenticationType;\n }\n\n /**\n * Returns the set of guest credentials that was passed to the constructor.\n *\n * @return the set of guest credentials that was passed to the constructor\n */\n public Credentials getGuestCredentials() {\n return guestCredentials;\n }\n\n /**\n * Returns the path separator that was passed to the constructor.\n *\n * @return the path separator that was passed to the constructor\n */\n public String getPathSeparator() {\n return pathSeparator;\n }\n\n /**\n * Returns the standard port that was passed to the constructor.\n *\n * @return the standard port that was passed to the constructor\n */\n public int getStandardPort() {\n return standardPort;\n }\n\n /**\n * Returns a URL with the same scheme, host and port (if any) as the specified URL, and a path set to \n\t * \"/\" or \"\\\" depending on the URL format.\n * The login, password, query and fragment parts of the returned URL are always null.\n * For example, when called with {@code http://www.mucommander.com:8080/path/to/file?query¶m=value},\n * this method returns http://www.mucommander.com:8080/.\n * \n * @param location the location for which to return the authentication realm\n * @return the authentication realm of the specified location\n */\n public FileURL getRealm(FileURL location) {\n // Start by cloning the given URL and then modify the parts that need it\n FileURL realm = (FileURL)location.clone();\n\n realm.setPath(location.getPathSeparator());\n realm.setCredentials(null);\n realm.setQuery(null);\n // Todo\n // realm.setFragment(null)\n\n return realm;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/DefaultSchemeParser.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see Local paths
\n * \n *
\n *\n * C:\\Windows\\System32\\ will be parsed and turned into a FileURL whose path\n * separator is \"\\\" and representation file://localhost/C:\\Windows\\System32\\C:\\Windows\\System32\\ will be parsed and turned\n * into a FileURL whose path separator is \"\\\" and representation file://localhost/C:\\Windows\\System32\\UNC paths
\n * \\\\Server\\Volume\\File are supported on all OSes but the FileURL\n * resulting from the parsing varies will not be the same whether they are created on a Windows environment or\n * on another:\n * \n *
\n *\n * @see PathCanonizer\n * @author Maxence Bernard\n */\n@Slf4j\npublic class DefaultSchemeParser implements SchemeParser {\n /** True if query should be parsed and not considered as part of the path */\n private final boolean parseQuery;\n\n /** \\\\Server\\Volume\\File will be turned into a FileURL whose string\n * representation is file://Server/\\Volume\\File\\\\Server\\Volume\\File will be turned into a FileURL whose string\n * representation is smb://Server/Volume/FilePathCanonizer instance to be used for canonizing the path part */\n private final PathCanonizer pathCanonizer;\n\n\n /**\n * Creates a DefaultSchemeParser with a {@link DefaultPathCanonizer} that uses the operating system's default \n * path separator as the path separator and no tilde replacement, and query parsing disabled.\n */\n DefaultSchemeParser() {\n this(false);\n }\n\n /**\n * Creates a DefaultSchemeParser with a {@link DefaultPathCanonizer} that uses the operating system's\n\t * default path separator as the path separator and no tilde replacement.\n * If parseQuery is true, any query part (delimited by '?') will be parsed as such,\n * or considered as part of the path otherwise.\n *\n * @param parseQuery true, any query part (delimited by '?') will be parsed as such, or considered\n * as part of the path otherwise\n */\n DefaultSchemeParser(boolean parseQuery) {\n this(new DefaultPathCanonizer(FileSystems.getDefault().getSeparator(), null), parseQuery);\n }\n\n /**\n * Creates a DefaultSchemeParser using the specified {@link PathCanonizer} for canonizing the path part.\n * If parseQuery is true, any query part (delimited by '?') will be parsed as such,\n * or considered as part of the path otherwise.\n *\n * @param pathCanonizer PathCanonizer instance to be used for canonizing the path part\n * @param parseQuery true, any query part (delimited by '?') will be parsed as such, or considered\n * as part of the path otherwise\n */\n DefaultSchemeParser(PathCanonizer pathCanonizer, boolean parseQuery) {\n this.parseQuery = parseQuery;\n this.pathCanonizer = pathCanonizer;\n }\n\n /**\n * Handles the parsing of the given local file URL.\n *\n * @param url the URL to parse\n * @param fileURL the FileURL instance in which to set the different parsed parts\n */\n private void handleLocalFilePath(String url, FileURL fileURL) {\n SchemeHandler handler = FileURL.getRegisteredHandler(FileProtocols.FILE);\n SchemeParser parser = handler.getParser();\n\n fileURL.setHandler(handler);\n fileURL.setScheme(FileProtocols.FILE);\n fileURL.setHost(FileURL.LOCALHOST);\n fileURL.setPath((parser instanceof DefaultSchemeParser?((DefaultSchemeParser)parser).getPathCanonizer():pathCanonizer).canonize(url));\n }\n\n /**\n * Returns the {@link PathCanonizer} instance that is used by this {@link DefaultSchemeParser}.\n *\n * @return the {@link PathCanonizer} instance that is used by this {@link DefaultSchemeParser}\n */\n private PathCanonizer getPathCanonizer() {\n return pathCanonizer;\n }\n\n\n @Override\n public void parse(String url, FileURL fileURL) throws MalformedURLException {\n // The general form of a URI is:\n\n // foo://example.com:8042/over/there?name=ferret#nose\n // \\_/ \\______________/\\_________/ \\_________/ \\__/\n // | | | | |\n // scheme authority path query fragment\n // | _____________________|__\n // / \\ / \\\n // urn:example:animal:ferret:nose\n\n\n // See http://labs.apache.org/webarch/uri/rfc/rfc3986.html for full specs\n\n try {\n int pos;\n int schemeDelimPos = url.indexOf(\"://\");\n int urlLen = url.length();\n\n // If the given url contains no scheme, consider that it is a local path and transform it into a file:// URL\n if (schemeDelimPos == -1) {\n // Treat the URL as local file path if it starts with:\n // - '/' and OS doesn't use root drives (Unix-style path)\n // - a drive letter and OS uses root drives (Windows-style) [support both C:\\ and C:/ style]\n // - a ~ character (refers to the user home folder)\n if ((!LocalFile.USES_ROOT_DRIVES && url.startsWith(\"/\")) || url.startsWith(\"~/\") || url.equals(\"~\")) {\n handleLocalFilePath(url, fileURL);\n\n // All done, return\n return;\n } else if (LocalFile.USES_ROOT_DRIVES && (url.indexOf(\":\\\\\") == 1 || url.indexOf(\":/\") == 1)) {\n // Turn forward slash-separated paths into their backslash-separated counterparts.\n if (url.charAt(2) == '/') {\n url = url.replace('/', '\\\\');\n }\n\n handleLocalFilePath(url, fileURL);\n\n // All done, return\n return;\n }\n\n // Handle Windows-style UNC network paths ( \\\\hostname\\path ):\n // - under Windows, transform it into a URL in the file://hostname/path form,\n // LocalProtocolProvider will translate it back into a UNC network path\n // - under other OS, conveniently transform it into smb://hostname/path to be nice with folks\n // who've spent too much time using Windows\n else if (url.startsWith(\"\\\\\\\\\") && urlLen > 2) {\n if (OsFamily.WINDOWS.isCurrent()) {\n pos = url.indexOf('\\\\', 2);\n url = FileProtocols.FILE+\"://\"+ \n \t\t\t\t(pos==-1?url.substring(2):url.substring(2, pos)+\"/\"+(pos==urlLen-1?\"\":url.substring(pos+1)));\n\n // Update scheme delimiter position\n schemeDelimPos = FileProtocols.FILE.length();\n }\n else {\n url = FileProtocols.SMB+\"://\"+url.substring(2).replace('\\\\', '/');\n\n // Update scheme delimiter position\n schemeDelimPos = FileProtocols.SMB.length();\n }\n\n // Update URL's length\n urlLen = url.length();\n } else { // This doesn't look like a valid path, throw an MalformedURLException\n throw new MalformedURLException(\"Path not absolute or malformed: \"+url);\n }\n }\n\n // Start URL parsing\n\n String scheme = url.substring(0, schemeDelimPos);\n fileURL.setScheme(scheme);\n // Advance string index\n pos = schemeDelimPos+3;\n\n int separatorPos = url.indexOf('/', pos);\n\n // The question mark character (if any) marks the beginning of the query part, only if it should be parsed.\n int questionMarkPos = parseQuery?url.indexOf('?', pos):-1;\n int hostEndPos; // Contains the position of the beginning of the path/query part\n if (separatorPos != -1) { // Separator is necessarily before question mark\n hostEndPos = separatorPos;\n } else if (questionMarkPos != -1) {\n hostEndPos = questionMarkPos;\n } else {\n hostEndPos = urlLen;\n }\n\n // The authority part is the one between scheme:// and the path/query. It includes the user information\n // (login/password), host and port. \n String authority = url.substring(pos, hostEndPos);\n pos = 0;\n\n // Parse login and password (if specified).\n // They may contain non-URL safe characters that are decoded here, and re-encoded by FileURL#toString.\n int atPos = authority.lastIndexOf('@');\n int colonPos;\n // Filenames may contain @ chars, so atPos must be lower than next separator's position (if any)\n if (atPos != -1 && (separatorPos == -1 || atPos < separatorPos)) {\n colonPos = authority.indexOf(':');\n String login = URLDecoder.decode(authority.substring(0, colonPos == -1 ? atPos : colonPos), StandardCharsets.UTF_8);\n String password;\n if (colonPos != -1) {\n password = URLDecoder.decode(authority.substring(colonPos+1, atPos), StandardCharsets.UTF_8);\n } else {\n password = null;\n }\n if (!login.isEmpty() || !(password == null || password.isEmpty())) {\n fileURL.setCredentials(new Credentials(login, password));\n }\n\n // Advance string index\n pos = atPos+1;\n }\n\n // Parse host and port (if specified)\n colonPos = authority.indexOf(':', pos);\n\n String host;\n if (colonPos != -1) {\n host = authority.substring(pos, colonPos);\n String portString = authority.substring(colonPos+1);\n if (!portString.isEmpty()) { // Tolerate an empty port part (e.g. http://mucommander.com:/)\n try {\n fileURL.setPort(Integer.parseInt(portString));\n } catch(NumberFormatException e) {\n throw new MalformedURLException(\"URL contains an invalid port\");\n }\n }\n } else {\n host = authority.substring(pos);\n }\n\n if (host.isEmpty()) {\n host = null;\n }\n\n fileURL.setHost(host);\n\n // Parse path part excluding query part\n pos = hostEndPos;\n String path = url.substring(pos, questionMarkPos==-1?urlLen:questionMarkPos);\n\n // Empty path means '/'\n if (path.isEmpty()) {\n path = \"/\";\n }\n\n // Canonize path: factor out '.' and '..' and replace '~' by the replacement string (if any)\n fileURL.setPath(pathCanonizer.canonize(path));\n\n// log.debug(\"Warning: path should not be empty, url={}\", url);\n\n // Parse query part (if any)\n if (questionMarkPos != -1) {\n fileURL.setQuery(url.substring(questionMarkPos+1)); // Do not include the question mark\n }\n } catch (MalformedURLException e) {\n throw e;\n } catch (Exception e2) {\n log.info(\"Unexpected exception in FileURL() with {}\", url, e2);\n throw new MalformedURLException();\n }\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/DummyFile.java",
"content": "package com.mucommander.commons.file;\n\nimport com.mucommander.commons.io.RandomAccessInputStream;\nimport com.mucommander.commons.io.RandomAccessOutputStream;\n\nimport java.io.IOException;\nimport java.io.InputStream;\nimport java.io.OutputStream;\n\n/**\n * This class is an implementation of AbstractFile which implements all methods as no-op (that do nothing)\n * that return default values. It makes it easy to quickly create a AbstractFile implementation by simply\n * overriding the methods that are needed, for example as an anonymous class inside a method.\n *\n * 0.\n */\n @Override\n public long getLastModifiedDate() {\n return 0;\n }\n\n /**\n * Implementation notes: always throws {@link UnsupportedFileOperationException}.\n *\n * @throws UnsupportedFileOperationException always.\n */\n @Override\n @UnsupportedFileOperation\n public void setLastModifiedDate(long lastModified) throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.CHANGE_DATE);\n }\n\n /**\n * Implementation notes: always returns -1.\n */\n @Override\n public long getSize() {\n return -1;\n }\n\n /**\n * Implementation notes: always returns null.\n */\n @Override\n public AbstractFile getParent() {\n return null;\n }\n\n /**\n * Implementation notes: no-op, does nothing with the specified parent.\n */\n @Override\n public void setParent(AbstractFile parent) {\n }\n\n /**\n * Implementation notes: always returns false.\n */\n @Override\n public boolean exists() {\n return false;\n }\n\n /**\n * Implementation notes: always returns {@link FilePermissions#EMPTY_FILE_PERMISSIONS}.\n */\n @Override\n public FilePermissions getPermissions() {\n return FilePermissions.EMPTY_FILE_PERMISSIONS;\n }\n\n /**\n * Implementation notes: returns {@link PermissionBits#EMPTY_PERMISSION_BITS}, none of the permission bits can be\n * changed.\n */\n @Override\n public PermissionBits getChangeablePermissions() {\n return PermissionBits.EMPTY_PERMISSION_BITS;\n }\n\n /**\n * Implementation notes: always returns false.\n */\n @Override\n @UnsupportedFileOperation\n public void changePermission(int access, int permission, boolean enabled) throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.CHANGE_PERMISSION);\n }\n\n /**\n * Implementation notes: always returns null.\n */\n @Override\n public String getOwner() {\n return null;\n }\n\n /**\n * Implementation notes: always returns false.\n */\n @Override\n public boolean canGetOwner() {\n return false;\n }\n\n /**\n * Implementation notes: always returns null.\n */\n @Override\n public String getGroup() {\n return null;\n }\n\n /**\n * Implementation notes: always returns false.\n */\n @Override\n public boolean canGetGroup() {\n return false;\n }\n\n /**\n * Implementation notes: always returns false.\n */\n @Override\n public boolean isDirectory() {\n return false;\n }\n\n /**\n * Implementation notes: always returns false.\n */\n @Override\n public boolean isArchive() {\n return false;\n }\n\n /**\n * Implementation notes: always returns false.\n */\n @Override\n public boolean isSymlink() {\n return false;\n }\n\n /**\n * Implementation notes: always returns false.\n */\n @Override\n public boolean isSystem() {\n return false;\n }\n\n /**\n * Implementation notes: always throws an {@link UnsupportedFileOperationException}.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public AbstractFile[] ls() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.LIST_CHILDREN);\n }\n\n /**\n * Implementation notes: always throws an {@link UnsupportedFileOperationException}.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public void mkdir() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.CREATE_DIRECTORY);\n }\n\n /**\n * Implementation notes: always throws an {@link UnsupportedFileOperationException}.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public InputStream getInputStream() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.READ_FILE);\n }\n\n /**\n * Implementation notes: always throws an {@link UnsupportedFileOperationException}.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public OutputStream getOutputStream() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.WRITE_FILE);\n }\n\n /**\n * Implementation notes: always throws an {@link UnsupportedFileOperationException}.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public OutputStream getAppendOutputStream() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.APPEND_FILE);\n }\n\n /**\n * Implementation notes: always throws an {@link UnsupportedFileOperationException}.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public RandomAccessInputStream getRandomAccessInputStream() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.RANDOM_READ_FILE);\n }\n\n /**\n * Implementation notes: always throws an {@link UnsupportedFileOperationException}.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public RandomAccessOutputStream getRandomAccessOutputStream() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.RANDOM_WRITE_FILE);\n }\n\n /**\n * Implementation notes: always throws an {@link UnsupportedFileOperationException}.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public void delete() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.DELETE);\n }\n\n /**\n * Implementation notes: always throws an {@link UnsupportedFileOperationException}.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public void copyRemotelyTo(AbstractFile destFile) throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.COPY_REMOTELY);\n }\n\n /**\n * Implementation notes: always throws an {@link UnsupportedFileOperationException}.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public void renameTo(AbstractFile destFile) throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.RENAME);\n }\n\n /**\n * Implementation notes: always throws {@link UnsupportedFileOperationException}.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public long getFreeSpace() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.GET_FREE_SPACE);\n }\n\n /**\n * Implementation notes: always throws {@link UnsupportedFileOperationException}.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public long getTotalSpace() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.GET_TOTAL_SPACE);\n }\n\n /**\n * Implementation notes: always returns null.\n */\n @Override\n public Object getUnderlyingFileObject() {\n return null;\n }\n\n @Override\n @UnsupportedFileOperation\n public short getReplication() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.GET_REPLICATION);\n }\n\n @Override\n @UnsupportedFileOperation\n public long getBlocksize() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.GET_BLOCKSIZE);\n }\n\n @Override\n @UnsupportedFileOperation\n public void changeReplication(short replication) throws IOException {\n throw new UnsupportedFileOperationException(FileOperation.CHANGE_REPLICATION);\n }\n\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/FileAccessDeniedException.java",
"content": "/*\n * This file is part of trolCommander, http://www.trolsoft.ru/en/soft/trolcommander\n * Copyright (C) 2013-2016 Oleg Trifonov\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see \n *
\n *\n * null by default. The type of path (relative or absolute) separator character\n * are unspecified and context-dependant.false by default0 (00:00:00 GMT, January 1, 1970) by default0 by defaultfalse by defaultnull if\n * undefinednull by defaultnull by defaultnull by default.\n *\n * null by default\n */\n String getPath();\n\n /**\n * Returns true if the file exists physically on the underlying filesystem, false\n * by default.\n *\n * @return true if the file exists physically on the underlying filesystem, false by default\n */\n boolean exists();\n\n /**\n * Returns the file's date in milliseconds since the epoch (00:00:00 GMT, January 1, 1970), 0 by default\n *\n * @return the file's date in milliseconds since the epoch (00:00:00 GMT, January 1, 1970), 0 by default\n */\n long getLastModifiedDate();\n\n /**\n * Returns the file's size in bytes.\n *\n * @return the file's size in bytes\n */\n long getSize();\n\n /**\n * Returns true if the file is a directory, false if it is a regular file\n * (defaults to false).\n *\n * @return true if the file is a directory, false if it is a regular file or undefined\n */\n boolean isDirectory();\n\n /**\n * Returns the file's permissions, null by default.\n *\n * @return the file's permissions, null by default\n */\n FilePermissions getPermissions();\n\n /**\n * Returns the file's owner, null by default.\n *\n * @return the file's owner, null by default\n */\n String getOwner();\n\n /**\n * Returns the file's group, null by default.\n *\n * @return the file's group, null by default\n */\n String getGroup();\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/FileFactory.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see Protocols
\n * com.mucommander.commons.file API to access new file protocols, developers must create\n * an implementation of {@link AbstractFile} that handles that protocol and register it to FileFactory.\n * This registration requires an implementation of {@link ProtocolProvider}, an instance of which will be passed to\n * {@link #registerProtocol(String,ProtocolProvider) registerProtocol}.\n *\n * \n *
\n *\n * Archive formats
\n * com.mucommander.commons.file API to access new archive formats, developers must create\n * an implementation of {@link AbstractArchiveFile} that handles that format and register it to FileFactory.\n * This registration requires an implementation of {@link ArchiveFormatProvider}, an instance of which will be passed to\n * {@link #registerArchiveFormat(ArchiveFormatProvider)}.\n *\n * \n *
\n *\n * @author Maxence Bernard, Nicolas Rinaudo\n */\npublic class FileFactory {\n private static Logger logger;\n\n /** All registered protocol providers. */\n private static final MapZIP, registered to zip, jar, war, wal, wmz, xpi, ear, odt, ods and odp files.TAR, registered to tar, tar.gz, tgz, tar.bz2 and tbz2 files.GZIP, registered to gz files.BZip2, registered to bz2 files.ISO, registered to iso and nrg files.AR, registered to ar, a and deb files.LST, registered to lst files.RAR, registered to rar files.SEVENZIP, registered to 7z files.FileFactory is created.\n */\n private FileFactory() {\n }\n\n\n /**\n * Registers a new file protocol.\n * protocol argument is expected to be the protocol identifier, without the trailing ://.\n * For example, the identifier of the HTTP protocol would be http. This parameter's case is irrelevant,\n * as it will be stored in all lower-case.\n *\n * null otherwise.\n */\n public static ProtocolProvider registerProtocol(String protocol, ProtocolProvider provider) {\n protocol = protocol.toLowerCase();\n\n // create raw and archive file pools\n synchronized (FILE_POOL_MAP) {\n FILE_POOL_MAP.put(protocol, new FilePool());\n }\n\n // Special case for local file provider.\n // Note that the local file provider is also added to the provider hashtable.\n if (protocol.equals(FileProtocols.FILE)) {\n localFileProvider = provider;\n }\n\n return protocolProviders.put(protocol, provider);\n }\n\n /**\n * Unregisters the provider associated with the specified protocol.\n *\n * @param protocol identifier of the protocol whose provider should be unregistered.\n * @return the provider that has been unregistered, or null if none.\n */\n public static ProtocolProvider unregisterProtocol(String protocol) {\n protocol = protocol.toLowerCase();\n\n // Remove raw and archive file pools\n synchronized (FILE_POOL_MAP) {\n FILE_POOL_MAP.remove(protocol);\n }\n\n // Special case for local file provider\n if (protocol.equals(FileProtocols.FILE)) {\n localFileProvider = null;\n }\n\n return protocolProviders.remove(protocol);\n }\n\n /**\n * Returns the protocol provider associated with the specified protocol identifier, or null if there\n * is none.\n *\n * @param protocol identifier of the protocol whose provider should be retrieved.\n * @return the protocol provider registered to the specified protocol identifier, or null if none.\n */\n public static ProtocolProvider getProtocolProvider(String protocol) {\n return protocolProviders.get(protocol.toLowerCase());\n }\n\n /**\n * Returns true if the given protocol has a registered {@link ProtocolProvider}.\n *\n * @param protocol identifier of the protocol to test\n * @return true if the given protocol has a registered {@link ProtocolProvider}.\n */\n public static boolean isRegisteredProtocol(String protocol) {\n return getProtocolProvider(protocol)!=null;\n }\n\n /**\n * Returns an iterator on all known protocol names.\n *\n * nextElement() method will be string instances. These can\n * then be passed to {@link #getProtocolProvider(String) getProtocolProvider} to retrieve the associated\n * {@link ProtocolProvider}.\n *\n * @return an iterator on all known protocol names.\n */\n public static IteratorArchiveFormatProvider.\n *\n * @param provider the ArchiveFormatProvider to register.\n */\n public static void registerArchiveFormat(ArchiveFormatProvider provider) {\n archiveFormatProvidersV.add(provider);\n updateArchiveFormatProviderArray();\n }\n\n /**\n * Removes a previously-registered ArchiveFormatProvider.\n * FileFactory.unregisterArchiveFormat(FileFactory.getArchiveFormatProvider(\"file.zip\"))\n * will unregister the (first, if any) Zip provider.\n *\n * @param provider the ArchiveFormatProvider to unregister.\n * @see #getArchiveFormatProvider(String)\n */\n public static void unregisterArchiveFormat(ArchiveFormatProvider provider) {\n int index = archiveFormatProvidersV.indexOf(provider);\n\n if (index != -1) {\n archiveFormatProvidersV.remove(index);\n updateArchiveFormatProviderArray();\n }\n }\n\n /**\n * Updates the ArchiveFormatProvider array to reflect the contents of the Vector.\n */\n private static void updateArchiveFormatProviderArray() {\n archiveFormatProviders = new ArchiveFormatProvider[archiveFormatProvidersV.size()];\n archiveFormatProvidersV.toArray(archiveFormatProviders);\n }\n\n /**\n * Returns the first ArchiveFormatProvider that matches the specified filename, null\n * if there is none. Note that if a filename matches the {@link java.io.FilenameFilter} of several registered\n * providers, the first provider matching the filename will be returned.\n *\n * @param filename an archive filename that potentially matches one of the registered ArchiveFormatProvider\n * @return the first ArchiveFormatProvider that matches the specified filename, null if there is none\n */\n private static ArchiveFormatProvider getArchiveFormatProvider(String filename) {\n if (filename == null || archiveFormatProviders == null) {\n return null;\n }\n\n for (ArchiveFormatProvider provider : archiveFormatProviders) {\n if (provider != null && provider.getFilenameFilter() != null && provider.getFilenameFilter().accept(filename)) {\n return provider;\n }\n }\n return null;\n }\n\n /**\n * Returns an iterator on all known archive formats.\n *\n * @return an iterator on all known archive formats.\n */\n public static Iteratornull if the file could not be created.\n *\n * @param absPath the absolute path to the file\n * @return null if the given path is not absolute or incorrect (doesn't correspond to any file) or\n * if something went wrong during file creation.\n */\n public static AbstractFile getFile(String absPath) {\n try {\n return getFile(absPath, null);\n } catch(IOException e) {\n getLogger().info(\"Caught an exception (file {})\", absPath, e);\n return null;\n }\n }\n\n /**\n * Returns an instance of AbstractFile for the given absolute path.\n *\n * null if the file could not be created.\n *\n * @param absPath the absolute path to the file\n * @param throwException if set to true, an IOException will be thrown if something went wrong during file creation\n * @return null if the given path is not absolute or incorrect (doesn't correspond to any file)\n * @throws java.io.IOException and throwException param was set to true.\n * @throws AuthException if additional authentication information is required to create the file\n */\n public static AbstractFile getFile(String absPath, boolean throwException) throws AuthException, IOException {\n try {\n return getFile(absPath, null);\n } catch(IOException e) {\n getLogger().info(\"Caught an exception\", e);\n\n if (throwException) {\n throw e;\n }\n return null;\n }\n }\n\n /**\n * Returns an instance of AbstractFile for the given absolute path and use the given parent for the new file if\n * not null. AbstractFile subclasses should as much as possible call this method rather than {@link #getFile(String)} \n * because it is more efficient.\n *\n * @param absPath the absolute path to the file\n * @param parent the returned file's parent\n * @return an instance of AbstractFile for the specified absolute path.\n * @throws java.io.IOException if something went wrong during file or file url creation.\n * @throws AuthException if additional authentication information is required to create the file\n */\n public static AbstractFile getFile(String absPath, AbstractFile parent) throws AuthException, IOException {\n return getFile(FileURL.getFileURL(absPath), parent);\n }\n\n /**\n * Returns an instance of AbstractFile for the given FileURL instance.\n *\n * @param fileURL the file URL\n * @return the created file or null if something went wrong during file creation\n */\n public static AbstractFile getFile(FileURL fileURL) {\n try {\n return getFile(fileURL, null);\n } catch(IOException e) {\n getLogger().info(\"Caught an exception\", e);\n return null;\n }\n }\n\n /**\n * Returns an instance of AbstractFile for the given FileURL instance.\n *\n * @param fileURL the file URL\n * @param throwException if set to true, an IOException will be thrown if something went wrong during file creation\n * @return the created file\n * @throws java.io.IOException if something went wrong during file creation\n */\n public static AbstractFile getFile(FileURL fileURL, boolean throwException) throws IOException {\n try {\n return getFile(fileURL, null);\n } catch(IOException e) {\n getLogger().info(\"Caught an exception\", e);\n\n if (throwException) {\n throw e;\n }\n return null;\n }\n }\n\n /**\n * Shorthand for {@link #getFile(FileURL, AbstractFile, Authenticator, Object...)} called with the\n * {@link #getDefaultAuthenticator() default authenticator}.\n *\n * @param fileURL the file URL representing the file to be created\n * @param parent the parent AbstractFile to use as the created file's parent, can be null\n * @return an instance of {@link AbstractFile} for the given {@link FileURL}.\n * @throws java.io.IOException if something went wrong during file creation.\n */\n public static AbstractFile getFile(FileURL fileURL, AbstractFile parent, Object... instantiationParams) throws IOException {\n return getFile(fileURL, parent, defaultAuthenticator, instantiationParams);\n }\n\n /**\n * Creates and returns an instance of AbstractFile for the given FileURL and uses the specified parent file (if any)\n * as the created file's parent.\n *\n * null, no {@link Authenticator} will be used, not even the default one.\n * @param parent the parent AbstractFile to use as the created file's parent, can be null\n * @return an instance of {@link AbstractFile} for the given {@link FileURL}.\n * @throws java.io.IOException if something went wrong during file creation.\n */\n public static AbstractFile getFile(FileURL fileURL, AbstractFile parent, Authenticator authenticator, Object... instantiationParams) throws IOException {\n String protocol = fileURL.getScheme();\n if (!isRegisteredProtocol(protocol)) {\n throw new IOException(\"Unsupported file protocol: \" + protocol);\n }\n\n // Lookup the pool for an existing AbstractFile instance, only if there are no instantiationParams.\n // If there are instantiationParams (the file was created by the AbstractFile implementation directly, that is\n // by ls()), any existing file in the pool must be replaced with a new, more up-to-date one.\n FilePool filePool = FILE_POOL_MAP.get(fileURL.getScheme().toLowerCase());\n if (instantiationParams.length == 0) {\n // Note: FileURL#equals(Object) and #hashCode() take into account credentials and properties and are\n // trailing slash insensitive (e.g. '/root' and '/root/' URLS are one and the same)\n AbstractFile file = filePool.get(fileURL);\n if (file != null) {\n return file;\n }\n }\n\n String filePath = fileURL.getPath();\n // For local paths under Windows (e.g. \"/C:\\temp\"), remove the leading '/' character\n if (OsFamily.WINDOWS.isCurrent() && FileProtocols.FILE.equals(protocol)) {\n filePath = PathUtils.removeLeadingSeparator(filePath, \"/\");\n }\n\n String pathSeparator = fileURL.getPathSeparator();\n\n PathTokenizer pt = new PathTokenizer(filePath, pathSeparator, false);\n\n AbstractFile currentFile = null;\n boolean lastFileResolved = false;\n\n // Extract every filename from the path from left to right and for each of them, see if it looks like an archive.\n // If it does, create the appropriate protocol file and wrap it with an archive file.\n while (pt.hasMoreFilenames()) {\n // Test if the filename's extension looks like a supported archive format...\n // Note that the archive can also be a directory with an archive extension.\n if (isArchiveFilename(pt.nextFilename())) {\n // Remove trailing separator of file, some file protocols such as SFTP don't like trailing separators.\n // On the contrary, directories without a trailing slash are fine.\n String currentPath = PathUtils.removeTrailingSeparator(pt.getCurrentPath(), pathSeparator);\n\n // Test if current file is an archive and if it is, create an archive entry file instead of a raw\n // protocol file\n if (currentFile == null || !currentFile.isArchive()) {\n // create a fresh FileURL with the current path\n FileURL clonedURL = (FileURL)fileURL.clone();\n clonedURL.setPath(currentPath);\n\n // Look for a cached file instance before creating a new one\n currentFile = filePool.get(clonedURL);\n if (currentFile == null) {\n currentFile = wrapArchive(createRawFile(clonedURL, authenticator, instantiationParams));\n // Add the intermediate file instance to the cache\n filePool.put(clonedURL, currentFile);\n }\n\n lastFileResolved = true;\n } else { // currentFile is an AbstractArchiveFile\n // Note: wrapArchive() is already called by AbstractArchiveFile#createArchiveEntryFile()\n AbstractFile tempEntryFile = ((AbstractArchiveFile)currentFile).getArchiveEntryFile(PathUtils.removeLeadingSeparator(currentPath.substring(currentFile.getURL().getPath().length()), pathSeparator));\n if (tempEntryFile.isArchive()) {\n currentFile = tempEntryFile;\n lastFileResolved = true;\n } else {\n lastFileResolved = false;\n }\n // Note: don't cache the entry file\n }\n } else {\n lastFileResolved = false;\n }\n }\n\n // create last file if it hasn't been already (if the last filename was not an archive), same routine as above\n // except that it doesn't wrap the file with an archive file\n if (!lastFileResolved) {\n // Note: DON'T strip out the trailing separator, as this would cause problems with root resources\n String currentPath = pt.getCurrentPath();\n\n if (currentFile == null || !currentFile.isArchive()) {\n FileURL clonedURL = (FileURL)fileURL.clone();\n clonedURL.setPath(currentPath);\n\n // Note: no need to look a cached file instance, we have already looked for it at the very beginning.\n currentFile = createRawFile(clonedURL, authenticator, instantiationParams);\n // Add the final file instance to the cache\n filePool.put(currentFile.getURL(), currentFile);\n } else { // currentFile is an AbstractArchiveFile\n currentFile = ((AbstractArchiveFile)currentFile).getArchiveEntryFile(PathUtils.removeLeadingSeparator(currentPath.substring(currentFile.getURL().getPath().length()), pathSeparator));\n // Note: don't cache the entry file\n }\n }\n\n // Reuse existing parent file instance if one was specified\n if (parent != null)\n currentFile.setParent(parent);\n\n return currentFile;\n }\n\n private static AbstractFile createRawFile(FileURL fileURL, Authenticator authenticator, Object... instantiationParams) throws IOException {\n String scheme = fileURL.getScheme().toLowerCase();\n\n // Special case for local files to avoid provider hashtable lookup and other unnecessary checks\n // (for performance reasons)\n if (scheme.equals(FileProtocols.FILE)) {\n if (localFileProvider == null) {\n throw new IOException(\"Unknown file protocol: \" + scheme);\n }\n\n return localFileProvider.getFile(fileURL, instantiationParams);\n\n // Uncomment this line and comment the previous one to simulate a slow filesystem\n //file = new DebugFile(file, 0, 50);\n }\n // Use the protocol hashtable for any other file protocol\n else {\n // If an Authenticator has been specified and the specified FileURL's protocol is authenticated and the\n // FileURL doesn't contain any credentials, use it to authenticate the FileURL.\n if (authenticator != null && fileURL.getAuthenticationType() != AuthenticationType.NO_AUTHENTICATION && !fileURL.containsCredentials()) {\n authenticator.authenticate(fileURL);\n }\n\n // Finds the right file protocol provider\n ProtocolProvider provider = getProtocolProvider(scheme);\n if (provider == null) {\n throw new IOException(\"Unknown file protocol: \" + scheme);\n }\n\n return provider.getFile(fileURL, instantiationParams);\n }\n }\n\n /**\n * Returns a variation of the given filename, appending a pseudo-unique ID to the filename's prefix while keeping\n * the same filename extension.\n *\n * @param filename base filename\n */\n private static String getFilenameVariation(String filename) {\n int lastDotPos = filename.lastIndexOf('.');\n int len = filename.length();\n String nameSuffix = \"_\" + System.currentTimeMillis() + (new Random().nextInt(10000));\n\n if (lastDotPos == -1) {\n filename += nameSuffix;\n } else {\n filename = filename.substring(0, lastDotPos) + nameSuffix + filename.substring(lastDotPos, len);\n }\n\n return filename;\n }\n\n /**\n * Creates and returns a temporary local file using the desired filename. If a file with this name already exists\n * in the temp directory, the filename's prefix (name without extension) will be appended an ID. The filename's\n * extension will however always be preserved.\n *\n * true, the temporary file will be deleted upon normal termination of the JVM\n * @return the temporary file, may be a LocalFile or an AbstractArchiveFile if the filename's extension corresponds\n * to a registered archive format.\n * @throws IOException if an error occurred while instantiating the temporary file. This should not happen under\n * normal circumstances.\n */\n public static AbstractFile getTemporaryFile(String desiredFilename, boolean deleteOnExit) throws IOException {\n if (desiredFilename == null || desiredFilename.isEmpty()) {\n desiredFilename = \"temp\";\n }\n \n // Attempt to use the desired name\n AbstractFile tempFile = TEMP_DIRECTORY.getDirectChild(desiredFilename);\n\n if (tempFile.exists()) {\n tempFile = TEMP_DIRECTORY.getDirectChild(getFilenameVariation(desiredFilename));\n }\n\n if (deleteOnExit) {\n ((java.io.File)tempFile.getUnderlyingFileObject()).deleteOnExit();\n }\n\n return tempFile;\n }\n\n /**\n * Creates a temporary file with a default filename. This method is a shorthand for\n * {@link #getTemporaryFile(String, boolean)} called with a null name.\n *\n * @param deleteOnExit if true, the temporary file will be deleted upon normal termination of the JVM\n * @return the temporary file, may be a LocalFile or an AbstractArchiveFile if the filename's extension corresponds\n * to a registered archive format.\n * @throws IOException if an error occurred while instantiating the temporary file. This should not happen under\n * normal circumstances.\n */\n public static AbstractFile getTemporaryFile(boolean deleteOnExit) throws IOException {\n return getTemporaryFile(null, deleteOnExit);\n }\n\n /**\n * Returns the temporary folder, i.e. the parent folder of temporary files returned by\n * {@link #getTemporaryFile(String, boolean)}.\n *\n * @return the temporary folder\n */\n public static AbstractFile getTemporaryFolder() {\n return TEMP_DIRECTORY;\n }\n\n\n /**\n * Returns true if the given filename's extension matches one of the registered archive formats.\n *\n * @param filename the filename to test\n * @return true if the specified filename is a known archive file name, false otherwise.\n */\n public static boolean isArchiveFilename(String filename) {\n if (archiveExtensions == null) {\n if (archiveFormatProviders == null) {\n return false;\n }\n archiveExtensions = new HashSet<>();\n for (ArchiveFormatProvider provider : archiveFormatProviders) {\n if (provider != null) {\n String[] extensions = provider.getFileExtensions();\n for (String ext : extensions) {\n String extWithoutDot = ext.startsWith(\".\") ? ext.substring(1) : ext;\n archiveExtensions.add(extWithoutDot.toLowerCase());\n }\n }\n }\n }\n String ext = AbstractFile.getExtension(filename);\n return ext != null && archiveExtensions.contains(ext.toLowerCase());\n //return getArchiveFormatProvider(filename) != null;\n }\n\n /**\n * Tests if the given file's extension matches that of one of the registered archive formats.\n * If it does, a corresponding {@link AbstractArchiveFile} instance is created on top of the provided file\n * and returned. If it doesn't, the provided AbstractFile instance is simply returned.\n * Method object.\n * @return the {@link AbstractFile} method corresponding to this file operation.\n */\n public Method getCorrespondingMethod(Class c) {\n try {\n switch(this) {\n case READ_FILE:\n return c.getMethod(\"getInputStream\");\n\n case RANDOM_READ_FILE:\n return c.getMethod(\"getRandomAccessInputStream\");\n\n case WRITE_FILE:\n return c.getMethod(\"getOutputStream\");\n\n case APPEND_FILE:\n return c.getMethod(\"getAppendOutputStream\");\n\n case RANDOM_WRITE_FILE:\n return c.getMethod(\"getRandomAccessOutputStream\");\n\n case CREATE_DIRECTORY:\n return c.getMethod(\"mkdir\");\n\n case LIST_CHILDREN:\n return c.getMethod(\"ls\");\n\n case CHANGE_DATE:\n return c.getMethod(\"setLastModifiedDate\", Long.TYPE);\n\n case GET_BLOCKSIZE:\n return c.getMethod(\"getBlocksize\");\n\n case GET_REPLICATION:\n return c.getMethod(\"getReplication\");\n\n case CHANGE_REPLICATION:\n return c.getMethod(\"changeReplication\", Short.TYPE);\n\n case CHANGE_PERMISSION:\n return c.getMethod(\"changePermission\", Integer.TYPE, Integer.TYPE, Boolean.TYPE);\n\n case DELETE:\n return c.getMethod(\"delete\");\n\n case RENAME:\n return c.getMethod(\"renameTo\", AbstractFile.class);\n\n case COPY_REMOTELY:\n return c.getMethod(\"copyRemotelyTo\", AbstractFile.class);\n\n case GET_FREE_SPACE:\n return c.getMethod(\"getFreeSpace\");\n\n case GET_TOTAL_SPACE:\n return c.getMethod(\"getTotalSpace\");\n\n default:\n // This should never be reached, unless method signatures have changed and this method hasn't been updated.\n LOGGER.warn(\"this line should not have been executed\");\n return null;\n }\n } catch (Exception e) {\n // Should never happen, unless method signatures have changed and this method hasn't been updated.\n LOGGER.warn(\"this line should not have been executed\", e);\n return null;\n }\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/FilePermissions.java",
"content": "package com.mucommander.commons.file;\n\n/**\n * FilePermissions is an interface that represents the permissions of an {@link com.mucommander.commons.file.AbstractFile}.\n * The actual permission values can be retrieved by the methods inherited from the\n * {@link com.mucommander.commons.file.PermissionBits} interface. The permissions mask returned by {@link #getMask()} allows\n * to determine which permission bits are significant, i.e. should be taken into account. That way, certain\n * {@link AbstractFile} implementations that have limited permissions support can set those supported permission bits\n * while making it clear that other bits should be ignored, and not simply be considered as being disabled.\n * For instance, a file implementation with support for the sole 'user' permissions (read/write/execute) will return a\n * mask whose int value is 448 (700 octal).\n *\n * \r\n * \tscheme://[login[:password]@]host[:port][/path][?query]\r\n *
\r\n *\r\n * Instantiation
\r\n * java.net.URL and java.net.URI classes, FileURL instances are mutable --\r\n * all URL parts can be freely modified. FileURL instances can also be cloned using the standard {@link #clone()} method.\r\n *\r\n * Handlers and Scheme-specific attributes
\r\n * \r\n *
\r\n * These attribute values are provided by the {@link SchemeHandler} registered with the scheme, if any.\r\n * registerHandler and\r\n * unregisterHandler.\r\n * scheme://). Those locations can be system-dependent,\r\n * local and absolute paths, or UNC paths. These paths are turned by the parser into an equivalent, fully-qualified URL.\r\n *\r\n * Properties
\r\n * Limitations
\r\n * \r\n *
\r\n * Some of these limitations will be addressed in upcoming revisions of this class.\r\n *\r\n * @see SchemeHandler\r\n * @see SchemeParser\r\n * @author Maxence Bernard\r\n */\r\npublic class FileURL implements Cloneable {\r\n\r\n // Todo: add support for the fragment part\r\n // Todo: add percent encoding/decoding\r\n\r\n /** Handler instance that provides the scheme-specific features of this FileURL */\r\n private SchemeHandler handler;\r\n\r\n /** Scheme part */\r\n private String scheme;\r\n /** Port part, -1 if this URL has none */\r\n private int port = -1;\r\n /** Host part, null if this URL has none */\r\n private String host;\r\n /** Path part */\r\n private String path;\r\n /** Filename, extracted from the path, null if the path has none */\r\n private String filename;\r\n /** Query part, null if this URL has none */\r\n private String query;\r\n\r\n /** Properties, null if none have been set thus far */\r\n private MapMalformedURLException\r\n * if the specified location is not a valid URL or path and cannot be resolved. The {@link SchemeParser parser}\r\n * of the {@link SchemeHandler handler} registered for the location's scheme is used to parse the given location.\r\n * If the scheme specified in the location does not have a specific handler, or if the location does not contain a\r\n * scheme (i.e. is local or UNC path, not a URL) then the default handler's parser is used.\r\n *\r\n * @param location the URL or path for which to get a FileURL instance\r\n * @throws MalformedURLException if the specified string isn't a valid URL, according to the scheme's parser used\r\n * @return a FileURL corresponding to the given location\r\n */\r\n public static FileURL getFileURL(String location) throws MalformedURLException {\r\n if (location == null) {\r\n return null;\r\n }\r\n int schemeDelimPos = location.indexOf(\"://\");\r\n SchemeHandler handler;\r\n\r\n if (schemeDelimPos == -1) {\r\n // No scheme: the location is a local or UNC path, not a URL\r\n handler = getDefaultHandler();\r\n } else {\r\n handler = getSchemeHandler(location.substring(0, schemeDelimPos));\r\n }\r\n\r\n FileURL fileURL = new FileURL(handler);\r\n try {\r\n handler.getParser().parse(location, fileURL);\r\n } catch (Exception e) {\r\n // Catch any unexpected exception thrown by the SchemeParser and turn it into a MalformedURLException\r\n // with a specific error message.\r\n if (e instanceof MalformedURLException) {\r\n throw (MalformedURLException) e;\r\n }\r\n\r\n throw new MalformedURLException(\"URL parser error\");\r\n }\r\n\r\n return fileURL;\r\n }\r\n\r\n /**\r\n * Returns the handler registered the specified scheme if there is one, the default handler otherwise.\r\n *\r\n * @param scheme the scheme for which to return a handler\r\n * @return a handler for the specified scheme\r\n */\r\n private static SchemeHandler getSchemeHandler(String scheme) {\r\n SchemeHandler handler = getRegisteredHandler(scheme);\r\n if (handler == null) {\r\n return getDefaultHandler();\r\n }\r\n\r\n return handler;\r\n }\r\n\r\n /**\r\n * Returns the SchemeHandler instance that provides the scheme-specific features of this FileURL.\r\n *\r\n * @return the SchemeHandler instance that provides the scheme-specific features of this FileURL\r\n */\r\n public SchemeHandler getHandler() {\r\n return handler;\r\n }\r\n\r\n /**\r\n * Sets the SchemeHandler that provides the scheme-specific features of this FileURL.\r\n * SchemeHandler instance that provides the scheme-specific features of this FileURL\r\n */\r\n public void setHandler(SchemeHandler handler) {\r\n this.handler = handler;\r\n }\r\n\r\n /**\r\n * Registers a handler for the specified scheme, replacing any handler previously registered\r\n * for the same scheme.\r\n *\r\n * @param scheme the scheme to associate the handler with (case-insensitive)\r\n * @param handler the new handler in charge of the scheme\r\n */\r\n static void registerHandler(String scheme, SchemeHandler handler) {\r\n handlers.put(scheme.toLowerCase(), handler);\r\n }\r\n\r\n /**\r\n * Removes any handler associated with the specified scheme, leaving the default handler in charge of the scheme.\r\n * This method has no effect if there is no handler registered for the scheme.\r\n *\r\n * @param scheme the scheme to remove the handler for\r\n */\r\n static void unregisterHandler(String scheme) {\r\n handlers.remove(scheme.toLowerCase());\r\n }\r\n\r\n /**\r\n * Returns the handler registered for the specified scheme, null if there isn't any.\r\n *\r\n * @param scheme the scheme for which to return the handler\r\n * @return the handler registered for the specified scheme\r\n */\r\n public static SchemeHandler getRegisteredHandler(String scheme) {\r\n return handlers.get(scheme.toLowerCase());\r\n }\r\n\r\n /**\r\n * Returns the default handler, which handles schemes which do not have a specific handler.\r\n * The returned instance is a {@link DefaultSchemeHandler} created with the no-arg constructor. \r\n *\r\n * @return the default handler\r\n */\r\n static SchemeHandler getDefaultHandler() {\r\n return DEFAULT_HANDLER;\r\n }\r\n\r\n /**\r\n * Extracts the filename from the given path and returns it, or null if the path does not contain\r\n * a filename.\r\n *\r\n * @param path the path from which to extract a filename\r\n * @param separator the path separator\r\n * @return the filename extracted from the given path, null if the path doesn't contain any\r\n */\r\n public static String getFilenameFromPath(String path, String separator) {\r\n if (path.isEmpty() || path.equals(\"/\")) {\r\n return null;\r\n }\r\n\r\n // Remove any trailing separator\r\n path = PathUtils.removeTrailingSeparator(path, separator);\r\n\r\n if (!separator.equals(\"/\")) {\r\n path = PathUtils.removeLeadingSeparator(path, \"/\");\r\n }\r\n\r\n // Extract filename\r\n int pos = path.lastIndexOf(separator);\r\n if (pos < 0) {\r\n return null;\r\n }\r\n\r\n return path.substring(pos+1);\r\n }\r\n\r\n\r\n /**\r\n * Returns the scheme part of this URL. The returned scheme may never be null.\r\n *\r\n * @return the scheme part of this FileURL.\r\n * @see #setScheme(String)\r\n */\r\n public String getScheme() {\r\n return scheme;\r\n }\r\n\r\n /**\r\n * Sets the scheme part of this URL. An IllegalArgumentException will be thrown if the specified scheme\r\n * is null or an empty string.\r\n * null if it doesn't contain any.\r\n *\r\n * @return the host part of this URL.\r\n * @see #setHost(String)\r\n */\r\n public String getHost() {\r\n return host;\r\n }\r\n\r\n /**\r\n * Sets the host part of this URL, null for no host.\r\n *\r\n * @param host new host part of this URL.\r\n * @see #getHost()\r\n */\r\n public void setHost(String host) {\r\n this.host = host;\r\n\r\n urlModified();\r\n }\r\n\r\n /**\r\n * Returns the port part of this URL, -1 if none was specified in the URL.\r\n *\r\n * @return the port part of this URL, -1 if there isn't any.\r\n * @see #setPort(int)\r\n * @see #getDefaultHandler()\r\n */\r\n public int getPort() {\r\n return port;\r\n }\r\n\t\r\n /**\r\n * Sets the port part of this URL, -1 for no specific port.\r\n *\r\n * @param port new port part of this URL.\r\n * @see #getPort()\r\n * @see #getDefaultHandler()\r\n */\r\n public void setPort(int port) {\r\n this.port = port;\r\n\r\n urlModified();\r\n }\r\n\r\n /**\r\n * Returns this scheme's standard port, -1 if the scheme doesn't have any.\r\n * If this URL doesn't have a specific port part, the return value should be considered as being this URL's port.\r\n *\r\n * getHandler().getStandardPort().\r\n *\r\n * @return the scheme's standard port\r\n * @see #getPort()\r\n */\r\n public int getStandardPort() {\r\n return handler.getStandardPort();\r\n }\r\n \r\n\r\n /**\r\n * Returns the login part of this URL, null if there isn't any.\r\n *\r\n * @return the login part of this URL, null if there isn't any\r\n * @see #getCredentials()\r\n */\r\n public String getLogin() {\r\n return credentials==null?null:credentials.getLogin();\r\n }\r\n\r\n /**\r\n * Returns the password part of this URL, null if there isn't any.\r\n *\r\n * @return the password part of this URL, null if there isn't any\r\n * @see #getCredentials()\r\n */\r\n public String getPassword() {\r\n return credentials==null?null:credentials.getPassword();\r\n }\r\n\r\n /**\r\n * Returns the type of authentication used by the scheme's file protocol. The returned value is one of the constants\r\n * defined in the {@link AuthenticationType} enum.\r\n *\r\n * getHandler().getAuthenticationType().\r\n *\r\n * @return the type of authentication used by the scheme's file protocol\r\n */\r\n public AuthenticationType getAuthenticationType() {\r\n return handler.getAuthenticationType();\r\n }\r\n\r\n /**\r\n * Returns true if this URL contains credentials, i.e. a login and/or password part. If true is\r\n * returned, {@link #getCredentials()} will return a non-null value.\r\n *\r\n * @return true if this URL contains credentials, false otherwise.\r\n */\r\n public boolean containsCredentials() {\r\n return credentials!=null;\r\n }\r\n\r\n /**\r\n * Returns the credentials (login and password) contained by this URL, wrapped in an {@link Credentials} object.\r\n * Returns null if this URL doesn't have a login or password part.\r\n *\r\n * null if this URL doesn't have a login or password part.\r\n * @see #setCredentials(Credentials)\r\n * @see #getAuthenticationType()\r\n */\r\n public Credentials getCredentials() {\r\n return credentials;\r\n }\r\n\r\n /**\r\n * Sets the login and password parts of this URL. Any credentials contained by this FileURL will be replaced.\r\n * null can be passed to discard existing credentials.\r\n *\r\n * null if the scheme doesn't have any.\r\n * getHandler().getGuestCredentials().\r\n *\r\n * @return the scheme's guest credentials, null if the scheme doesn't have any\r\n */\r\n public Credentials getGuestCredentials() {\r\n return handler.getGuestCredentials();\r\n }\r\n\r\n\r\n /**\r\n * Returns the path part of this URL. The returned value will never be null and always start with a\r\n * leading '/' character.\r\n *\r\n * @return the path part of this URL.\r\n * @see #setPath(String)\r\n */\r\n public String getPath() {\r\n return path;\r\n }\r\n\r\n /**\r\n * Sets the path part of this URL. The specified path cannot be null and must start with a leading \r\n * '/' character. If the specified path value is null, then the path will be set to \"/\".\r\n * If the path does not start with a leading separator, one will be added.\r\n *\r\n * @param path new path part of this URL\r\n * @see #getPath()\r\n */\r\n public void setPath(String path) {\r\n if (path == null || path.isEmpty()) {\r\n path = \"/\";\r\n }\r\n\r\n if (!path.startsWith(\"/\")) {\r\n path = \"/\" + path;\r\n }\r\n\r\n this.path = path;\r\n // Extract new filename from path\r\n this.filename = getFilenameFromPath(path, getPathSeparator());\r\n\r\n urlModified();\r\n }\r\n\r\n /**\r\n * Returns this scheme's path separator, which serves as a delimiter for path fragments. For most schemes, this is\r\n * the forward slash character.\r\n *\r\n * getHandler().getPathSeparator().\r\n *\r\n * @return this scheme's path separator\r\n */\r\n public String getPathSeparator() {\r\n return handler.getPathSeparator();\r\n }\r\n\r\n\r\n /**\r\n * Returns the parent of this URL according to its path, null if this URL has no parent (its path is \"/\").\r\n * null, even if this URL had one.\r\n *\r\n * null if it doesn't have one.\r\n */\r\n public FileURL getParent() {\r\n // If path equals '/', url has no parent\r\n if (!(path.equals(\"/\") || path.isEmpty())) {\r\n String separator = getPathSeparator();\r\n\r\n // Remove any trailing separator\r\n String parentPath = path.endsWith(separator)?path.substring(0, path.length()-separator.length()):path;\r\n\r\n // Resolve parent folder's path and reconstruct parent URL\r\n int lastSeparatorPos = parentPath.lastIndexOf(separator);\r\n if (lastSeparatorPos >= 0) {\r\n FileURL parentURL = new FileURL(handler);\r\n\r\n parentURL.scheme = scheme;\r\n parentURL.host = host;\r\n parentURL.port = port;\r\n parentURL.path = parentPath.substring(0, lastSeparatorPos+1); // Keep trailing slash\r\n parentURL.filename = getFilenameFromPath(parentURL.path, separator);\r\n\r\n // Set same credentials for parent, (if any)\r\n // Note: Credentials are immutable.\r\n parentURL.credentials = credentials;\r\n\r\n // Copy properties to parent (if any)\r\n if (properties != null)\r\n parentURL.properties = new HashMap<>(properties);\r\n\r\n return parentURL;\r\n }\r\n }\r\n\r\n return null; // URL has no parent\r\n }\r\n\r\n\r\n /**\r\n * Returns the authentication realm corresponding to this URL, i.e. the base location throughout which credentials\r\n * can be used. Any property contained by the specified FileURL will be carried over in the returned FileURL.\r\n * On the contrary, credentials will not be copied, the returned URL always has no credentials.\r\n *\r\n * getHandler().getRealm(this).\r\n *\r\n * @return this url's authentication realm\r\n */\r\n public FileURL getRealm() {\r\n return handler.getRealm(this);\r\n }\r\n\r\n\r\n /**\r\n * Returns the filename of this URL , null if doesn't have one (e.g. if the path is \"/\").\r\n * setFilename as the filename is simply extrapolated from the path.\r\n * Use {@link #setPath(String)} to change the path and its filename.\r\n *\r\n * @return the filename of this URL, null if it doesn't have one.\r\n * @see #setPath(String)\r\n */\r\n public String getFilename() {\r\n return filename;\r\n }\r\n\r\n\r\n /**\r\n * Returns the query part of this URL if it has one, null otherwise.\r\n *\r\n * @return the query part of this URL if it has one, null otherwise\r\n * @see #setQuery(String)\r\n */\r\n public String getQuery() {\r\n return query;\r\n }\r\n\r\n /**\r\n * Sets the query part of this URL, null for no query part.\r\n *\r\n * @param query new query part of this URL, null for no query part\r\n * @see #getQuery()\r\n */\r\n public void setQuery(String query) {\r\n this.query = query;\r\n\r\n urlModified();\r\n }\r\n\r\n\t\r\n /**\r\n * Returns the value corresponding to the given property name, null if the property has no value.\r\n *\r\n * @param name name of the property whose value is to be retrieved\r\n * @return the value associated with the specified property name, null if it has no value\r\n * @see #setProperty(String,String)\r\n */\r\n public String getProperty(String name) {\r\n return properties==null?null:properties.get(name);\r\n }\r\n\t\r\n /**\r\n * Sets the given property (name/value pair) in the FileURL instance. A null property value has the\r\n * effect of removing the property.\r\n *\r\n * @param name name of the property to set\r\n * @param value value of the property\r\n * @see #getProperty(String)\r\n */\r\n public void setProperty(String name, String value) {\r\n // create the property map only when a property is set for the first time\r\n if (properties == null) {\r\n properties = new HashMap<>();\r\n }\r\n\r\n if (value == null) {\r\n properties.remove(name);\r\n } else {\r\n properties.put(name, value);\r\n }\r\n\r\n urlModified();\r\n }\r\n\r\n\r\n /**\r\n * Returns an Enumeration of all property names this FileURL contains.\r\n *\r\n * @return an Enumeration of all property names this FileURL contains\r\n */\r\n public Settrue, the login and password parts (if any) will be included in the\r\n * returned URL.\r\n * @param maskPassword if true and the includeCredentials parameter is also true, the password's\r\n * characters (if any) will be replaced by '*' characters. This allows a URL containing credentials to be displayed\r\n * to the end user without revealing the actual password.\r\n * @return a string representation of this FileURL\r\n */\r\n public String toString(boolean includeCredentials, boolean maskPassword) {\r\n StringBuilder sb = new StringBuilder(scheme);\r\n sb.append(\"://\");\r\n\r\n if (includeCredentials && credentials != null) {\r\n sb.append(URLEncoder.encode(credentials.getLogin(), StandardCharsets.UTF_8));\r\n\r\n String password = credentials.getPassword();\r\n if (!password.isEmpty()) {\r\n sb.append(':');\r\n if (maskPassword) {\r\n sb.append(credentials.getMaskedPassword());\r\n } else {\r\n sb.append(URLEncoder.encode(password, StandardCharsets.UTF_8));\r\n }\r\n }\r\n sb.append('@');\r\n }\r\n\r\n if (host != null) {\r\n sb.append(host);\r\n }\r\n\r\n // Set the port only if it has a value that is different from the standard port\r\n if (port != -1 && port != handler.getStandardPort()) {\r\n sb.append(':');\r\n sb.append(port);\r\n }\r\n\r\n if (host != null || !path.equals(\"/\"))\t{ // Test to avoid URLs like 'smb:///'\r\n if (path.startsWith(\"/\")) {\r\n sb.append(path);\r\n } else {\r\n // Add a leading '/' if path doesn't already start with one, needed for scheme paths that are not\r\n // forward slash-separated\r\n sb.append('/');\r\n sb.append(path);\r\n }\r\n }\r\n\r\n if (query != null) {\r\n sb.append('?');\r\n sb.append(query);\r\n }\r\n\r\n return sb.toString();\r\n }\r\n\r\n /**\r\n * Returns a String representation of this FileURL, including the login and password parts (credentials) only if\r\n * requested.\r\n *\r\n * @param includeCredentials if true, the login and password parts (if any) will be included in the\r\n * returned URL.\r\n * @return a string representation of this FileURL.\r\n */\r\n public String toString(boolean includeCredentials) {\r\n return toString(includeCredentials, false);\r\n }\r\n\r\n\r\n /**\r\n * Creates and returns a java.net.URL referring to the same location as this FileURL.\r\n * The java.net.URL is created from the string representation of this FileURL.\r\n * Thus, any credentials this FileURL contains are preserved, but properties are lost.\r\n *\r\n * URL uses an {@link AbstractFile} to access the associated resource.\r\n * An {@link AbstractFile} instance is created by the underlying URLConnection when the URL is\r\n * connected.\r\n *\r\n * java.net.URL.\r\n *\r\n * @return a java.net.URL referring to the same location as this FileURL\r\n * @throws MalformedURLException if the java.net.URL could not parse the location of this FileURL\r\n */\r\n public URL getJavaNetURL() throws MalformedURLException {\r\n return new URL(null, toString(true), new CompatURLStreamHandler());\r\n }\r\n\r\n /**\r\n * Returns true if the scheme part of this URL and the given URL are equal.\r\n * The comparison is case-sensitive.\r\n *\r\n * @param url the URL to test for scheme equality\r\n * @return true if the scheme part of this URL and the given URL are equal\r\n */\r\n public boolean schemeEquals(FileURL url) {\r\n return this.scheme.equalsIgnoreCase(url.scheme);\r\n }\r\n\r\n /**\r\n * Returns true if the host part of this URL and the given URL are equal.\r\n * The comparison is case-insensitive.\r\n *\r\n * @param url the URL to test for host equality\r\n * @return true if the host part of this URL and the given URL are equal\r\n */\r\n public boolean hostEquals(FileURL url) {\r\n // Note: StringUtils#equals is null-safe \r\n return StringUtils.equals(this.host, url.host, false);\r\n }\r\n\r\n /**\r\n * Returns true if the port of this URL and the given URL's are equal. Ports are said to be equal if\r\n * the values returned by {@link #getPort()} are equal, or if both URLs have the same standard port\r\n * (as returned by {@link #getStandardPort()} and one of the port value is -1 (undefined) and the other\r\n * is the standard port.\r\n *\r\n * @param url the URL to test for port equality\r\n * @return true if the port of this URL and the given one are equal\r\n */\r\n public boolean portEquals(FileURL url) {\r\n int port1 = this.port;\r\n int port2 = url.port;\r\n int standardPort = getStandardPort();\r\n\r\n return port1==port2 ||\r\n (standardPort==url.getStandardPort() && ((port1==-1 && port2==standardPort || (port2==-1 && port1==standardPort))));\r\n }\r\n\r\n /**\r\n * Returns true if the path of this URL and the given URL are equal. The comparison is case-sensitive.\r\n * If the sole difference between two paths is a trailing path separator (and both URLs have the same path separator),\r\n * they will be considered as equal.\r\n * For example, /path and /path/ are considered equal, assuming the path separator is '/'.\r\n *\r\n * java.lang.String#equals(Object) to compare URL paths,\r\n * which in some rare cases may return false for non-ascii/Unicode paths that have the same written\r\n * representation but are not equal according to java.lang.String#equals(Object). Handling such cases\r\n * would require a locale-aware String comparison which is not an option here.\r\n *\r\n * @param url the URL to test for path equality\r\n * @return true if the path of this URL and the given URL are equal\r\n */\r\n public boolean pathEquals(FileURL url) {\r\n \tboolean isCaseSensitiveOS = !(OsFamily.WINDOWS.isCurrent() || OsFamily.OS_2.isCurrent());\r\n \t\r\n String path1 = isCaseSensitiveOS ? this.getPath() : this.getPath().toLowerCase();\r\n String path2 = isCaseSensitiveOS ? url.getPath() : url.getPath().toLowerCase();\r\n\r\n if (path1.equals(path2))\r\n return true;\r\n\r\n String separator = getPathSeparator();\r\n\r\n if (separator.equals(url.getPathSeparator())) {\r\n int separatorLen = separator.length();\r\n int len1 = path1.length();\r\n int len2 = path2.length();\r\n\r\n // If the difference between the 2 strings is just a trailing path separator, we consider the paths as equal\r\n if (Math.abs(len1-len2) == separatorLen && (len1 > len2 ? path1.startsWith(path2) : path2.startsWith(path1))) {\r\n String diff = len1>len2 ? path1.substring(len1-separatorLen) : path2.substring(len2-separatorLen);\r\n return separator.equals(diff);\r\n }\r\n }\r\n\r\n return false;\r\n }\r\n\r\n /**\r\n * Returns true if the query part of this URL and the given URL are equal.\r\n * The comparison is case-sensitive.\r\n *\r\n * @param url the URL to test for query equality\r\n * @return true if the query part of this URL and the given URL are equal\r\n */\r\n public boolean queryEquals(FileURL url) {\r\n return StringUtils.equals(this.query, url.query, true);\r\n }\r\n\r\n /**\r\n * Returns true if the credentials (login and password) of this URL and the given URL are equal.\r\n * The comparison is case-sensitive.\r\n *\r\n * @param url the URL to test for credentials equality\r\n * @return true if the credentials of this URL and the given URL are equal\r\n */\r\n public boolean credentialsEquals(FileURL url) {\r\n Credentials creds1 = this.credentials;\r\n Credentials creds2 = url.credentials;\r\n\r\n return (creds1 == null && creds2 == null)\r\n || (creds1 != null && creds1.equals(creds2, true))\r\n || (creds2 != null && creds2.equals(creds1, true));\r\n }\r\n\r\n /**\r\n * Returns true if the properties contained by this URL and the given URL are equal.\r\n * The comparison of each property is case-sensitive.\r\n *\r\n * @param url the URL to test for properties equality\r\n * @return true if the properties contained by this URL and the given URL are equal\r\n */\r\n private boolean propertiesEquals(FileURL url) {\r\n return (this.properties == null && url.properties == null)\r\n || (this.properties != null && this.properties.equals(url.properties))\r\n || (url.properties != null && url.properties.equals(this.properties));\r\n }\r\n\r\n\r\n ////////////////////////\r\n // Overridden methods //\r\n ////////////////////////\r\n\r\n /**\r\n * Returns a String representation of this FileURL, without including the login and password parts it may have.\r\n */\r\n public String toString() {\r\n return toString(false);\r\n }\r\n\r\n\r\n /**\r\n * Returns a clone of this FileURL. The returned instance can safely be modified without any impact on this FileURL\r\n * or any previously cloned URL.\r\n */\r\n @Override\r\n public Object clone() {\r\n // create a new FileURL return it, instead of using Object.clone() which is probably way slower;\r\n // most FileURL fields are immutable and as such reused in cloned instance\r\n FileURL clonedURL = new FileURL(handler);\r\n\r\n // Immutable fields\r\n clonedURL.scheme = scheme;\r\n clonedURL.host = host;\r\n clonedURL.port = port;\r\n clonedURL.path = path;\r\n clonedURL.filename = filename;\r\n clonedURL.query = query;\r\n clonedURL.credentials = credentials; // Note: Credentials are immutable.\r\n\r\n // Mutable fields\r\n if (properties != null) { // Copy properties (if any)\r\n clonedURL.properties = new HashMap<>(properties);\r\n }\r\n\r\n // Caches\r\n clonedURL.hashCode = hashCode;\r\n\r\n return clonedURL;\r\n }\r\n\r\n /**\r\n * This method is equivalent to calling {@link #equals(Object, boolean, boolean)} with credentials and properties\r\n * comparisons enabled.\r\n *\r\n * @param o object to compare against this FileURL instance.\r\n * @return true if both FileURL instances are equal.\r\n */\r\n public boolean equals(Object o) {\r\n return equals(o, true, true);\r\n }\r\n\r\n /**\r\n * Tests the specified FileURL for equality with this FileURL. false is systematically returned if the\r\n * specified object is not a FileURL instance or is null.\r\n * FileURL instances are said to be equal if:\r\n * \r\n *
\r\n * http://mucommander.com:80/\r\n * and http://mucommander.com/ are considered equal./path and /path/ are considered equal\r\n * (assuming the path separator is '/').
\r\n * Likewise, properties are compared only if requested: the comparison of all properties is case-sensitive.\r\n *\r\n * @param o object to compare against this FileURL instance\r\n * @param compareCredentials if true, the login and password parts of both FileURL need to be\r\n * equal (case-sensitive) for the FileURL instances to be equal\r\n * @param compareProperties if true, all properties need to be equal (case-sensitive) in both\r\n * FileURL for them to be equal\r\n * @return true if both FileURL instances are equal\r\n */\r\n public boolean equals(Object o, boolean compareCredentials, boolean compareProperties) {\r\n if (!(o instanceof FileURL)) {\r\n return false;\r\n }\r\n\r\n FileURL url = (FileURL)o;\r\n\r\n return pathEquals(url) // Compare the path first as it is the most likely to be different\r\n && schemeEquals(url)\r\n && hostEquals(url)\r\n && portEquals(url)\r\n && queryEquals(url)\r\n && (!compareCredentials || credentialsEquals(url))\r\n && (!compareProperties || propertiesEquals(url));\r\n }\r\n\r\n /**\r\n * This method is overridden to return a hash code that takes into account the behavior of {@link FileURL#equals(Object)},\r\n * so that url1.equals(url2) implies url1.hashCode()==url2.hashCode().\r\n */\r\n public int hashCode() {\r\n if (hashCode == 0) {\r\n String separator = handler.getPathSeparator();\r\n\r\n // #equals(Object) is trailing separator insensitive, so the hashCode must be trailing separator invariant\r\n int h = PathUtils.getPathHashCode(path, separator);\r\n\r\n h = 31* h + scheme.toLowerCase().hashCode();\r\n h = 31* h + (port==-1?handler.getStandardPort():port);\r\n\r\n if (host != null)\r\n h = 31* h + host.toLowerCase().hashCode();\r\n\r\n if (query != null)\r\n h = 31* h + query.hashCode();\r\n\r\n if (credentials != null)\r\n h = 31* h + credentials.hashCode();\r\n\r\n if (properties != null)\r\n h = 31* h + properties.hashCode();\r\n\r\n // Cache the value until for as long as this instance is not modified\r\n hashCode = h;\r\n }\r\n\r\n return hashCode;\r\n }\r\n}\r\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/GroupedPermissionBits.java",
"content": "package com.mucommander.commons.file;\n\n/**\n * GroupedPermissionBits is an implementation of {@link com.mucommander.commons.file.PermissionBits} using a given UNIX-style\n * permission int: {@link #getIntValue()} returns the specified int, and {@link #getBitValue(int, int)} isolates a\n * specified value.\n *\n * @see com.mucommander.commons.file.IndividualPermissionBits\n * @author Maxence Bernard\n */\npublic class GroupedPermissionBits implements PermissionBits {\n\n /** UNIX-style permission int */\n protected int permissions;\n\n /**\n * Creates a new GroupedPermissionBits using the specified UNIX-style permission int. The int can be created\n * by combining (binary OR and shift) values defined in {@link com.mucommander.commons.file.PermissionTypes} and\n * {@link com.mucommander.commons.file.PermissionAccesses}.\n *\n * @param permissions a UNIX-style permission int.\n */\n public GroupedPermissionBits(int permissions) {\n this.permissions = permissions;\n }\n\n @Override\n public int getIntValue() {\n return permissions;\n }\n\n @Override\n public boolean getBitValue(int access, int type) {\n return (permissions & (type << (access*3))) != 0;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/IndividualPermissionBits.java",
"content": "package com.mucommander.commons.file;\n\n/**\n * IndividualPermissionBits is a partial implementation of {@link com.mucommander.commons.file.PermissionBits} that relies\n * on {@link #getBitValue(int, int)}: the implementation of {@link #getIntValue()} calls getBitValue()\n * sequentially for each permission bit, 9 times in total.\n *\n * @see com.mucommander.commons.file.GroupedPermissionBits\n * @author Maxence Bernard\n */\npublic abstract class IndividualPermissionBits implements PermissionBits {\n\n public IndividualPermissionBits() {\n }\n\n\n @Override\n public int getIntValue() {\n int bitShift = 0;\n int perms = 0;\n\n for(int a=PermissionAccesses.OTHER_ACCESS; a<=PermissionAccesses.USER_ACCESS; a++) {\n for(int p=PermissionTypes.EXECUTE_PERMISSION; p<=PermissionTypes.READ_PERMISSION; p=p<<1) {\n if(getBitValue(a, p))\n perms |= (1<null\n\t * if the type is unknown (unknown or no extension) or if the file is a folder.\n\t *\n\t * @param file the given file\n\t *\n\t * @return the MIME type\n\t */\n\tpublic static String getMimeType(AbstractFile file) {\n\t\tif (file.isDirectory()) {\n\t\t\treturn null;\n\t\t}\n\n\t\tString name = file.getName();\n\t\tint pos = name.lastIndexOf('.');\n\t\tif (pos < 0) {\n\t\t\treturn null;\n\t\t}\n\n\t\treturn MIME_TYPES.get(name.substring(pos+1).toLowerCase());\n\t}\n\n}"
},
{
"path": "src/main/java/com/mucommander/commons/file/MutableFileAttributes.java",
"content": "package com.mucommander.commons.file;\n\n/**\n * This interface extends FileAttributes to add attribute getters. Refer to {@link FileAttributes}'s\n * documentation for more information about attributes.\n *\n * true if the file exists physically on the underlying filesystem\n */\n void setExists(boolean exists);\n\n /**\n * Sets the file's date in milliseconds since the epoch (00:00:00 GMT, January 1, 1970).\n *\n * @param date the file's date in milliseconds since the epoch (00:00:00 GMT, January 1, 1970)\n */\n void setDate(long date);\n\n /**\n * Sets the file's size in bytes.\n *\n * @param size the file's size in bytes\n */\n void setSize(long size);\n\n /**\n * Specifies whether the file is a directory or a regular file.\n *\n * @param directory true for directory, false for regular file\n */\n void setDirectory(boolean directory);\n\n /**\n * Sets the file's permissions.\n *\n * @param permissions the file's permissions\n */\n void setPermissions(FilePermissions permissions);\n\n /**\n * Sets the file's owner.\n *\n * @param owner the file's owner\n */\n void setOwner(String owner);\n\n /**\n * Sets the file's group.\n *\n * @param group the file's owner\n */\n void setGroup(String group);\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/PathCanonizer.java",
"content": "package com.mucommander.commons.file;\n\n/**\n * PathCanonizer is an interface that defines a single {@link #canonize(String)} method that returns the canonical\n * representation of a given path. This interface is used by {@link SchemeParser} implementations to perform\n * scheme-specific path canonization, independently of the actual URL parsing.\n *\n * @see DefaultSchemeParser\n * @author Maxence Bernard\n */\npublic interface PathCanonizer {\n\n /**\n * Returns a canonical representation of the given path.\n *\n * @param path path to canonize\n * @return a canonical representation of the given path.\n */\n String canonize(String path);\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/PermissionAccesses.java",
"content": "package com.mucommander.commons.file;\n\n/**\n * This interface defines constants fields used for designating the three different permission accesses:\n * {@link #USER_ACCESS}, {@link #GROUP_ACCESS} and {@link #OTHER_ACCESS}. Their actual int values represent the number\n * of 3-bit left shifts (<< operator) needed to represent a particular\n * {@link com.mucommander.commons.file.PermissionTypes permission type} in a UNIX-style permission int. To illustrate,\n * the 'read' permission (value = 4) for the 'user' access (value = 2) is represented in a UNIX-style permission int as:\n * 4 << 3*2 = 256 (400 octal).\n *\n * @see com.mucommander.commons.file.PermissionTypes\n * @author Maxence Bernard\n */\npublic interface PermissionAccesses {\n\n /** Designates the 'other' permission access. */\n int OTHER_ACCESS = 0;\n\n /** Designates the 'group' permission access. */\n int GROUP_ACCESS = 1;\n\n /** Designates the 'user' permission access. */\n int USER_ACCESS = 2;\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/PermissionBits.java",
"content": "package com.mucommander.commons.file;\n\n/**\n * This interface provides methods to access file permissions, for every combination of types and accesses defined\n * in {@link com.mucommander.commons.file.PermissionTypes} and {@link com.mucommander.commons.file.PermissionAccesses} respectively.\n * This interface also defines constants for commonly used permission values.\n *\n * \n *
\n *\n * @see com.mucommander.commons.file.GroupedPermissionBits\n * @see com.mucommander.commons.file.IndividualPermissionBits\n * @author Maxence Bernard\n */\npublic interface PermissionBits {\n\n /** read/write/execute permissions set for user/group/other (777 octal) */\n int FULL_PERMISSION_INT = 511;\n\n /** read/write/execute permissions set for user/group/other (777 octal) */\n PermissionBits FULL_PERMISSION_BITS = new GroupedPermissionBits(FULL_PERMISSION_INT);\n\n /** read/write/execute permissions cleared for user/group/other (0) */\n int EMPTY_PERMISSION_INT = 0;\n\n /** read/write/execute permissions cleared for user/group/other (0) */\n PermissionBits EMPTY_PERMISSION_BITS = new GroupedPermissionBits(EMPTY_PERMISSION_INT);\n\n\n /**\n * Returns the value of all the permission bits (9 in total) in a UNIX-style permission int. Each of the permission\n * bits can be isolated by comparing them against the values defined in {@link com.mucommander.commons.file.PermissionTypes}\n * and {@link com.mucommander.commons.file.PermissionAccesses}.\n *\n * @return the value of all the permission bits (9 in total) in a UNIX-style permission int\n */\n int getIntValue();\n\n /**\n * Returns the value of a specific permission bit: getIntValue() method by relying on getBitValue() and querying it sequentially for every\n * permission bit.true if the permission is set, false\n * if it isn't.\n *\n * @param access one of the values defined in {@link com.mucommander.commons.file.PermissionAccesses}\n * @param type one of the values defined in {@link com.mucommander.commons.file.PermissionTypes}\n * @return true if the permission is set, false if it isn't\n */\n boolean getBitValue(int access, int type);\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/PermissionTypes.java",
"content": "package com.mucommander.commons.file;\n\n/**\n * This interface defines constants fields used for designating the three different permission types:\n * {@link #READ_PERMISSION}, {@link #WRITE_PERMISSION} and {@link #EXECUTE_PERMISSION}. Their actual value represent\n * the bit to be set and left-shifted with the desired {@link com.mucommander.commons.file.PermissionAccesses permission access}\n * in a UNIX-style permission int.\n *\n * @see PermissionAccesses\n * @author Maxence Bernard\n */\npublic interface PermissionTypes {\n\n /** Designates the 'execute' permission. */\n int EXECUTE_PERMISSION = 1;\n\n /** Designates the 'write' permission. */\n int WRITE_PERMISSION = 2;\n\n /** Designates the 'read' permission. */\n int READ_PERMISSION = 4;\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/ProtocolFile.java",
"content": "package com.mucommander.commons.file;\n\n/**\n * Super class of all file protocol implementations (by opposition to {@link AbstractArchiveFile archive file} \n * implementations).\n *\n * @see ProtocolProvider\n * @author Maxence Bernard\n */\npublic abstract class ProtocolFile extends AbstractFile {\n\n protected ProtocolFile(FileURL url) {\n super(url);\n }\n \n\n /**\n * This implementation always returns false.\n *\n * @return false, always\n */\n @Override\n public boolean isArchive() {\n return false;\n }\n\n /*@Override\n public boolean canGetReplication() {\n return false;\n }\n\n @Override\n public boolean canGetBlocksize() {\n return false;\n }\n\n @Override\n public short getReplication() {\n return 0;\n }\n\n @Override\n public long getBlocksize() {\n return 0;\n }\n\n @Override\n public void changeReplication(short replication) throws IOException {\n\n }*/\n\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/ProtocolProvider.java",
"content": "package com.mucommander.commons.file;\n\nimport java.io.IOException;\n\n/**\n * This interface allows {@link FileFactory} to instantiate {@link AbstractFile} implementations.\n * AbstractFile that matches the specified URL.\n * @param url URL to map as an AbstractFile.\n * @param instantiationParams file implementation-specific parameters used for instantiating the\n * {@link AbstractFile} implementation. Those parameters are used when creating file instances within\n * the AbstractFile implementation.\n * @return a new instance of AbstractFile that matches the specified URL.\n * @throws IOException if an error occurs.\n */\n AbstractFile getFile(FileURL url, Object... instantiationParams) throws IOException;\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/ROArchiveEntryFile.java",
"content": "package com.mucommander.commons.file;\n\nimport java.io.OutputStream;\n\n/**\n * Represents a file entry inside a read-only archive. Read-only archives are characterized by\n * {@link AbstractArchiveFile#isWritable()} returning false.\n *\n * @see AbstractArchiveFile\n * @see RWArchiveEntryFile\n * @author Maxence Bernard\n */\npublic class ROArchiveEntryFile extends AbstractArchiveEntryFile {\n\n protected ROArchiveEntryFile(FileURL url, AbstractArchiveFile archiveFile, ArchiveEntry entry) {\n super(url, archiveFile, entry);\n }\n\n /**\n * Always throws {@link UnsupportedFileOperationException} when called.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public void setLastModifiedDate(long lastModified) throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.CHANGE_DATE);\n }\n\n /**\n * Always return {@link PermissionBits#EMPTY_PERMISSION_BITS}.\n */\n @Override\n public PermissionBits getChangeablePermissions() {\n return PermissionBits.EMPTY_PERMISSION_BITS;\n }\n\n /**\n * Always throws {@link UnsupportedFileOperationException} when called.\n */\n @Override\n @UnsupportedFileOperation\n public void delete() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.DELETE);\n }\n\n /**\n * Always throws {@link UnsupportedFileOperationException} when called.\n */\n @Override\n @UnsupportedFileOperation\n public void mkdir() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.CREATE_DIRECTORY);\n }\n\n /**\n * Always throws {@link UnsupportedFileOperationException} when called.\n */\n @Override\n @UnsupportedFileOperation\n public OutputStream getOutputStream() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.WRITE_FILE);\n }\n\n /**\n * Always throws {@link UnsupportedFileOperationException} when called.\n */\n @Override\n @UnsupportedFileOperation\n public void changePermissions(int permissions) throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.CHANGE_PERMISSION);\n }\n\n /**\n * Always throws {@link UnsupportedFileOperationException} when called.\n */\n @Override\n @UnsupportedFileOperation\n public void changePermission(int access, int permission, boolean enabled) throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.CHANGE_PERMISSION);\n }\n\n /**\n * Always returns 0.\n */\n @Override\n public long getFreeSpace() {\n return 0;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/RWArchiveEntryFile.java",
"content": "package com.mucommander.commons.file;\n\nimport com.mucommander.commons.io.ByteCounter;\nimport com.mucommander.commons.io.CounterOutputStream;\n\nimport javax.swing.tree.DefaultMutableTreeNode;\nimport java.io.IOException;\nimport java.io.OutputStream;\n\n/**\n * Represents a file entry inside a read-write archive. Read-write archives are characterized by\n * {@link AbstractArchiveFile#isWritable()} returning false.\n *\n * @see AbstractArchiveFile\n * @see ROArchiveEntryFile\n * @author Maxence Bernard\n */\npublic class RWArchiveEntryFile extends AbstractArchiveEntryFile {\n\n RWArchiveEntryFile(FileURL url, AbstractArchiveFile archiveFile, ArchiveEntry entry) {\n super(url, archiveFile, entry);\n }\n\n /**\n * Updates this entry's attributes in the archive and returns true if the update went OK.\n *\n * @return true if the attributes were successfully updated in the archive.\n */\n private boolean updateEntryAttributes() {\n try {\n ((AbstractRWArchiveFile)archiveFile).updateEntry(entry);\n return true;\n }\n catch(IOException e) {\n return false;\n }\n }\n\n\n\n /**\n * @throws IOException if the entry does not exist within the archive\n */\n @Override\n public void setLastModifiedDate(long lastModified) throws IOException {\n if (!entry.exists()) {\n throw new IOException();\n }\n\n long oldDate = entry.getLastModifiedDate();\n entry.setDate(lastModified);\n\n boolean success = updateEntryAttributes();\n if (!success) {\n // restore old date if attributes could not be updated\n entry.setDate(oldDate);\n throw new IOException();\n }\n }\n \n /**\n * Always returns {@link PermissionBits#FULL_PERMISSION_BITS}.\n */\n @Override\n public PermissionBits getChangeablePermissions() {\n // Todo: some writable archive implementations may not have full 'set' permissions support, or even no notion of permissions\n return PermissionBits.FULL_PERMISSION_BITS;\n }\n\n /**\n * Deletes this entry from the associated AbstractArchiveFile.\n * IOException in any of the following\n * cases:\n * \n *
\n *\n * @throws IOException in any of the cases listed above.\n */\n @Override\n public void delete() throws IOException {\n if (!entry.exists()) {\n throw new IOException();\n }\n\n AbstractRWArchiveFile rwArchiveFile = (AbstractRWArchiveFile)archiveFile;\n\n // Throw an IOException if this entry is a non-empty directory\n if (isDirectory()) {\n ArchiveEntryTree tree = rwArchiveFile.getArchiveEntryTree();\n if (tree != null) {\n DefaultMutableTreeNode node = tree.findEntryNode(entry.getPath());\n if (node != null && node.getChildCount() > 0) {\n throw new IOException();\n }\n }\n }\n\n // Delete the entry in the archive file\n rwArchiveFile.deleteEntry(entry);\n\n // Non-existing entries are considered as zero-length regular files\n entry.setDirectory(false);\n entry.setSize(0);\n entry.setExists(false);\n }\n\n /**\n * Creates this entry as a directory in the associated AbstractArchiveFile.\n * IOException if this entry\n * already exists in the archive or if an I/O error occurred.\n *\n * @throws IOException if this entry already exists in the archive or if an I/O error occurred.\n */\n @Override\n public void mkdir() throws IOException {\n if (entry.exists()) {\n throw new IOException();\n }\n\n AbstractRWArchiveFile rwArchivefile = (AbstractRWArchiveFile)archiveFile;\n // Update the ArchiveEntry\n entry.setDirectory(true);\n entry.setDate(System.currentTimeMillis());\n entry.setSize(0);\n\n // Add the entry to the archive file\n rwArchivefile.addEntry(entry);\n\n // The entry now exists\n entry.setExists(true);\n }\n\n /**\n * Returns an OutputStream that allows to write this entry's contents.\n * SchemeHandler is an interface that allows {@link FileURL} to be specialized for a particular scheme.\n * It provides a number of scheme-specific features:\n * \n *
\n * Handler registration
\n * FileURL registers a number of handlers for the schemes/protocols supported by the muCommander file API.\n * Additional handlers can be registered dynamically using {@link FileURL#registerHandler(String, SchemeHandler)}.\n * Likewise, existing handlers can be unregistered or replaced at runtime using\n * {@link FileURL#registerHandler(String, SchemeHandler)} and {@link FileURL#unregisterHandler(String)}.
\n *
\n * FileURL uses a default handler for schemes that do not have a specific handler registered.\n *\n * @see DefaultSchemeHandler\n * @see com.mucommander.commons.file.FileURL#registerHandler(String, SchemeHandler)\n * @see SchemeParser\n * @author Maxence Bernard\n */\npublic interface SchemeHandler {\n\n /**\n * Returns the SchemeParser that turns URL strings of a particular scheme into {@link FileURL} objects.\n *\n * @return the SchemeParser that turns URL strings of a particular scheme into {@link FileURL} objects\n */\n SchemeParser getParser();\n\n /**\n * Returns the authentication realm of the given location, i.e. the base location throughout which a set of\n * credentials can be used. Any property contained by the specified FileURL will be carried over in the returned\n * FileURL. On the contrary, credentials will not be copied, the returned URL always has no credentials. \n *\n * null if the scheme doesn't have any.\n * null if the scheme doesn't have any\n */\n Credentials getGuestCredentials();\n\n /**\n * Returns the type of authentication used by the scheme's file protocol. The returned value is one of the constants\n * defined in {@link AuthenticationType}.\n *\n * @return the type of authentication used by the scheme's file protocol\n */\n AuthenticationType getAuthenticationType();\n\n /**\n * Returns the scheme's path separator, which serves as a delimiter for path fragments. For most schemes, this is\n * the forward slash character.\n *\n * @return this scheme's path separator\n */\n String getPathSeparator();\n\n /**\n * Returns the scheme's standard port, -1 if the scheme doesn't have any. Some file protocols may not\n * have a notion of standard port or even no use for the port part at all, for example those that are not TCP\n * or UDP based such as the local 'file' scheme. \n *\n * @return the scheme's standard port\n */\n int getStandardPort();\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/SchemeParser.java",
"content": "package com.mucommander.commons.file;\n\nimport java.net.MalformedURLException;\n\n/**\n * SchemeParser is an interface that provides a single {@link #parse(String, FileURL)} method used by\n * {@link FileURL#getFileURL(String)} to turn a URL string into a corresponding FileURL instance.\n *\n * @see FileURL#getFileURL(String)\n * @see com.mucommander.commons.file.SchemeHandler\n * @author Maxence Bernard\n */\npublic interface SchemeParser {\n\n /**\n * Extracts the different parts from the given URL string and sets them in the specified FileURL instance.\n * The FileURL is empty when it is passed, with just the handler set. The scheme, host, port, login, password, path,\n * ... parts must all be set, using the corresponding setter methods.\n *\n * padPermission static methods that allows to pad unsupported permission\n * bits with default values.\n *\n * @author Maxence Bernard\n */\npublic class SimpleFilePermissions extends GroupedPermissionBits implements FilePermissions {\n\n /** The permissions mask */\n protected PermissionBits mask;\n\n /**\n * Creates a new SimpleFilePermissions using the specified UNIX-style permission int for permission values and\n * {@link #FULL_PERMISSION_BITS full permissions mask}.\n *\n * @param permissions a UNIX-style permission int that holds permission values.\n */\n public SimpleFilePermissions(int permissions) {\n this(permissions, FULL_PERMISSION_BITS);\n }\n\n /**\n * Creates a new SimpleFilePermissions using the specified UNIX-style permission int values for permission values\n * and mask.\n *\n * @param permissions a UNIX-style permission int that holds permission values.\n * @param mask a UNIX-style permission int which defines which permission bits are supported.\n */\n public SimpleFilePermissions(int permissions, int mask) {\n this(permissions, new GroupedPermissionBits(mask));\n }\n\n /**\n * Creates a new SimpleFilePermissions using the specified UNIX-style permission int and permission mask.\n *\n * @param permissions a UNIX-style permission int that holds permission values.\n * @param mask a permission mask which defines which permission bits are supported.\n */\n public SimpleFilePermissions(int permissions, PermissionBits mask) {\n super(permissions);\n\n this.mask = mask;\n }\n\n\n /**\n * Pads the given permissions with the specified ones: the permission bits that are not supported\n * (as reported by the supplied permissions mask) are replaced by those of the default permissions.\n * That means:
\n * - if the mask indicates that all permission bits are supported (mask = 777 octal), the supplied permissions will\n * simply be returned, without using any of the default permissions
\n * - if the mask indicates that none of the permission bits are supported (mask = 0), the default permissions will\n * be returned, without using any of the supplied permissions
\n *\n * @param permissions the permissions to pad with default permissions for the bits that are not supported\n * @param defaultPermissions permissions to use for the bits that are not supported\n * @return the permissions padded with the default permissions\n */\n public static FilePermissions padPermissions(FilePermissions permissions, FilePermissions defaultPermissions) {\n int permissionMask = permissions.getMask().getIntValue();\n\n return new SimpleFilePermissions((\n permissions.getIntValue() & permissionMask) | (~permissionMask & defaultPermissions.getIntValue()),\n defaultPermissions.getMask());\n }\n\n /**\n * Pads the given permissions with the specified ones: the permission bits that are not supported\n * (as reported by the supplied permissions mask) are replaced by those of the default permissions.\n * That means:
\n * - if the mask indicates that all permission bits are supported (mask = 777 octal), the supplied permissions will\n * simply be returned, without using any of the default permissions
\n * - if the mask indicates that none of the permission bits are supported (mask = 0), the default permissions will\n * be returned, without using any of the supplied permissions
\n *\n * @param permissions the permissions to pad with default permissions for the bits that are not supported\n * @param supportedPermissionsMask the bit mask that indicates which bits of the given permissions are supported\n * @param defaultPermissions permissions to use for the bits that are not supported\n * @return the given permissions padded with the default permissions\n */\n public static int padPermissions(int permissions, int supportedPermissionsMask, int defaultPermissions) {\n return (permissions & supportedPermissionsMask) | (~supportedPermissionsMask & defaultPermissions);\n }\n\n\n @Override\n public PermissionBits getMask() {\n return mask;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/SingleArchiveEntryIterator.java",
"content": "package com.mucommander.commons.file;\n\n/**\n * This class is an implementation of {@link ArchiveEntryIterator} that iterates through a single archive entry\n * specified at creation time. The entry passed to the constructor may be null -- the iterator will\n * act as an empty one. {@link #close()} is implemented as a no-op.\n *\n * @author Maxence Bernard\n */\npublic class SingleArchiveEntryIterator implements ArchiveEntryIterator {\n\n /** The single entry to iterate through */\n protected ArchiveEntry entry;\n\n public SingleArchiveEntryIterator(ArchiveEntry entry) {\n this.entry = entry;\n }\n\n @Override\n public ArchiveEntry nextEntry() {\n if (entry == null) {\n return null;\n }\n\n ArchiveEntry nextEntry = entry;\n entry = null;\n\n return nextEntry;\n }\n\n /**\n * Implemented as a no-op (nothing to close).\n */\n @Override\n public void close() {\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/SyncedFileAttributes.java",
"content": "package com.mucommander.commons.file;\n\n/**\n * SyncedFileAttributes is a FileAttributes implementation which allows attribute values to be automatically\n * updated when accessed after a certain amount of time (the 'time to live') since their last update. The update\n * is performed by the abstract {@link #updateAttributes()} method and is triggered by any of the attribute getters.\n * A typical usage for this class is for remote file systems that need to keep file attributes in sync with a server,\n * {@link #updateAttributes()} can retrieve a fresh copy of the attributes on the server.\n *\n * true, attributes are automatically updated\n */\n public SyncedFileAttributes(long ttl, boolean updateAttributesNow) {\n setTtl(ttl); // also sets the expiration date\n\n if (updateAttributesNow) {\n checkForExpiration(true); // force attributes update\n }\n }\n\n /**\n * Returns the attributes' 'time to live', i.e. the amount of time since the last update after which attributes will\n * be automatically updated when any of the getter method is called.\n *\n * @return the attributes' 'time to live', in milliseconds\n */\n public long getTtl() {\n return ttl;\n }\n\n /**\n * Sets the attributes' 'time to live', i.e. the amount of time since the last update after which attributes will\n * be automatically updated when any of the getter method is called.\n * Note that setting the 'time to live' causes the expiration date to be updated with {@link #updateExpirationDate()}.\n *\n * @param ttl the attributes' 'time to live', in milliseconds\n */\n public void setTtl(long ttl) {\n this.ttl = ttl;\n\n // update the expiration date\n updateExpirationDate();\n }\n\n /**\n * Returns the attributes' expiration timestamp/date, the date after which attributes values will be automatically\n * updated when any of the getter method is called.\n *\n * @return the attributes' expiration timestamp/date\n */\n public long getExpirationDate() {\n return expirationDate;\n }\n\n /**\n * Sets the attributes' expiration timestamp/date, the date after which attributes values will be automatically\n * updated when they are accessed using any of the getter methods.\n *\n * @param expirationDate the attributes expiration timestamp/date\n */\n public void setExpirationDate(long expirationDate) {\n this.expirationDate = expirationDate;\n }\n\n /**\n * Updates the attributes' expiration date to 'now' + 'ttl' (as returned by {@link #getTtl()}).\n * This method is called after attributes have been automatically updated. It can also be called after attribute\n * values have been manually updated using the setter methods.\n */\n public void updateExpirationDate() {\n setExpirationDate(ttl < 0 ? Long.MAX_VALUE : System.currentTimeMillis() + getTtl());\n }\n\n /**\n * Returns true if attributes have expired, i.e. the {@link #getExpirationDate()} expiration date has\n * passed, false if attributes are still 'fresh'. This method also returns false if\n * automatic attributes' update has been disabled ('time to live' set to a negative value), or if attributes are\n * currently being updated.\n * \n * @return true if attributes have expired\n */\n public boolean hasExpired() {\n return ttl>=0 // prevents automatic updates if ttl is set to a negative value\n && !isUpdating() // causes getters to return the current value while attributes are being updated\n && System.currentTimeMillis()>expirationDate;\n }\n\n /**\n * Returns true if attributes are currently being updated.\n *\n * @return true if attributes are currently being updated\n */\n private synchronized boolean isUpdating() {\n return isUpdating;\n }\n\n /**\n * Sets whether attributes are currently being updated.\n *\n * @param isUpdating true if attributes are currently being updated\n */\n private synchronized void setUpdating(boolean isUpdating) {\n this.isUpdating = isUpdating;\n }\n\n /**\n * Checks if the attributes have expired and if they have, calls {@link #updateAttributes()} to refresh their\n * values.\n *\n * @param forceUpdate if true, attributes will systematically be updated, without checking the expiration date\n */\n protected void checkForExpiration(boolean forceUpdate) {\n if (forceUpdate || hasExpired()) {\n // After this method is called, hasExpired() returns false so that implementations of updateAttributes()\n // can query attribute getters without entering a loop of death.\n setUpdating(true);\n\n // Updates attribute values\n updateAttributes();\n\n // Update expiration date after the attribute have actually been updated, note that it may take a while\n // for remote file protocols to retrieve attributes.\n updateExpirationDate();\n\n // OK we're done\n setUpdating(false);\n }\n }\n\n\n ////////////////////////\n // Overridden methods //\n ////////////////////////\n\n /**\n * Overridden to trigger attributes update if the expiration date has been reached.\n */\n @Override\n public String getPath() {\n checkForExpiration(false);\n\n return super.getPath();\n }\n\n /**\n * Overridden to trigger attributes update if the expiration date has been reached.\n */\n @Override\n public boolean exists() {\n checkForExpiration(false);\n\n return super.exists();\n }\n\n /**\n * Overridden to trigger attributes update if the expiration date has been reached.\n */\n @Override\n public long getLastModifiedDate() {\n checkForExpiration(false);\n\n return super.getLastModifiedDate();\n }\n\n /**\n * Overridden to trigger attributes update if the expiration date has been reached.\n */\n @Override\n public long getSize() {\n checkForExpiration(false);\n\n return super.getSize();\n }\n\n /**\n * Overridden to trigger attributes update if the expiration date has been reached.\n */\n @Override\n public boolean isDirectory() {\n checkForExpiration(false);\n\n return super.isDirectory();\n }\n\n /**\n * Overridden to trigger attributes update if the expiration date has been reached.\n */\n @Override\n public FilePermissions getPermissions() {\n checkForExpiration(false);\n\n return super.getPermissions();\n }\n\n /**\n * Overridden to trigger attributes update if the expiration date has been reached.\n */\n @Override\n public String getOwner() {\n checkForExpiration(false);\n\n return super.getOwner();\n }\n\n /**\n * Overridden to trigger attributes update if the expiration date has been reached.\n */\n @Override\n public String getGroup() {\n checkForExpiration(false);\n\n return super.getGroup();\n }\n\n /**\n * Overridden to trigger attributes update if the expiration date has been reached.\n */\n @Override\n public short getReplication() {\n checkForExpiration(false);\n\n return super.getReplication();\n }\n\n /**\n * Overridden to trigger attributes update if the expiration date has been reached.\n */\n @Override\n public long getBlockSize() {\n checkForExpiration(false);\n\n return super.getBlockSize();\n }\n\n\n //////////////////////\n // Abstract methods //\n //////////////////////\n\n /**\n * Updates the attribute values. This method is automatically called when attributes are expired and one of the\n * attribute getters is called. The implementation may choose to update only certain attributes, or skip updates\n * under certain conditions.\n */\n public abstract void updateAttributes();\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/UnsupportedFileOperation.java",
"content": "package com.mucommander.commons.file;\n\nimport java.lang.annotation.*;\n\n/**\n * @author Maxence Bernard\n */\n@Target(ElementType.METHOD)\n@Retention(RetentionPolicy.RUNTIME)\n@Documented\npublic @interface UnsupportedFileOperation {\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/UnsupportedFileOperationException.java",
"content": "package com.mucommander.commons.file;\n\nimport java.io.IOException;\n\n/**\n * This exception can be thrown by certain {@link AbstractFile} methods, when the corresponding operation\n * is not available, either because the underlying file protocol does not support it, or because it is not\n * implemented. This exception may also be thrown by file operations that depend on another file operation that is\n * not supported.\n *
\n * Unlike java.lang.UnsupportedOperationException, this exception is not a\n * RuntimeException and must therefore be caught explicitly.\n *\n * AbstractFile method that throws this exception once must throw it\n * always, for any file instance.\n *\n * @author Maxence Bernard\n * @see UnsupportedFileOperation\n * @see AbstractFile\n */\npublic class UnsupportedFileOperationException extends IOException {\n\n /** The {@link FileOperation} this exception refers to */\n private final FileOperation op;\n\n /**\n * Creates a new UnsupportedFileOperationException corresponding to the specified {@link FileOperation}.\n *\n * @param op the {@link FileOperation} this exception refers to.\n */\n public UnsupportedFileOperationException(FileOperation op) {\n super();\n\n this.op = op;\n }\n\n /**\n * Creates a new UnsupportedFileOperationException corresponding to the specified {@link FileOperation}\n * with a custom message.\n *\n * @param op the {@link FileOperation} this exception refers to.\n * @param message a message describing the exception cause.\n */\n public UnsupportedFileOperationException(FileOperation op, String message) {\n super(message);\n\n this.op = op;\n }\n\n /**\n * Returns the {@link FileOperation} this exception refers to.\n *\n * @return the {@link FileOperation} this exception refers to.\n */\n public FileOperation getFileOperation() {\n return op;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/WrapperArchiveEntryIterator.java",
"content": "package com.mucommander.commons.file;\n\nimport java.io.IOException;\nimport java.util.Iterator;\n\n/**\n * This class wraps a java.util.Iterator and implements ArchiveEntryIterator by\n * delegating methods to their java.util.Iterator equivalent. {@link #close()} is implemented as a no-op.\n *\n * @author Maxence Bernard\n */\npublic class WrapperArchiveEntryIterator implements ArchiveEntryIterator {\n\n /** Wrapped iterator */\n protected Iterator iterator;\n\n /**\n * Creates a new WrapperArchiveEntryIterator that iterates through the given\n * java.util.Iterator's elements.\n *\n * @param iterator the wrapped iterator\n */\n public WrapperArchiveEntryIterator(Iterator iterator) {\n this.iterator = iterator;\n }\n\n\n @Override\n public ArchiveEntry nextEntry() {\n return iterator.hasNext() ? iterator.next() : null;\n }\n\n /**\n * Implemented as a no-op (nothing to close).\n */\n @Override\n public void close() throws IOException {\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/archiver/ArchiveFormat.java",
"content": "/*\n * This file is part of trolCommander, http://www.trolsoft.ru/en/soft/trolcommander\n * Copyright (C) 2013-2017 Oleg Trifonov\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see getArchiver methods can be used to retrieve an Archiver\n * instance for a specified archive format. A list of available archive formats can be dynamically retrieved\n * using {@link #getFormats(boolean) getFormats}.\n *\n * \n *
\n *\n * @author Maxence Bernard\n */\npublic abstract class Archiver {\n\n\n /** The underlying stream this archiver is writing to */\n protected OutputStream out;\n /** Archive format of this Archiver */\n protected ArchiveFormat format;\n /** Support output stream for archiving files */\n boolean supportStream;\n\t\n /**\n * Creates a new Archiver.\n *\n * @param out the OutputStream this Archiver will write to\n */\n Archiver(OutputStream out) {\n this.out = out;\n this.supportStream = true;\n }\n\n /**\n * Returns the OutputStream this Archiver is writing to.\n *\n * @return the OutputStream this Archiver is writing to\n */\n public OutputStream getOutputStream() {\n return out;\n }\n\n \n /**\n * Returns the archiver format used by this Archiver. See format constants.\n * @return archiver format code\n */\n public ArchiveFormat getFormat() {\n return this.format;\n }\n\t\n /**\n * Sets the archiver format used by this Archiver, for internal use only.\n */\n private void setFormat(ArchiveFormat format) {\n this.format = format;\n }\n\t\n\n /**\n * Checks if the format used by this Archiver can store an optional comment.\n * @return true if the format used by this Archiver can store an optional comment.\n */\n public boolean supportsComment() {\n return formatSupportsComment(this.format);\n }\n\n /**\n * @return true if the archiver supports writing with streams\n */\n public boolean supportsStream() {\n return supportStream;\n }\n\n /**\n * Sets an optional comment in the archive, the {@link #supportsComment()} or\n * {@link #formatSupportsComment(ArchiveFormat)} must first be called to make sure\n * the archive format supports comment, otherwise calling this method will have no effect.\n *\n * \n *
\n *\n * @param entryPath\n\t * @param isDirectory\n\t *\n\t * @return normalized path\n */\n String normalizePath(String entryPath, boolean isDirectory) {\n // Replace any \\ character by /\n entryPath = entryPath.replace('\\\\', '/');\n\t\t\n // If entry is a directory, make sure the path contains a trailing / \n if (isDirectory && !entryPath.endsWith(\"/\"))\n entryPath += \"/\";\n\t\t\n return entryPath;\n }\n\n\n ////////////////////\n // Static methods //\n ////////////////////\n\n /**\n * Returns an Archiver for the specified format and that uses the given {@link AbstractFile} to write entries to.\n * null is returned if the specified format is not valid.\n *\n * OutputStream. Note that if the file exists, its contents\n * will be overwritten. Write bufferring is used under the hood to improve performance.\n *\n * @param file the AbstractFile which the returned Archiver will write entries to\n * @param format an archive format\n * @return an Archiver for the specified format and that uses the given {@link AbstractFile} to write entries to ;\n * null if the specified format is not valid.\n * @throws IOException if the file cannot be opened for write, or if an error occurred while intializing the archiver\n * @throws UnsupportedFileOperationException if the underlying filesystem does not support write operations\n */\n public static Archiver getArchiver(AbstractFile file, ArchiveFormat format) throws IOException, UnsupportedFileOperationException {\n// switch(format) {\n// case ISO:\n// return new ISOArchiver(file);\n// }\n OutputStream out = null;\n\n if (file.isFileOperationSupported(FileOperation.RANDOM_WRITE_FILE)) {\n try {\n // Important: if the file exists, it has to be overwritten as AbstractFile#getRandomAccessOutputStream()\n // does NOT overwrite the file. This fixes bug #30.\n if (file.exists()) {\n file.delete();\n }\n out = new BufferedRandomOutputStream(file.getRandomAccessOutputStream());\n } catch (IOException e) {\n // Fall back to a regular OutputStream\n }\n }\n\n if (out == null) {\n out = new BufferedOutputStream(file.getOutputStream());\n }\n\n return getArchiver(out, format);\n }\n\n\n /**\n * Returns an Archiver for the specified format and that uses the given OutputStream to write entries to.\n * null is returned if the specified format is not valid. Whenever possible, a\n * {@link RandomAccessOutputStream} should be supplied as some formats take advantage of having a random write access.\n *\n * @param out the OutputStream which the returned Archiver will write entries to\n * @param format an archive format\n * @return an Archiver for the specified format and that uses the given {@link AbstractFile} to write entries to ;\n * null if the specified format is not valid.\n * @throws IOException if an error occurred while initializing the archiver\n */\n private static Archiver getArchiver(OutputStream out, ArchiveFormat format) throws IOException {\n Archiver archiver;\n\n switch (format) {\n case ZIP:\n archiver = new ZipArchiver(out);\n break;\n case GZ:\n archiver = new SingleFileArchiver(new GZIPOutputStream(out));\n break;\n case BZ2:\n archiver = new SingleFileArchiver(createBzip2OutputStream(out));\n break;\n case TAR:\n archiver = new TarArchiver(out);\n break;\n case TAR_GZ:\n archiver = new TarArchiver(new GZIPOutputStream(out));\n break;\n case TAR_BZ2:\n archiver = new TarArchiver(createBzip2OutputStream(out));\n break;\n// case ISO:\n// throw new IllegalStateException(\"ISO archiving not supported by stream\");\n\n default:\n return null;\n }\n\t\t\n archiver.setFormat(format);\n\n return archiver;\n }\n\n /**\n * Creates and returns a Bzip2 OutputStream using the given OutputStream as the underlying\n * stream.\n *\n * @param out the underlying stream\n * @return a Bzip2 OutputStream\n * @throws IOException if an error occurred while initializing the Bzip2 OutputStream\n */\n private static OutputStream createBzip2OutputStream(OutputStream out) throws IOException {\n // Writes the 2 magic bytes 'BZ', as required by CBZip2OutputStream. A quote from CBZip2OutputStream's Javadoc:\n // \"Attention: The caller is responsible to write the two BZip2 magic bytes \"BZ\" to the specified stream\n // prior to calling this constructor.\"\n\n out.write('B');\n out.write('Z');\n\n return new CBZip2OutputStream(out);\n }\n\n\n /**\n * Returns an array of available archive formats, single entry formats or many entries formats\n * depending on the value of the specified boolean parameter. \n *\n * @param manyEntries if true, a list of many entries formats (a subset of single entry formats) will be returned\n * @return an array of available archive formats\n */\n public static ArchiveFormat[] getFormats(boolean manyEntries) {\n if (!manyEntries) {\n return ArchiveFormat.values();\n }\n int cnt = 0;\n for (ArchiveFormat af : ArchiveFormat.values()) {\n if (af.supportManyEntries) {\n cnt++;\n }\n }\n ArchiveFormat[] result = new ArchiveFormat[cnt];\n int i = 0;\n for (ArchiveFormat af : ArchiveFormat.values()) {\n if (af.supportManyEntries) {\n result[i++] = af;\n }\n }\n return result;\n }\n\n\n /**\n * Returns true if the specified archive format can store an optional comment.\n *\n * @param format an archive format\n * @return true if the specified archive format can store an optional comment\n */\n public static boolean formatSupportsComment(ArchiveFormat format) {\n return format == ArchiveFormat.ZIP;\n }\n\t\n\t\n //////////////////////\n // Abstract methods //\n //////////////////////\n\n /**\n * Creates a new entry in the archive using the given relative path and file attributes, and returns an\n * OutputStream to write the entry's contents. The specified file attributes are used to determine\n * whether the entry is a directory or a regular file, and to set the entry's size, permissions and date.\n * \n * null otherwise. The OutputStream must not be closed once\n * it has been used (Archiver takes care of this), only the {@link #close() close} method has to be called when\n * all entries have been created.\n *\n * OutputStream to write the entry's contents.\n * @throws IOException if this Archiver failed to write the entry, or in the case of a single entry archiver, if\n * this method was called more than once.\n */\n public abstract OutputStream createEntry(String entryPath, FileAttributes attributes) throws IOException;\n\n\n /**\n * @return Name of current file being processed\n */\n public String getProcessingFile() {\n return null;\n }\n \n /**\n * Written bytes in total without the current file progress\n * @return number of bytes written as a long\n */\n public long totalWrittenBytes() {\n return -1;\n }\n \n /**\n * Written bytes to the current file being processed, will be the same size as the\n * file if complete.\n * @return number of bytes written as a long\n */\n public long writtenBytesCurrentFile() {\n return -1;\n }\n \n /**\n * @return Size of the current file being processed in bytes\n */\n public long currentFileLength() {\n return -1;\n }\n \n /**\n * Finish the archiving process when all files have been added.\n */\n public abstract void postProcess() throws IOException;\n \n /**\n * Closes the underlying OuputStream and ressources used by this Archiver to write the archive. This method\n * must be called when all entries have been added to the archive.\n */\n public abstract void close() throws IOException;\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/archiver/ISOArchiver.java",
"content": "package com.mucommander.commons.file.archiver;\n\nimport com.github.stephenc.javaisotools.eltorito.impl.ElToritoConfig;\nimport com.github.stephenc.javaisotools.iso9660.ConfigException;\nimport com.github.stephenc.javaisotools.iso9660.ISO9660Directory;\nimport com.github.stephenc.javaisotools.iso9660.ISO9660File;\nimport com.github.stephenc.javaisotools.iso9660.ISO9660RootDirectory;\nimport com.github.stephenc.javaisotools.iso9660.impl.ISO9660Config;\nimport com.github.stephenc.javaisotools.iso9660.impl.ISOImageFileHandler;\nimport com.github.stephenc.javaisotools.joliet.impl.JolietConfig;\nimport com.github.stephenc.javaisotools.rockridge.impl.RockRidgeConfig;\nimport com.github.stephenc.javaisotools.sabre.HandlerException;\nimport com.github.stephenc.javaisotools.sabre.StreamHandler;\nimport com.mucommander.commons.file.AbstractFile;\nimport com.mucommander.commons.file.FileAttributes;\nimport com.mucommander.commons.file.impl.iso.MuCreateISO;\nimport java.io.File;\nimport java.io.FileNotFoundException;\nimport java.io.IOException;\nimport java.io.OutputStream;\nimport java.util.logging.Level;\nimport java.util.logging.Logger;\n\n/**\n * Archiver implementation using the ISO9660 archive format.\n *\n * @author Jeppe Vennekilde\n */\npublic class ISOArchiver extends Archiver {\n private StreamHandler streamHandler;\n private final ISO9660Config config;\n private final ISO9660RootDirectory root;\n //Adds support for longer file names & wider range of characters\n private final boolean enableJoliet = true;\n //Adds support for deeper directory hierarchies and even bigger file names (up to 255 bytes)\n private final boolean enableRockRidge = true;\n //Adds support for creation of bootable iso files (not implemented)\n private final boolean enableElTorito = false;\n private MuCreateISO createISOProcess = null;\n\n ISOArchiver(AbstractFile file) {\n super(null);\n supportStream = false;\n \n config = new ISO9660Config();\n try {\n config.allowASCII(false);\n config.setInterchangeLevel(1);\n //The rock ridge extension of ISO9660 allow directory depth to exceed 8\n config.restrictDirDepthTo8(!enableRockRidge);\n config.setPublisher(System.getProperty(\"user.name\"));\n //Max length of volume is 32 chars\n config.setVolumeID(file.getName().substring(0, Math.min(file.getName().length(), 31)));\n config.setDataPreparer(System.getProperty(\"user.name\"));\n config.forceDotDelimiter(true);\n } catch (ConfigException ex) {\n Logger.getLogger(ISOArchiver.class.getName()).log(Level.SEVERE, null, ex);\n }\n \n root = new ISO9660RootDirectory();\n \n try {\n streamHandler = new ISOImageFileHandler(new File(file.getPath()));\n } catch (FileNotFoundException ex) {\n Logger.getLogger(ISOArchiver.class.getName()).log(Level.SEVERE, null, ex);\n }\n }\n\n\n @Override\n public OutputStream createEntry(String entryPath, FileAttributes attributes) {\n try {\n if (attributes.isDirectory()) {\n String[] split = entryPath.split(\"\\\\\\\\\");\n ISO9660Directory dir = new ISO9660Directory(split[split.length-1]);\n ISO9660Directory parent = getParentDirectory(entryPath);\n if (parent != null) {\n parent.addDirectory(dir);\n }\n } else {\n try {\n ISO9660File file = new ISO9660File(new File(attributes.getPath()));\n ISO9660Directory parent = getParentDirectory(entryPath);\n if (parent != null) {\n parent.addFile(file);\n }\n } catch (HandlerException ex) {\n Logger.getLogger(ISOArchiver.class.getName()).log(Level.SEVERE, null, ex);\n }\n }\n } catch (RuntimeException e) {\n e.printStackTrace();\n throw e;\n }\n return null; // TODO !!!! NPE here !!!\n }\n \n /**\n * Get the ISO9660Directory parent object the path belongs to\n *\n * @param isoPath the sub directory/file of the parent directory it will return\n * @return an ISO9660Directory that is the parent of the provided path\n */\n private ISO9660Directory getParentDirectory(String isoPath){\n String[] directories = isoPath.split(\"\\\\\\\\\");\n //Initial directory (root)\n ISO9660Directory parent = root;\n for (int i = 0; i < directories.length - 1; i++){\n ISO9660Directory dir = containsDirectory(parent,directories[i]);\n if (dir == null) {\n return null;\n }\n parent = dir;\n }\n return parent;\n }\n \n /**\n * Check if an ISO9660Directory contain a provided sub directory\n *\n * @param parentDirectory the directory that will be searched\n * @param isoSubDirPath the ISO path that will be used for reference to see \n * if the parent directory contains the sub directory\n * @return an ISO9660Directory that is sub directory of the parent directory\n * null if it does not contain the sub directory\n */\n private ISO9660Directory containsDirectory(ISO9660Directory parentDirectory, String isoSubDirPath){\n for (ISO9660Directory directory : parentDirectory.getDirectories()) {\n if (directory.getName().equals(isoSubDirPath)){\n return directory;\n }\n }\n return null;\n }\n\n @Override\n public String getProcessingFile() {\n return createISOProcess != null ? createISOProcess.getProcessingFile() : null;\n }\n \n @Override\n public long totalWrittenBytes(){\n return createISOProcess != null ? createISOProcess.totalWrittenBytes(): 0;\n }\n \n @Override\n public long writtenBytesCurrentFile(){\n return createISOProcess != null ? createISOProcess.writtenBytesCurrentFile(): 0;\n }\n \n @Override\n public long currentFileLength(){\n return createISOProcess != null ? createISOProcess.currentFileLength(): 0;\n }\n \n @Override\n public void postProcess() throws IOException {\n if (root.hasSubDirs() || !root.getFiles().isEmpty()) {\n createISOProcess = new MuCreateISO(streamHandler, root);\n\n RockRidgeConfig rrConfig = null;\n if (enableRockRidge) {\n // Rock Ridge support\n rrConfig = new RockRidgeConfig();\n rrConfig.setMkisofsCompatibility(false);\n rrConfig.hideMovedDirectoriesStore(true);\n rrConfig.forcePortableFilenameCharacterSet(true);\n }\n\n JolietConfig jolietConfig = null;\n if (enableJoliet) {\n // Joliet support\n jolietConfig = new JolietConfig();\n try {\n if (config.getPublisher() instanceof String){\n jolietConfig.setPublisher((String) config.getPublisher());\n } else {\n try {\n jolietConfig.setPublisher((File) config.getPublisher());\n } catch (HandlerException ex) {\n Logger.getLogger(ISOArchiver.class.getName()).log(Level.SEVERE, null, ex);\n }\n } \n //Max volume id is 16 in the joliet config\n jolietConfig.setVolumeID(config.getVolumeID().substring(0,Math.min(config.getVolumeID().length(), 15)));\n if (config.getDataPreparer() != null){\n if(config.getDataPreparer() instanceof String){\n jolietConfig.setDataPreparer((String) config.getDataPreparer());\n } else {\n try {\n jolietConfig.setDataPreparer((File) config.getDataPreparer());\n } catch (Exception ex) {\n Logger.getLogger(ISOArchiver.class.getName()).log(Level.SEVERE, null, ex);\n }\n } \n }\n jolietConfig.forceDotDelimiter(true);\n } catch (ConfigException ex) {\n Logger.getLogger(ISOArchiver.class.getName()).log(Level.SEVERE, null, ex);\n }\n }\n\n //ELTorito adds support for bootable ISO files, which is not supported at this time\n //As this is for archiving, not creation of bootable ISO files (yet)\n ElToritoConfig elToritoConfig = null;\n\n try {\n createISOProcess.process(config, rrConfig, jolietConfig, elToritoConfig);\n } catch (HandlerException ex) {\n Logger.getLogger(ISOArchiver.class.getName()).log(Level.SEVERE, null, ex);\n }\n }\n }\n\n @Override\n public void close() throws IOException {\n }\n \n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/archiver/SingleFileArchiver.java",
"content": "package com.mucommander.commons.file.archiver;\n\nimport com.mucommander.commons.file.FileAttributes;\n\nimport java.io.IOException;\nimport java.io.OutputStream;\n\n\n/**\n * Generic single file Archiver.\n *\n * @author Maxence Bernard\n */\nclass SingleFileArchiver extends Archiver {\n\n private boolean firstEntry = true;\n\n\n SingleFileArchiver(OutputStream outputStream) {\n super(outputStream);\n }\n\n\n /**\n * This method is a no-op, and does nothing but throw an IOException if it is called more than once,\n * which should never be the case as this Archiver is only meant to store one file. \n */\n @Override\n public OutputStream createEntry(String entryPath, FileAttributes attributes) throws IOException {\n if (firstEntry) {\n firstEntry = false;\n } else {\n throw new IOException();\n }\n\n return out;\n }\n\t\n\t\n @Override\n public void close() throws IOException {\n out.close();\n }\n\n @Override\n public void postProcess() {}\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/archiver/TarArchiver.java",
"content": "package com.mucommander.commons.file.archiver;\n\nimport com.mucommander.commons.file.FileAttributes;\nimport com.mucommander.commons.file.FilePermissions;\nimport com.mucommander.commons.file.SimpleFilePermissions;\nimport com.mucommander.commons.file.impl.tar.provider.TarEntry;\nimport com.mucommander.commons.file.impl.tar.provider.TarOutputStream;\n\nimport java.io.IOException;\nimport java.io.OutputStream;\n\n\n/**\n * Archiver implementation using the Tar archive format.\n *\n * @author Maxence Bernard\n */\nclass TarArchiver extends Archiver {\n\n private final TarOutputStream tos;\n private boolean firstEntry = true;\n\n TarArchiver(OutputStream outputStream) {\n super(outputStream);\n\n this.tos = new TarOutputStream(outputStream);\n // Specifies how to handle files which filename is > 100 chars (default is to fail!)\n this.tos.setLongFileMode(TarOutputStream.LONGFILE_GNU);\n }\n\n\n\n @Override\n public OutputStream createEntry(String entryPath, FileAttributes attributes) throws IOException {\n // Start by closing current entry\n if (!firstEntry) {\n tos.closeEntry();\n }\n\n boolean isDirectory = attributes.isDirectory();\n\t\t\n // create the entry\n TarEntry entry = new TarEntry(normalizePath(entryPath, isDirectory));\n // Use provided file's size (required by TarOutputStream) and date\n long size = attributes.getSize();\n if (!isDirectory && size >= 0)\t\t// Do not set size if file is directory or file size is unknown!\n entry.setSize(size);\n\n // Set the entry's date and permissions\n entry.setModTime(attributes.getLastModifiedDate());\n entry.setMode(SimpleFilePermissions.padPermissions(attributes.getPermissions(), isDirectory\n ? FilePermissions.DEFAULT_DIRECTORY_PERMISSIONS\n : FilePermissions.DEFAULT_FILE_PERMISSIONS).getIntValue());\n\n // Add the entry\n tos.putNextEntry(entry);\n\n if (firstEntry) {\n firstEntry = false;\n }\n\t\n // Return the OutputStream that allows to write to the entry, only if it isn't a directory \n return isDirectory ? null : tos;\n }\n\n\n @Override\n public void close() throws IOException {\n // Close current entry\n if (!firstEntry) {\n tos.closeEntry();\n }\n\t\t\n tos.close();\n }\n \n @Override\n public void postProcess() {}\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/archiver/ZipArchiver.java",
"content": "package com.mucommander.commons.file.archiver;\n\nimport com.mucommander.commons.file.FileAttributes;\nimport com.mucommander.commons.file.FilePermissions;\nimport com.mucommander.commons.file.SimpleFilePermissions;\nimport com.mucommander.commons.file.impl.zip.provider.ZipEntry;\nimport com.mucommander.commons.file.impl.zip.provider.ZipOutputStream;\nimport java.io.IOException;\nimport java.io.OutputStream;\n\n\n/**\n * Archiver implementation using the Zip archive format.\n *\n * @author Maxence Bernard\n */\nclass ZipArchiver extends Archiver {\n\n private final ZipOutputStream zos;\n private boolean firstEntry = true;\n\n\n\n ZipArchiver(OutputStream outputStream) {\n super(outputStream);\n\n this.zos = new ZipOutputStream(outputStream);\n }\n\n\n /**\n * Overrides Archiver's no-op setComment method as Zip supports archive comment.\n */\n @Override\n public void setComment(String comment) {\n zos.setComment(comment);\n } \n\t\n\n\n @Override\n public OutputStream createEntry(String entryPath, FileAttributes attributes) throws IOException {\n // Start by closing current entry\n if (!firstEntry) {\n zos.closeEntry();\n }\n\n boolean isDirectory = attributes.isDirectory();\n\t\t\n // Create the entry and use the provided file's date\n ZipEntry entry = new ZipEntry(normalizePath(entryPath, isDirectory));\n // Use provided file's size and date\n long size = attributes.getSize();\n if (!isDirectory && size >= 0) { // Do not set size if file is directory or file size is unknown!\n entry.setSize(size);\n }\n\n entry.setTime(attributes.getLastModifiedDate());\n entry.setUnixMode(SimpleFilePermissions.padPermissions(attributes.getPermissions(), isDirectory\n ? FilePermissions.DEFAULT_DIRECTORY_PERMISSIONS\n : FilePermissions.DEFAULT_FILE_PERMISSIONS).getIntValue());\n\n // Add the entry\n zos.putNextEntry(entry);\n\n if (firstEntry) {\n firstEntry = false;\n }\n\t\t\n // Return the OutputStream that allows to write to the entry, only if it isn't a directory \n return isDirectory ? null : zos;\n }\n\n\n @Override\n public void close() throws IOException {\n zos.close();\n }\n \n @Override\n public void postProcess() {}\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/compat/CompatURLConnection.java",
"content": "package com.mucommander.commons.file.compat;\n\nimport com.mucommander.commons.file.AbstractFile;\nimport com.mucommander.commons.file.FileFactory;\n\nimport java.io.IOException;\nimport java.io.InputStream;\nimport java.io.OutputStream;\nimport java.net.URL;\nimport java.net.URLConnection;\n\n/**\n * @author Maxence Bernard\n*/\nclass CompatURLConnection extends URLConnection {\n\n protected AbstractFile file;\n\n public CompatURLConnection(URL url) {\n super(url);\n\n // Not connected yet\n }\n\n public CompatURLConnection(URL url, AbstractFile file) {\n super(url);\n\n if(file!=null) {\n this.file = file;\n connected = true;\n }\n }\n\n /**\n * Checks if this URLConnection is connected and if it isn't, calls {@link #connect()} to connect it.\n *\n * @throws IOException if an error occurred while connecting this URLConnection\n */\n private void checkConnected() throws IOException {\n if(!connected)\n connect();\n }\n\n\n /**\n * Creates the {@link AbstractFile} instance corresponding to the URL location, only if no AbstractFile\n * has been specified when this CompatURLConnection was created.\n *\n * @throws IOException if an error occurred while instanciating the AbstractFile\n */\n @Override\n public void connect() throws IOException {\n if (!connected) {\n file = FileFactory.getFile(url.toString(), true);\n connected = true;\n }\n }\n\n\n @Override\n public InputStream getInputStream() throws IOException {\n checkConnected();\n return file.getInputStream();\n }\n\n @Override\n public OutputStream getOutputStream() throws IOException {\n checkConnected();\n return file.getOutputStream();\n }\n\n @Override\n public long getLastModified() {\n try {\n checkConnected();\n return file.getLastModifiedDate();\n } catch(IOException e) {\n return 0;\n }\n }\n\n @Override\n public long getDate() {\n return getLastModified();\n }\n\n @Override\n public int getContentLength() {\n try {\n checkConnected();\n return (int)file.getSize();\n } catch(IOException e) {\n return -1;\n }\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/compat/CompatURLStreamHandler.java",
"content": "package com.mucommander.commons.file.compat;\n\nimport com.mucommander.commons.file.AbstractFile;\n\nimport java.io.IOException;\nimport java.net.URL;\nimport java.net.URLConnection;\nimport java.net.URLStreamHandler;\n\n\n/**\n * @author Maxence Bernard\n */\npublic class CompatURLStreamHandler extends URLStreamHandler {\n\n protected AbstractFile file;\n\n public CompatURLStreamHandler() {\n }\n\n public CompatURLStreamHandler(AbstractFile file) {\n this.file = file;\n }\n\n\n @Override\n protected URLConnection openConnection(URL url) throws IOException {\n return new CompatURLConnection(url, file); // Note: file may be null\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/connection/ConnectionHandler.java",
"content": "package com.mucommander.commons.file.connection;\n\nimport com.mucommander.commons.file.AuthException;\nimport com.mucommander.commons.file.Credentials;\nimport com.mucommander.commons.file.FileURL;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\nimport java.io.IOException;\n\n/**\n * ConnectionHandler is a an abstract class that provides the basic operations for to interact with a server: establish\n * the connection, keep it alive and close it.\n *\n * @see com.mucommander.commons.file.connection.ConnectionPool\n * @author Maxence Bernard\n */\npublic abstract class ConnectionHandler {\n private static final Logger LOGGER = LoggerFactory.getLogger(ConnectionHandler.class);\n\n /** URL of the server this ConnectionHandler connects to */\n protected FileURL realm;\n\n /** Credentials that are used to connect to the server */\n protected Credentials credentials;\n\n /** True if this ConnectionHandler is currently locked */\n protected boolean isLocked;\n\n /** Time at which the connection managed by this ConnectionHandler was last used */\n private long lastActivityTimestamp;\n\n /** Time at which the connection managed by this ConnectionHandler was last kept alive */\n private long lastKeepAliveTimestamp;\n\n /** Number of seconds of inactivity after which this ConnectionHandler's connection will be closed by ConnectionPool */\n private long closeOnInactivityPeriod = DEFAULT_CLOSE_ON_INACTIVITY_PERIOD;\n\n /** Number of seconds of inactivity after which this ConnectionHandler's connection will be kept alive by ConnectionPool */\n private long keepAlivePeriod = DEFAULT_KEEP_ALIVE_PERIOD;\n\n /** Default 'close on inactivity' period */\n private final static long DEFAULT_CLOSE_ON_INACTIVITY_PERIOD = 300;\n\n /** Default keep alive period (-1, keep alive disabled) */\n private final static long DEFAULT_KEEP_ALIVE_PERIOD = -1;\n\n\n /**\n * Creates a new ConnectionHandler for the given server URL using the Credentials included in the URL (potentially\n * null).\n *\n * @param serverURL URL of the server to connect to\n */\n public ConnectionHandler(FileURL serverURL) {\n realm = serverURL.getRealm();\n this.credentials = serverURL.getCredentials();\n }\n\n\n /**\n * Returns the URL of the server this ConnectionHandler connects to.\n *\n * @return the URL of the server this ConnectionHandler connects to\n */\n public FileURL getRealm() {\n return realm;\n }\n\n\n /**\n * Returns the Credentials that are used to connect to the server, null if no credentials are used.\n *\n * @return the Credentials that are used to connect to the server, null if no credentials are used\n */\n public Credentials getCredentials() {\n return credentials;\n }\n\n\n /**\n * Checks if the connection is currently active (as returned by {@link #isConnected()} and if it isn't, starts it\n * by calling {@link #startConnection()}. Returns true if the connection was properly started, false if the\n * connection was already active, or throws an IOException if the connection could not be started.\n *\n * @return Returns true if the connection was properly started, false if the connection was already active\n * @throws IOException if the connection could not be started\n */\n public boolean checkConnection() throws IOException {\n if (!isConnected()) {\n LOGGER.info(\"not connected, starting connection, this=\"+this);\n startConnection();\n return true;\n }\n\n return false;\n }\n\n\n /**\n * Tries to lock this ConnectionHandler and returns true if it could be locked, false if it is already locked.\n *\n * @return true if it could be locked, false if it is already locked.\n */\n synchronized boolean acquireLock() {\n if (isLocked) {\n LOGGER.info(\"!!!!! acquireLock() returning false, should not happen !!!!!\", new Throwable());\n return false;\n }\n\n isLocked = true;\n return true;\n }\n\n /**\n * Tries to release the lock on this ConnectionHandler and returns true if it could be locked, false if it\n * is not locked.\n *\n * @return true if it could be locked, false if it is not locked\n */\n public boolean releaseLock() {\n synchronized(this) {\n if (!isLocked) {\n LOGGER.info(\"!!!!! releaseLock() returning false, should not happen !!!!!\", new Throwable());\n return false;\n }\n\n isLocked = false;\n }\n\n ConnectionPool.notifyConnectionHandlerLockReleased();\n\n return true;\n }\n\n /**\n * Returns true if this ConnectionHandler is currently locked.\n *\n * @return true if this ConnectionHandler is currently locked\n */\n public synchronized boolean isLocked() {\n return isLocked;\n }\n\n\n /**\n * Updates the time at which the connection managed by this ConnectionHandler was last used to now (current time).\n */\n void updateLastActivityTimestamp() {\n lastActivityTimestamp = System.currentTimeMillis();\n }\n\n /**\n * Returns the time at which the connection managed by this ConnectionHandler was last used.\n *\n * @return the time at which the connection managed by this ConnectionHandler was last used\n */\n long getLastActivityTimestamp() {\n return lastActivityTimestamp;\n }\n\n\n /**\n * Updates the time at which the connection managed by this ConnectionHandler was last kept alive to now (current time).\n */\n void updateLastKeepAliveTimestamp() {\n lastKeepAliveTimestamp = System.currentTimeMillis();\n }\n\n /**\n * Returns the time at which the connection managed by this ConnectionHandler was last kept alive.\n *\n * @return the time at which the connection managed by this ConnectionHandler was last kept alive\n */\n long getLastKeepAliveTimestamp() {\n return lastKeepAliveTimestamp;\n }\n\n\n /**\n * Returns the number of seconds of inactivity after which {@link ConnectionPool} will close the connection by\n * calling {@link #closeConnection()}, -1 to indicate that the connection should not be automatically\n * closed.\n *\n * -1 to indicate that the connection should not be automatically closed\n */\n long getCloseOnInactivityPeriod() {\n return closeOnInactivityPeriod;\n }\n\n /**\n * Sets the number of seconds of inactivity after which {@link ConnectionPool} will close the connection by calling\n * {@link #closeConnection()}, -1 to prevent the connection from being automatically closed.\n *\n * -1 to indicate that the connection should not be automatically closed\n */\n public void setCloseOnInactivityPeriod(long nbSeconds) {\n closeOnInactivityPeriod = nbSeconds;\n }\n\n\n /**\n * Returns the number of seconds of inactivity after which {@link ConnectionPool} will keep the connection alive\n * by calling {@link #keepAlive()}, -1 to indicate that this connection should not be kept alive.\n *\n * -1 to indicate that this connection should not be kept alive\n */\n long getKeepAlivePeriod() {\n return keepAlivePeriod;\n }\n\n /**\n * Returns the number of seconds of inactivity after which {@link ConnectionPool} will keep the connection alive\n * by calling {@link #keepAlive()}, -1 to indicate that this connection should not be kept alive.\n *\n * -1 to indicate that this connection should not be kept alive\n */\n protected void setKeepAlivePeriod(long nbSeconds) {\n keepAlivePeriod = nbSeconds;\n }\n\n\n /**\n * Returns true if the given Object is a ConnectionHandler whose realm and credentials are equal to\n * those of this ConnectionHandler. The credentials comparison is password-sensitive.\n *\n * @param o the Object to compare for equality\n * @see Credentials#equals(Object, boolean)\n */\n public boolean equals(Object o) {\n if (!(o instanceof ConnectionHandler)) {\n return false;\n }\n ConnectionHandler connHandler = (ConnectionHandler)o;\n return equals(connHandler.realm, connHandler.credentials);\n }\n\n\n /**\n * Returns true if both the given realm and credentials are equal to those of this ConnectionHandler.\n * The credentials comparison is password-sensitive.\n *\n * @param realm the FileURL to compare against this ConnectionHandler's\n * @param credentials the Credentials to compare against this ConnectionHandler's\n * @return true if both the given realm and credentials are equal to those of this ConnectionHandler\n * @see Credentials#equals(Object, boolean)\n */\n public boolean equals(FileURL realm, Credentials credentials) {\n if (!this.realm.equals(realm, false, true)) {\n return false;\n }\n\n // Compare credentials. One or both Credentials instances may be null.\n\n // Note: Credentials.equals() considers null as equal to empty Credentials (see Credentials#isEmpty())\n return (this.credentials == null && credentials == null)\n || (this.credentials != null && this.credentials.equals(credentials, true))\n || (credentials != null && credentials.equals(this.credentials, true));\n }\n\n\n /**\n * Throws an {@link AuthException} using this connection handler's realm, credentials and the message passed as\n * an argument (can be null). The FileURL instance representing the realm that is used to create\n * the AuthException is a clone of this realm, making it safe for modification.\n *\n * @param message the message to pass to AuthException's constructor, can be null\n * @throws AuthException always throws the created AuthException\n */\n protected void throwAuthException(String message) throws AuthException {\n FileURL clonedRealm = (FileURL)realm.clone();\n clonedRealm.setCredentials(credentials);\n\n throw new AuthException(clonedRealm, message);\n }\n\n\n //////////////////////\n // Abstract methods //\n //////////////////////\n\n /**\n * Starts the connection managed by this ConnectionHandler, and throws an IOException if the connection could not\n * be established. This method may be called several times during the life of this ConnectionHandler, if the\n * connection dropped and must be re-established.\n *\n * @throws IOException if an error occurred while trying to establish the connection\n * @throws AuthException if an authentication error occurred (incorrect login or password, insufficient privileges...)\n */\n public abstract void startConnection() throws IOException, AuthException;\n\n /**\n * Returns true if the connection managed by this ConnectionHandler is currently active/established,\n * in a state that makes it possible to serve client requests.\n *\n * true if the connection managed by this ConnectionHandler is currently active/established\n */\n public abstract boolean isConnected();\n\n /**\n * Closes the connection managed by this ConnectionHandler.\n *\n * ConnectionHandler that a\n * ConnectionHandler has been released.\n */\n static void notifyConnectionHandlerLockReleased() {\n synchronized (connectionHandlers) {\n // Notify any thread waiting for a ConnectionHandler to be released\n connectionHandlers.notify();\n }\n }\n\n /**\n * Monitors connections and periodically:\n * \n *
\n */\n public void run() {\n\n while (monitorThread != null) { // Thread will be interrupted by CloseConnectionThread if there are no more ConnectionHandler\n long now = System.currentTimeMillis();\n\n synchronized(connectionHandlers) { // Ensures that getConnectionHandler is not currently changing the list while we access it\n for (IteratorAbstractContainsFilter using the specified generator and string, and operating in the\n * specified mode.\n *\n * @param generator generates criterion values for files as requested\n * @param s the string to compare criterion values against\n * @param caseSensitive if true, this filter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public AbstractContainsFilter(CriterionValueGeneratorAbstractCriterionFilter implements the bulk of the {@link CriterionFilter} interface, matching\n * files based on the criteria values generated by a given {@link CriterionValueGenerator}. The only method left for\n * subclasses to implement is {@link #accept(Object)}.\n *\n * @author Maxence Bernard\n */\npublic abstract class AbstractCriterionFilterAbstractCriterionFilter using the specified {@link CriterionValueGenerator} and operating\n * in non-inverted mode.\n *\n * @param generator generates criterion values for files as requested\n */\n public AbstractCriterionFilter(CriterionValueGeneratorAbstractCriterionFilter using the specified {@link CriterionValueGenerator} and operating\n * in the specified mode.\n *\n * @param generator generates criterion values for files as requested\n * @param inverted if true, this filter will operate in inverted mode.\n */\n AbstractCriterionFilter(CriterionValueGeneratortrue if this filter matched the given value, according to the current {@link #isInverted()}\n * mode:\n * \n *
\n *\n * @param value the value to test\n * @return true if this filter matched the given value, according to the current inverted mode\n */\n public boolean match(C value) {\n return inverted ? reject(value) : accept(value);\n }\n\n /**\n * Returns true if the given value was rejected by this filter, false if it was accepted.\n *\n * AbstractFile instances.\n *\n * @param values values to be tested\n * @return an array of accepted AbstractFile instances\n */\n public C[] filter(C[] values) {\n Listtrue if all the values in the specified array were matched by\n * {@link #match(Object)}, false if one of the values wasn't.\n *\n * @param values the values to be tested\n * @return true if all the values in the specified array were accepted\n */\n public boolean match(C[] values) {\n for (C value : values) {\n if (!match(value)) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Convenience method that returns true if all the values in the specified array were accepted by\n * {@link #accept(Object)}, false if one of the values wasn't.\n *\n * @param values the values to be tested\n * @return true if all the values in the specified array were accepted\n */\n public boolean accept(C[] values) {\n for (C value : values) {\n if (!accept(value)) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Convenience method that returns true if all the values in the specified array were rejected by\n * {@link #reject(Object)}, false if one of the values wasn't.\n *\n * @param values the values to be tested\n * @return true if all the values in the specified array were rejected\n */\n public boolean reject(C[] values) {\n for (C value : values) {\n if (!reject(value)) {\n return false;\n }\n }\n return true;\n }\n\n\n @Override\n public boolean accept(AbstractFile file) {\n return accept(generator.getCriterionValue(file));\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/AbstractEndsWithFilter.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see AbstractEndsWithFilter using the specified generator and string, and operating in the \n * specified mode.\n *\n * @param generator generates criterion values for files as requested\n * @param s the string to compare criterion values against\n * @param caseSensitive if true, this filter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public AbstractEndsWithFilter(CriterionValueGeneratorAbstractEndsWithFilter using the specified generator and string, and operating in the\n * specified mode.\n *\n * @param generator generates criterion values for files as requested\n * @param s the string to compare criterion values against\n * @param caseSensitive if true, this filter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public AbstractEqualsFilter(CriterionValueGeneratorAbstractExtensionFilter using the specified generator and string, and operating in the\n * specified mode.\n *\n * @param generator generates criterion values for files as requested\n * @param extensions the extensions to compare criterion values against\n * @param caseSensitive if true, this filter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n AbstractExtensionFilter(CriterionValueGeneratorAbstractFileFilter implements the bulk of the {@link FileFilter} interface. The only method left for\n * subclasses to implement is {@link #accept(AbstractFile)}.\n *\n * @see AbstractFilenameFilter\n * @author Maxence Bernard\n */\npublic abstract class AbstractFileFilter implements FileFilter {\n\n /** True if this filter should operate in inverted mode and invert matches */\n protected boolean inverted;\n\n /**\n * Creates a new AbstractFileFilter operating in non-inverted mode.\n */\n public AbstractFileFilter() {\n this(false);\n }\n\n /**\n * Creates a new AbstractFileFilter operating in the specified mode.\n *\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public AbstractFileFilter(boolean inverted) {\n setInverted(inverted);\n }\n\n\n ///////////////////////////////\n // FileFilter implementation //\n ///////////////////////////////\n\n public boolean isInverted() {\n return inverted;\n }\n\n public void setInverted(boolean inverted) {\n this.inverted = inverted;\n }\n\n public boolean match(AbstractFile file) {\n return inverted ? reject(file) : accept(file);\n }\n\n public boolean reject(AbstractFile file) {\n return !accept(file);\n }\n\n public AbstractFile[] filter(AbstractFile[] files) {\n ListAbstractFilenameFilter implements the bulk of the {@link FilenameFilter} interface. The only method left\n * for subclasses to implement is {@link #accept(Object)}.\n *\n * @author Maxence Bernard\n */\npublic abstract class AbstractFilenameFilter extends AbstractStringCriterionFilter implements FilenameFilter {\n\n /**\n * Creates a new case-insensitive AbstractFilenameFilter operating in non-inverted mode.\n */\n public AbstractFilenameFilter() {\n this(false, false);\n }\n\n /**\n * Creates a new AbstractFilenameFilter operating in non-inverted mode.\n *\n * @param caseSensitive if true, this FilenameFilter will be case-sensitive\n */\n public AbstractFilenameFilter(boolean caseSensitive) {\n this(caseSensitive, false);\n }\n\n /**\n * Creates a new AbstractFilenameFilter operating in the specified mode.\n *\n * @param caseSensitive if true, this FilenameFilter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public AbstractFilenameFilter(boolean caseSensitive, boolean inverted) {\n super(new FilenameGenerator(), caseSensitive, inverted);\n }\n}"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/AbstractPathFilter.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see AbstractPathFilter implements the bulk of the {@link PathFilter} interface. The only method left\n * for subclasses to implement is {@link #accept(Object)}.\n *\n * @author Maxence Bernard\n */\npublic abstract class AbstractPathFilter extends AbstractStringCriterionFilter implements PathFilter {\n\n /**\n * Creates a new case-insensitive AbstractPathFilter operating in non-inverted mode.\n */\n public AbstractPathFilter() {\n this(false, false);\n }\n\n /**\n * Creates a new AbstractPathFilter operating in non-inverted mode.\n *\n * @param caseSensitive if true, this FilePathFilter will be case-sensitive\n */\n public AbstractPathFilter(boolean caseSensitive) {\n this(caseSensitive, false);\n }\n\n /**\n * Creates a new AbstractPathFilter operating in the specified mode.\n *\n * @param caseSensitive if true, this FilePathFilter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public AbstractPathFilter(boolean caseSensitive, boolean inverted) {\n super(new PathGenerator(), caseSensitive, inverted);\n }\n}"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/AbstractRegexpFilter.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see AbstractRegexpFilter matching the specified regexp and operating in the specified\n * modes.\n *\n * @param generator generates criterion values for files as requested\n * @param regexp regular expression that matches string values.\n * @param caseSensitive whether the regular expression is case sensitive or not.\n * @param inverted if true, this filter will operate in inverted mode.\n * @throws PatternSyntaxException if the syntax of the regular expression is not correct.\n */\n public AbstractRegexpFilter(CriterionValueGeneratortrue if the specified value matches the filter's regular expression.\n *\n * @param value value to match against the filter's regular expression.\n * @return true if the specified value matches the filter's regular expression,\n * false otherwise.\n */\n @Override\n public boolean accept(String value) {\n return pattern.matcher(value).matches();\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/AbstractStartsWithFilter.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see AbstractStartsWithFilter using the specified generator and string, and operating in the\n * specified mode.\n *\n * @param generator generates criterion values for files as requested\n * @param s the string to compare criterion values against\n * @param caseSensitive if true, this filter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public AbstractStartsWithFilter(CriterionValueGeneratorAbstractCriterionFilter implements the bulk of the {@link StringCriterionFilter} interface, matching\n * files based on the criteria values generated by a given {@link CriterionValueGenerator}. The only method left for\n * subclasses to implement is {@link #accept(Object)}.\n *\n * @see AbstractPathFilter\n * @see AbstractFilenameFilter\n * @author Maxence Bernard\n */\npublic abstract class AbstractStringCriterionFilter extends AbstractCriterionFilterAbstractStringCriterionFilter operating in non-inverted mode.\n *\n * @param generator generates criterion values for files as requested\n */\n public AbstractStringCriterionFilter(CriterionValueGeneratorAbstractStringCriterionFilter operating in non-inverted mode.\n *\n * @param generator generates criterion values for files as requested\n * @param caseSensitive if true, this FilePathFilter will be case-sensitive\n */\n public AbstractStringCriterionFilter(CriterionValueGeneratorAbstractStringCriterionFilter that operates in the specified mode.\n *\n * @param generator generates criterion values for files as requested\n * @param caseSensitive if true, this FilePathFilter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public AbstractStringCriterionFilter(CriterionValueGeneratorAndFileFilter operating in non-inverted mode and containing the specified filters,\n * if any.\n *\n * @param filters filters to add to this chained filter.\n */\n public AndFileFilter(FileFilter... filters) {\n this(false, filters);\n }\n\n /**\n * Creates a new AndFileFilter operating in the specified mode and containing the specified filters,\n * if any.\n *\n * @param inverted if true, this filter will operate in inverted mode.\n * @param filters filters to add to this chained filter.\n */\n public AndFileFilter(boolean inverted, FileFilter... filters) {\n super(inverted, filters);\n }\n\n\n\n /**\n * Calls {@link #match(com.mucommander.commons.file.AbstractFile)} on each of the registered filters, and returns\n * true if all of them matched the given file, false if one of them didn't.\n *\n * true.\n *\n * @param file the file to test against the registered filters\n * @return if the file was matched by all filters, false if one of them didn't \n */\n @Override\n public boolean accept(AbstractFile file) {\n for (FileFilter filter : filters) {\n if (!filter.match(file)) {\n return false;\n }\n }\n return true;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/AttributeFileFilter.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see AttributeFileFilter matches files which have a specific attribute set.\n * Here's a list of supported file attributes:\n * \n *
\n *\n * AttributeFileFilter matching files that have the specified attribute set and operating\n * in non-inverted mode.\n *\n * @param attribute the attribute to test files against\n */\n public AttributeFileFilter(FileAttribute attribute) {\n this(attribute, false);\n }\n\n /**\n * Creates a new AttributeFileFilter matching files that have the specified attribute set and operating\n * in the specified mode.\n *\n * @param attribute the attribute to test files against\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public AttributeFileFilter(FileAttribute attribute, boolean inverted) {\n super(inverted);\n this.attribute = attribute;\n }\n\n\n /**\n * Returns the attribute which files are tested against.\n *\n * @return the attribute which files are tested against.\n */\n public FileAttribute getAttribute() {\n return attribute;\n }\n\n /**\n * Sets the attribute which files are tested against.\n *\n * @param attribute the attribute which files are tested against.\n */\n public void setAttribute(FileAttribute attribute) {\n this.attribute = attribute;\n }\n\n\n @Override\n public boolean accept(AbstractFile file) {\n switch(attribute) {\n case DIRECTORY:\n return file.isDirectory();\n case FILE:\n return !file.isDirectory();\n case BROWSABLE:\n return file.isBrowsable();\n case ARCHIVE:\n return file.isArchive();\n case SYMLINK:\n return file.isSymlink();\n case HIDDEN:\n return file.isHidden();\n case ROOT:\n return file.isRoot();\n\t\t case SYSTEM:\n\t\t\t return file.isSystem();\n\t\t default:\n\t\t \treturn true;\n }\n }\n}\n\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/ChainedFileFilter.java",
"content": "package com.mucommander.commons.file.filter;\n\nimport java.util.ArrayList;\nimport java.util.Iterator;\nimport java.util.List;\n\n\n/**\n * ChainedFileFilter combines one or several {@link FileFilter} to act as just one.\n *{@link #addFileFilter(FileFilter)} and {@link #removeFileFilter(FileFilter)} allow to add or remove a\n * FileFilter, {@link #getFileFilterIterator()} to iterate through all the registered filters.\n *\n * ChainedFileFilter operating in non-inverted mode and containing the specified filters,\n * if any.\n *\n * @param filters filters to add to this chained filter.\n */\n public ChainedFileFilter(FileFilter... filters) {\n this(false, filters);\n }\n\n /**\n * Creates a new ChainedFileFilter operating in the specified mode and containing the specified filters,\n * if any.\n *\n * @param inverted if true, this filter will operate in inverted mode.\n * @param filters filters to add to this chained filter.\n */\n public ChainedFileFilter(boolean inverted, FileFilter... filters) {\n super(inverted);\n\n for (FileFilter filter : filters)\n addFileFilter(filter);\n }\n\n /**\n * Adds a new {@link FileFilter} to the list of chained filters.\n *\n * @param filter the FileFilter to add\n */\n public void addFileFilter(FileFilter filter) {\n filters.add(filter);\n }\n\n /**\n * Removes a {@link FileFilter} from the list of chained filters. Does nothing if the given FileFilter\n * is not contained by this ChainedFileFilter.\n *\n * @param filter the FileFilter to remove\n */\n public void removeFileFilter(FileFilter filter) {\n filters.remove(filter);\n }\n\n /**\n * Returns an Iterator that traverses all the registered filters.\n *\n * @return an Iterator that traverses all the registered filters. \n */\n public Iteratortrue if this chained filter doesn't contain any file filter.\n *\n * @return true if this chained filter doesn't contain any file filter.\n */\n public boolean isEmpty() {\n return filters.isEmpty();\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/ContainsFilenameFilter.java",
"content": "package com.mucommander.commons.file.filter;\n\n/**\n * This {@link FilenameFilter} matches filenames that contain a specified string that can be located anywhere in the\n * filename.\n *\n * @author Maxence Bernard\n */\npublic class ContainsFilenameFilter extends AbstractContainsFilter implements FilenameFilter {\n\n /**\n * Creates a new case-insensitive ContainsFilenameFilter operating in non-inverted mode.\n *\n * @param s the string to compare filenames against\n */\n public ContainsFilenameFilter(String s) {\n this(s, false, false);\n }\n\n /**\n * Creates a new ContainsFilenameFilter operating in non-inverted mode.\n *\n * @param s the string to compare filenames against\n * @param caseSensitive if true, this FilenameFilter will be case-sensitive\n */\n public ContainsFilenameFilter(String s, boolean caseSensitive) {\n this(s, caseSensitive, false);\n }\n\n /**\n * Creates a new ContainsFilenameFilter operating in the specified mode.\n *\n * @param s the string to compare filenames against\n * @param caseSensitive if true, this FilenameFilter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public ContainsFilenameFilter(String s, boolean caseSensitive, boolean inverted) {\n super(new FilenameGenerator(), s, caseSensitive, inverted);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/ContainsPathFilter.java",
"content": "package com.mucommander.commons.file.filter;\n\n/**\n * This {@link PathFilter} matches paths that contain a specified string that can be located anywhere in the\n * path.\n *\n * @author Maxence Bernard\n */\npublic class ContainsPathFilter extends AbstractContainsFilter implements PathFilter {\n\n /**\n * Creates a new case-insensitive ContainsPathFilter operating in non-inverted mode.\n *\n * @param s the string to compare paths against\n */\n public ContainsPathFilter(String s) {\n this(s, false, false);\n }\n\n /**\n * Creates a new ContainsPathFilter operating in non-inverted mode.\n *\n * @param s the string to compare paths against\n * @param caseSensitive if true, this PathFilter will be case-sensitive\n */\n public ContainsPathFilter(String s, boolean caseSensitive) {\n this(s, caseSensitive, false);\n }\n\n /**\n * Creates a new ContainsPathFilter operating in the specified mode.\n *\n * @param s the string to compare paths against\n * @param caseSensitive if true, this PathFilter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public ContainsPathFilter(String s, boolean caseSensitive, boolean inverted) {\n super(new PathGenerator(), s, caseSensitive, inverted);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/CriterionFilter.java",
"content": "package com.mucommander.commons.file.filter;\n\nimport com.mucommander.commons.file.AbstractFile;\n\n/**\n * CriterionFilter is a {@link FileFilter} that operates on a file criterion. It can be used to match\n * paths without having to deal with {@link AbstractFile} instances. By extending {@link FileFilter}, this class can be\n * used everywhere a FileFilter is accepted.\n *\n * true if this filter matched the given value, according to the current {@link #isInverted()}\n * mode:\n * \n *
\n *\n * @param value the value to test\n * @return true if this filter matched the given value, according to the current inverted mode\n */\n boolean match(C value);\n\n /**\n * Returns true if the given value was rejected by this filter, false if it was accepted.\n *\n * AbstractFile instances.\n *\n * @param value values to be tested\n * @return an array of accepted AbstractFile instances\n */\n C[] filter(C[] value);\n\n /**\n * Convenience method that returns true if all the values in the specified array were matched by\n * {@link #match(Object)}, false if one of the values wasn't.\n *\n * @param value the values to be tested\n * @return true if all the values in the specified array were accepted\n */\n boolean match(C[] value);\n\n /**\n * Convenience method that returns true if all the values in the specified array were accepted by\n * {@link #accept(Object)}, false if one of the values wasn't.\n *\n * @param value the values to be tested\n * @return true if all the values in the specified array were accepted\n */\n boolean accept(C[] value);\n\n /**\n * Convenience method that returns true if all the values in the specified array were rejected by\n * {@link #reject(Object)}, false if one of the values wasn't.\n *\n * @param value the values to be tested\n * @return true if all the values in the specified array were rejected\n */\n boolean reject(C[] value);\n\n /**\n * Returns true if the given value was accepted by this filter, false if it was rejected.\n *\n * @param value the value to test\n * @return true if the given value was accepted by this filter, false if it was rejected\n */\n boolean accept(C value);\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/CriterionValueGenerator.java",
"content": "package com.mucommander.commons.file.filter;\n\nimport com.mucommander.commons.file.AbstractFile;\n\n/**\n * This interface defines a {@link #getCriterionValue(AbstractFile)} method that generates a criterion value for\n * a specified {@link AbstractFile}. It is used by {@link CriterionFilter} to match files based on their criteria\n * values.\n *\n * @see CriterionFilter\n * @author Maxence Bernard\n */\npublic interface CriterionValueGeneratorEndsWithFilenameFilter operating in non-inverted mode.\n *\n * @param s the string to compare filenames against\n */\n public EndsWithFilenameFilter(String s) {\n this(s, false, false);\n }\n\n /**\n * Creates a new EndsWithFilenameFilter operating in non-inverted mode.\n *\n * @param s the string to compare filenames against\n * @param caseSensitive if true, this FilenameFilter will be case-sensitive\n */\n public EndsWithFilenameFilter(String s, boolean caseSensitive) {\n this(s, caseSensitive, false);\n }\n\n /**\n * Creates a new EndsWithFilenameFilter operating in the specified mode.\n *\n * @param s the string to compare filenames against\n * @param caseSensitive if true, this FilenameFilter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public EndsWithFilenameFilter(String s, boolean caseSensitive, boolean inverted) {\n super(new FilenameGenerator(), s, caseSensitive, inverted);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/EndsWithPathFilter.java",
"content": "package com.mucommander.commons.file.filter;\n\n/**\n * This {@link PathFilter} matches paths that end with a specified string.\n *\n * @author Maxence Bernard\n */\npublic class EndsWithPathFilter extends AbstractEndsWithFilter implements PathFilter {\n\n /**\n * Creates a new case-insensitive EndsWithPathFilter operating in non-inverted mode.\n *\n * @param s the string to compare paths against\n */\n public EndsWithPathFilter(String s) {\n this(s, false, false);\n }\n\n /**\n * Creates a new EndsWithPathFilter operating in non-inverted mode.\n *\n * @param s the string to compare paths against\n * @param caseSensitive if true, this PathFilter will be case-sensitive\n */\n public EndsWithPathFilter(String s, boolean caseSensitive) {\n this(s, caseSensitive, false);\n }\n\n /**\n * Creates a new EndsWithPathFilter operating in the specified mode.\n *\n * @param s the string to compare paths against\n * @param caseSensitive if true, this PathFilter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public EndsWithPathFilter(String s, boolean caseSensitive, boolean inverted) {\n super(new PathGenerator(), s, caseSensitive, inverted);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/EqualsFilenameFilter.java",
"content": "package com.mucommander.commons.file.filter;\n\n/**\n * This {@link FilenameFilter} matches filenames that are equal to a specified string.\n *\n * @author Maxence Bernard\n */\npublic class EqualsFilenameFilter extends AbstractEqualsFilter implements FilenameFilter {\n\n /**\n * Creates a new case-insensitive EqualsFilenameFilter operating in non-inverted mode.\n *\n * @param s the string to compare filenames against\n */\n public EqualsFilenameFilter(String s) {\n this(s, false, false);\n }\n\n /**\n * Creates a new EqualsFilenameFilter operating in non-inverted mode.\n *\n * @param s the string to compare filenames against\n * @param caseSensitive if true, this FilenameFilter will be case-sensitive\n */\n public EqualsFilenameFilter(String s, boolean caseSensitive) {\n this(s, caseSensitive, false);\n }\n\n /**\n * Creates a new EqualsFilenameFilter operating in the specified mode.\n *\n * @param s the string to compare filenames against\n * @param caseSensitive if true, this FilenameFilter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public EqualsFilenameFilter(String s, boolean caseSensitive, boolean inverted) {\n super(new FilenameGenerator(), s, caseSensitive, inverted);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/EqualsPathFilter.java",
"content": "package com.mucommander.commons.file.filter;\n\n/**\n * This {@link PathFilter} matches paths that are equal to a specified string.\n *\n * @author Maxence Bernard\n */\npublic class EqualsPathFilter extends AbstractEqualsFilter implements PathFilter {\n\n /**\n * Creates a new case-insensitive EqualsPathFilter operating in non-inverted mode.\n *\n * @param s the string to compare paths against\n */\n public EqualsPathFilter(String s) {\n this(s, false, false);\n }\n\n /**\n * Creates a new EqualsPathFilter operating in non-inverted mode.\n *\n * @param s the string to compare paths against\n * @param caseSensitive if true, this PathFilter will be case-sensitive\n */\n public EqualsPathFilter(String s, boolean caseSensitive) {\n this(s, caseSensitive, false);\n }\n\n /**\n * Creates a new EqualsPathFilter operating in the specified mode.\n *\n * @param s the string to compare paths against\n * @param caseSensitive if true, this PathFilter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public EqualsPathFilter(String s, boolean caseSensitive, boolean inverted) {\n super(new PathGenerator(), s, caseSensitive, inverted);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/ExtensionFilenameFilter.java",
"content": "package com.mucommander.commons.file.filter;\n\n/**\n * This {@link FilenameFilter} matches files whose path end with one of several specified extensions.\n *\n * ExtensionFilenameFilter matching filenames ending with the specified\n * extension and operating in non-inverted mode.\n *\n * @param extension the extension to match\n */\n public ExtensionFilenameFilter(String extension) {\n this(extension, false, false);\n }\n\n /**\n * Creates a ExtensionFilenameFilter matching filenames ending with the specified extension\n * and operating in the specified modes.\n *\n * @param extension the extension to match\n * @param caseSensitive if true, this FilenameFilter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public ExtensionFilenameFilter(String extension, boolean caseSensitive, boolean inverted) {\n this(new String[]{extension}, caseSensitive, inverted);\n }\n\n /**\n * Creates a case-insensitive ExtensionFilenameFilter matching filenames ending with one of the\n * specified extensions and operating in the specified mode.\n *\n * @param ext the extensions to match\n */\n public ExtensionFilenameFilter(String[] ext) {\n this(ext, false, false);\n }\n\n /**\n * Creates a new ExtensionFilenameFilter matching filenames ending with one of the specified\n * extensions and operating in the specified modes.\n *\n * @param ext the extensions to match\n * @param caseSensitive if true, this FilenameFilter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public ExtensionFilenameFilter(String[] ext, boolean caseSensitive, boolean inverted) {\n super(new FilenameGenerator(), ext, caseSensitive, inverted);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/ExtensionPathFilter.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see ExtensionPathFilter matching paths ending with the specified\n * extension and operating in non-inverted mode.\n *\n * @param extension the extension to match\n */\n public ExtensionPathFilter(String extension) {\n this(extension, false, false);\n }\n\n /**\n * Creates a ExtensionPathFilter matching paths ending with the specified extension\n * and operating in the specified modes.\n *\n * @param extension the extension to match\n * @param caseSensitive if true, this PathFilter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n private ExtensionPathFilter(String extension, boolean caseSensitive, boolean inverted) {\n this(new String[]{extension}, caseSensitive, inverted);\n }\n\n /**\n * Creates a case-insensitive ExtensionPathFilter matching paths ending with one of the\n * specified extensions and operating in the specified mode.\n *\n * @param ext the extensions to match\n */\n public ExtensionPathFilter(String[] ext) {\n this(ext, false, false);\n }\n\n /**\n * Creates a new ExtensionPathFilter matching paths ending with one of the specified\n * extensions and operating in the specified modes.\n *\n * @param ext the extensions to match\n * @param caseSensitive if true, this PathFilter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public ExtensionPathFilter(String[] ext, boolean caseSensitive, boolean inverted) {\n super(new PathGenerator(), ext, caseSensitive, inverted);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/FileFilter.java",
"content": "package com.mucommander.commons.file.filter;\n\nimport com.mucommander.commons.file.AbstractFile;\nimport com.mucommander.commons.file.util.FileSet;\n\n/**\n * A FileFilter matches files that meet certain criteria. It can operate in two opposite modes: inverted\n * and non-inverted. By default, a FileFilter operates in non-inverted mode where\n * {@link #match(AbstractFile)} returns the value of {@link #accept(AbstractFile)}. On the contrary, when operating in\n * inverted mode, {@link #match(AbstractFile)} returns the value of {@link #reject(AbstractFile)}. It is important to\n * understand that {@link #accept(AbstractFile)} and {@link #reject(AbstractFile)} are not affected by the inverted\n * mode in which a filter operates.\n *\n * FileFilter instance can be passed to {@link AbstractFile#ls(FileFilter)} to filter out some of the\n * the files contained by a folder.\n *\n * @see AbstractFileFilter\n * @see FilenameFilter\n * @see com.mucommander.commons.file.AbstractFile#ls(FileFilter)\n * @author Maxence Bernard\n */\npublic interface FileFilter {\n\n /**\n * Return true if this filter operates in normal mode, false if in inverted mode.\n *\n * @return true if this filter operates in normal mode, false if in inverted mode\n */\n boolean isInverted();\n\n /**\n * Sets the mode in which {@link #match(com.mucommander.commons.file.AbstractFile)} operates. If true, this\n * filter will operate in inverted mode: files that would be accepted by {@link #match(com.mucommander.commons.file.AbstractFile)}\n * in normal (non-inverted) mode will be rejected, and vice-versa.
\n * The inverted mode has no effect on the values returned by {@link #accept(com.mucommander.commons.file.AbstractFile)} and\n * {@link #reject(com.mucommander.commons.file.AbstractFile)}.\n *\n * @param inverted if true, this filter will operate in inverted mode.\n */\n void setInverted(boolean inverted);\n\n /**\n * Returns true if this filter matched the given file, according to the current {@link #isInverted()}\n * mode:\n * \n *
\n *\n * @param file the file to test\n * @return true if this filter matched the given file, according to the current inverted mode\n */\n boolean match(AbstractFile file);\n\n /**\n * Returns true if the given file was rejected by this filter, false if it was accepted.\n *\n * AbstractFile instances.\n *\n * @param files files to be tested against {@link #match(com.mucommander.commons.file.AbstractFile)}\n * @return a file array of files that were matched by this filter\n */\n AbstractFile[] filter(AbstractFile files[]);\n\n /**\n * Convenience method that filters out files that do not {@link #match(AbstractFile) match} this filter\n * and removes them from the given {@link FileSet}.\n *\n * @param files files to be tested against {@link #match(com.mucommander.commons.file.AbstractFile)}\n */\n void filter(FileSet files);\n\n /**\n * Convenience method that returns true if all the files contained in the specified file array\n * were matched by {@link #match(AbstractFile)}, false if one of the files wasn't.\n *\n * @param files the files to test against this FileFilter\n * @return true if all the files contained in the specified file array were matched by this filter\n */\n boolean match(AbstractFile files[]);\n\n /**\n * Convenience method that returns true if all the files contained in the specified {@link FileSet}\n * were matched by {@link #match(AbstractFile)}, false if one of the files wasn't.\n *\n * @param files the files to test against this FileFilter\n * @return true if all the files contained in the specified {@link FileSet} were matched by this filter\n */\n boolean match(FileSet files);\n\n /**\n * Convenience method that returns true if all the files contained in the specified file array\n * were accepted by {@link #accept(AbstractFile)}, false if one of the files wasn't.\n *\n * @param files the files to test against this FileFilter\n * @return true if all the files contained in the specified file array were accepted by this filter\n */\n boolean accept(AbstractFile files[]);\n\n /**\n * Convenience method that returns true if all the files contained in the specified {@link FileSet}\n * were accepted by {@link #accept(AbstractFile)}, false if one of the files wasn't.\n *\n * @param files the files to test against this FileFilter\n * @return true if all the files contained in the specified {@link FileSet} were accepted by this filter\n */\n boolean accept(FileSet files);\n\n /**\n * Convenience method that returns true if all the files contained in the specified file array\n * were rejected by {@link #reject(AbstractFile)}, false if one of the files wasn't.\n *\n * @param files the files to test against this FileFilter\n * @return true if all the files contained in the specified file array were rejected by this filter\n */\n boolean reject(AbstractFile files[]);\n\n /**\n * Convenience method that returns true if all the files contained in the specified {@link FileSet}\n * were rejected by {@link #reject(AbstractFile)}, false if one of the files wasn't.\n *\n * @param files the files to test against this FileFilter\n * @return true if all the files contained in the specified {@link FileSet} were rejected by this filter\n */\n boolean reject(FileSet files);\n\n /**\n * Returns true if the given file was accepted by this filter, false if it was rejected.\n *\n * OperationFileFilter matches files which support a specified {@link FileOperation file operation}.\n *\n * FilenameFilter is a {@link FileFilter} that operates on filenames.\n *\n * FilenameFilter can be passed to {@link AbstractFile#ls(FilenameFilter)} to filter out some of the\n * files contained by a folder without creating the associated AbstractFile instances.\n *\n * @see AbstractFilenameFilter\n * @author Maxence Bernard\n */\npublic interface FilenameFilter extends StringCriterionFilter {\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/FilenameGenerator.java",
"content": "package com.mucommander.commons.file.filter;\n\nimport com.mucommander.commons.file.AbstractFile;\n\n/**\n * This interface specializes {@link CriterionValueGenerator} to have {@link #getCriterionValue(AbstractFile)} return\n * the filename of the specified file.\n *\n * @author Maxence Bernard\n */\npublic class FilenameGenerator implements CriterionValueGeneratorOrFileFilter is a {@link ChainedFileFilter} that matches a file if one of its registered filters \n * matches it.\n *\n * @author Maxence Bernard\n */\npublic class OrFileFilter extends ChainedFileFilter {\n\n /**\n * Creates a new OrFileFilter operating in non-inverted mode and containing the specified filters,\n * if any.\n *\n * @param filters filters to add to this chained filter.\n */\n public OrFileFilter(FileFilter... filters) {\n this(false, filters);\n }\n\n /**\n * Creates a new OrFileFilter operating in the specified mode and containing the specified filters,\n * if any.\n *\n * @param inverted if true, this filter will operate in inverted mode.\n * @param filters filters to add to this chained filter.\n */\n public OrFileFilter(boolean inverted, FileFilter... filters) {\n super(inverted, filters);\n }\n\n\n\n /**\n * Calls {@link #match(com.mucommander.commons.file.AbstractFile)} on each of the registered filters, and returns\n * true if one of them matched the given file, false if none of them did.\n *\n * true.\n *\n * @param file the file to test against the registered filters\n * @return if the file was matched by one filter, false if none of them did\n */\n @Override\n public boolean accept(AbstractFile file) {\n for (FileFilter filter : filters) {\n if (filter.match(file)) {\n return true;\n }\n }\n return filters.isEmpty();\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/PassThroughFileFilter.java",
"content": "package com.mucommander.commons.file.filter;\n\nimport com.mucommander.commons.file.AbstractFile;\n\n/**\n * PassThroughFileFilter is a filter that {@link #accept(com.mucommander.commons.file.AbstractFile) accepts} all\n * files. Depending on the {@link #isInverted() inverted} mode, this filter will match all files or no file at all.\n *\n * @author Maxence Bernard\n */\npublic class PassThroughFileFilter extends AbstractFileFilter {\n\n /**\n * Creates a new PassThroughFileFilter operating in non-inverted mode.\n */\n public PassThroughFileFilter() {\n this(false);\n }\n\n /**\n * Creates a new PassThroughFileFilter operating in the specified mode.\n *\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public PassThroughFileFilter(boolean inverted) {\n super(inverted);\n }\n\n\n @Override\n public boolean accept(AbstractFile file) {\n return true;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/PathFilter.java",
"content": "package com.mucommander.commons.file.filter;\n\n/**\n * PathFilter is a {@link FileFilter} that operates on absolute file paths.\n *\n * @see AbstractPathFilter\n * @author Maxence Bernard\n */\npublic interface PathFilter extends StringCriterionFilter {\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/PathGenerator.java",
"content": "package com.mucommander.commons.file.filter;\n\nimport com.mucommander.commons.file.AbstractFile;\n\n/**\n * This interface specializes {@link CriterionValueGenerator} to have {@link #getCriterionValue(AbstractFile)} return\n * the absolute path of the specified file.\n *\n * @author Maxence Bernard\n */\npublic class PathGenerator implements CriterionValueGeneratorRegexpFilenameFilter matching the specified regexp and operating in non-inverted\n * mode.\n *\n * @param regexp regular expression that matches string values.\n * @param caseSensitive whether the regular expression is case-sensitive or not.\n * @throws PatternSyntaxException if the syntax of the regular expression is not correct.\n */\n public RegexpFilenameFilter(String regexp, boolean caseSensitive) throws PatternSyntaxException {\n super(new FilenameGenerator(), regexp, caseSensitive, false);\n }\n\n /**\n * Creates a new RegexpFilenameFilter matching the specified regexp and operating in the specified\n * modes.\n *\n * @param regexp regular expression that matches string values.\n * @param caseSensitive whether the regular expression is case-sensitive or not.\n * @param inverted if true, this filter will operate in inverted mode.\n * @throws PatternSyntaxException if the syntax of the regular expression is not correct.\n */\n public RegexpFilenameFilter(String regexp, boolean caseSensitive, boolean inverted) throws PatternSyntaxException {\n super(new FilenameGenerator(), regexp, caseSensitive, inverted);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/RegexpPathFilter.java",
"content": "package com.mucommander.commons.file.filter;\n\nimport java.util.regex.PatternSyntaxException;\n\n/**\n * This {@link PathFilter} that accepts or rejects files whose path match a specific regular expression.\n *\n * @author Maxence Bernard\n */\npublic class RegexpPathFilter extends AbstractRegexpFilter implements PathFilter {\n\n /**\n * Creates a new RegexpPathFilter matching the specified regexp and operating in non-inverted\n * mode.\n *\n * @param regexp regular expression that matches string values.\n * @param caseSensitive whether the regular expression is case-sensitive or not.\n * @throws PatternSyntaxException if the syntax of the regular expression is not correct.\n */\n public RegexpPathFilter(String regexp, boolean caseSensitive) throws PatternSyntaxException {\n super(new PathGenerator(), regexp, caseSensitive, false);\n }\n\n /**\n * Creates a new RegexpPathFilter matching the specified regexp and operating in the specified\n * modes.\n *\n * @param regexp regular expression that matches string values.\n * @param caseSensitive whether the regular expression is case-sensitive or not.\n * @param inverted if true, this filter will operate in inverted mode.\n * @throws PatternSyntaxException if the syntax of the regular expression is not correct.\n */\n public RegexpPathFilter(String regexp, boolean caseSensitive, boolean inverted) throws PatternSyntaxException {\n super(new PathGenerator(), regexp, caseSensitive, inverted);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/StartsWithFilenameFilter.java",
"content": "package com.mucommander.commons.file.filter;\n\n/**\n * This {@link FilenameFilter} matches filenames that start with a specified string.\n *\n * @author Maxence Bernard\n */\npublic class StartsWithFilenameFilter extends AbstractStartsWithFilter implements FilenameFilter {\n\n /**\n * Creates a new case-insensitive StartsFilenameFilter matching filenames starting with the specified\n * string and operating in the specified mode.\n *\n * @param s the string to compare filenames against\n */\n public StartsWithFilenameFilter(String s) {\n this(s, false, false);\n }\n\n /**\n * Creates a new StartsFilenameFilter matching filenames starting with the specified string and\n * operating in non-inverted mode.\n *\n * @param s the string to compare filenames against\n * @param caseSensitive if true, this FilenameFilter will be case-sensitive\n */\n public StartsWithFilenameFilter(String s, boolean caseSensitive) {\n this(s, caseSensitive, false);\n }\n\n /**\n * Creates a new StartsFilenameFilter matching filenames starting with the specified string and\n * operating in the specified modes.\n *\n * @param s the string to compare filenames against\n * @param caseSensitive if true, this FilenameFilter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public StartsWithFilenameFilter(String s, boolean caseSensitive, boolean inverted) {\n super(new FilenameGenerator(), s, caseSensitive, inverted);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/StartsWithPathFilter.java",
"content": "package com.mucommander.commons.file.filter;\n\n/**\n * This {@link PathFilter} matches paths that start with a specified string.\n *\n * @author Maxence Bernard\n */\npublic class StartsWithPathFilter extends AbstractStartsWithFilter implements PathFilter {\n\n /**\n * Creates a new case-insensitive StartsPathFilter matching paths starting with the specified\n * string and operating in the specified mode.\n *\n * @param s the string to compare paths against\n */\n public StartsWithPathFilter(String s) {\n this(s, false, false);\n }\n\n /**\n * Creates a new StartsPathFilter matching paths starting with the specified string and\n * operating in non-inverted mode.\n *\n * @param s the string to compare paths against\n * @param caseSensitive if true, this PathFilter will be case-sensitive\n */\n public StartsWithPathFilter(String s, boolean caseSensitive) {\n this(s, caseSensitive, false);\n }\n\n /**\n * Creates a new StartsPathFilter matching paths starting with the specified string and\n * operating in the specified modes.\n *\n * @param s the string to compare paths against\n * @param caseSensitive if true, this PathFilter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public StartsWithPathFilter(String s, boolean caseSensitive, boolean inverted) {\n super(new PathGenerator(), s, caseSensitive, inverted);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/StringCriterionFilter.java",
"content": "package com.mucommander.commons.file.filter;\n\n/**\n * @author Maxence Bernard\n */\npublic interface StringCriterionFilter extends CriterionFiltertrue if this CriterionFilter is case-sensitive.\n *\n * @return true if this CriterionFilter is case-sensitive.\n */\n boolean isCaseSensitive();\n\n /**\n * Specifies whether this CriterionFilter should be case-sensitive or not when comparing paths.\n *\n * @param caseSensitive if true, this CriterionFilter will be case-sensitive\n */\n void setCaseSensitive(boolean caseSensitive);\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/filter/WildcardFileFilter.java",
"content": "/*\n * This file is part of trolCommander, http://www.trolsoft.ru/en/soft/trolcommander\n * Copyright (C) 2013-2016 Oleg Trifonov\n *\n * trolCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * trolCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see WildcardFileFilter operating in non-inverted mode.\n *\n * @param s the wildcard to match\n */\n public WildcardFileFilter(String s) {\n this(s, false, false);\n }\n\n /**\n * Creates a new WildcardFileFilter operating in non-inverted mode.\n *\n * @param s the wildcard to match\n * @param caseSensitive if true, this FilenameFilter will be case-sensitive\n */\n public WildcardFileFilter(String s, boolean caseSensitive) {\n this(s, caseSensitive, false);\n }\n\n /**\n * Creates a new WildcardFileFilter operating in the specified mode.\n *\n * @param s the wildcard to match\n * @param caseSensitive if true, this FilenameFilter will be case-sensitive\n * @param inverted if true, this filter will operate in inverted mode.\n */\n public WildcardFileFilter(String s, boolean caseSensitive, boolean inverted) {\n super(new FilenameGenerator(), caseSensitive, inverted);\n this.fileFilter = org.apache.commons.io.filefilter.WildcardFileFilter.builder().setWildcards(s).setIoCase(isCaseSensitive() ? IOCase.SENSITIVE : IOCase.INSENSITIVE).get();\n }\n\n\n @Override\n public boolean accept(String value) {\n return fileFilter.accept(new File(value));\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/icon/CacheableFileIconProvider.java",
"content": "package com.mucommander.commons.file.icon;\n\nimport com.mucommander.commons.file.AbstractFile;\n\nimport javax.swing.*;\nimport java.awt.*;\n\n/**\n * CacheableFileIconProvider is an interface to be implemented by file icon providers that wish to use\n * some icon caching to improve performance. This interface is to be used in conjunction with {@link CachedFileIconProvider}\n * to form a functional cached provider.\n *\n * @author Maxence Bernard\n */\npublic interface CacheableFileIconProvider extends FileIconProvider {\n\n /**\n * Returns true if the icon cache can be used for the specified file and preferred resolution. This\n * method allows the icon cache to be used only for certain types of files and/or preferred resolutions.\n *\n * true is returned, the icon cache will be looked up with\n * {@link #lookupCache(com.mucommander.commons.file.AbstractFile, java.awt.Dimension)} and if the cache did not return\n * an icon, the icon will be added to the cache with {@link #addToCache(com.mucommander.commons.file.AbstractFile, javax.swing.Icon, java.awt.Dimension)}.\n *
\n * On the other hand, if false is returned, {@link #getFileIcon(com.mucommander.commons.file.AbstractFile, java.awt.Dimension)}\n * will simply be called, without querying or adding to the cache.\n *\n * @param file the file for which to retrieve an icon\n * @param preferredResolution the preferred resolution for the icon\n * @return true if the icon cache can be used with the specified file\n */\n boolean isCacheable(AbstractFile file, Dimension preferredResolution);\n\n /**\n * This method is called by {@link CachedFileIconProvider#getFileIcon(com.mucommander.commons.file.AbstractFile, java.awt.Dimension)}\n * to perform a cache lookup and give implementations a chance to re-use a cached icon. If a non-null value is\n * returned, the returned icon will be used.\n *
\n * On the other hand, if null is returned, the icon will be fetched using {@link #getFileIcon(com.mucommander.commons.file.AbstractFile, java.awt.Dimension)}\n * followed by a call to {@link #addToCache(com.mucommander.commons.file.AbstractFile, javax.swing.Icon,java.awt.Dimension)}\n * to add the freshly-retrieved icon to the cache.\n *\n * true.\n *\n * @param file the file for which to look for a previously cached icon\n * @param preferredResolution the preferred resolution for the icon\n * @return a cached icon to re-use, null if there is none\n */\n Icon lookupCache(AbstractFile file, Dimension preferredResolution);\n\n /**\n * This method is called by {@link CachedFileIconProvider#getFileIcon(com.mucommander.commons.file.AbstractFile, java.awt.Dimension)}\n * to give implementations a chance to cache an icon fetched with {@link #getFileIcon(com.mucommander.commons.file.AbstractFile, java.awt.Dimension)}\n * and have it returned later by {@link #lookupCache(com.mucommander.commons.file.AbstractFile, java.awt.Dimension)}.\n *
\n * There is no obligation for this method to cache the given icon, implementations may freely choose whether to\n * cache certain icons only.\n *\n * true.\n *\n * @param file the file that corresponds to the given icon\n * @param icon the icon to add to the cache\n * @param preferredResolution the preferred icon resolution that was originally requested\n */\n void addToCache(AbstractFile file, Icon icon, Dimension preferredResolution);\n\n void cleanCache();\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/icon/CachedFileIconProvider.java",
"content": "package com.mucommander.commons.file.icon;\n\nimport com.mucommander.bookmark.Bookmark;\nimport com.mucommander.bookmark.BookmarkManager;\nimport com.mucommander.commons.file.AbstractFile;\nimport com.mucommander.commons.file.FileFactory;\nimport com.mucommander.ui.icon.FileIcons;\n\nimport javax.swing.*;\nimport java.awt.*;\n\n/**\n * CachedFileIconProvider is a FileIconProvider with caching capabilities.\n *\n *
\n * When an icon is requested, a cache lookup is performed. If a cached value is found, it is returned. If not, the icon\n * is fetched from the underlying provider and added to the cache.\n *\n * @author Maxence Bernard\n */\npublic class CachedFileIconProvider implements FileIconProvider {\n\n /** The underlying icon provider and cache manager */\n protected CacheableFileIconProvider cacheableFip;\n\n\n /**\n * Creates a new CachedFileIconProvider that uses the given {@link CacheableFileIconProvider} to access the cache\n * and retrieve the icons.\n *\n * @param cacheableFip the underlying icon provider and cache manager\n */\n public CachedFileIconProvider(CacheableFileIconProvider cacheableFip) {\n this.cacheableFip = cacheableFip;\n }\n\n /**\n * Creates and returns a {@link IconCache} instance.\n *\n * @return a new {@link IconCache} instance\n */\n public static IconCache createCache() {\n return new IconCache();\n }\n\n\n /**\n * Implementation notes: this method first calls {@link CacheableFileIconProvider#isCacheable(com.mucommander.commons.file.AbstractFile, java.awt.Dimension)}\n * to determine if the icon cache is used.\n *\n * CacheableFileIconProvider\n * to retrieve the icon. This icon is then added to the cache by calling\n * {@link CacheableFileIconProvider#addToCache(com.mucommander.commons.file.AbstractFile, javax.swing.Icon, java.awt.Dimension)}.\n *\n * CacheableFileIconProvider and its value returned.\n */\n @Override\n public Icon getFileIcon(AbstractFile file, Dimension preferredResolution) {\n boolean isCacheable = cacheableFip.isCacheable(file, preferredResolution);\n\n if (BookmarkManager.isBookmark(file)) {\n for (Bookmark bookmark : BookmarkManager.getBookmarks()) {\n if (file.getName().equals(bookmark.getName())) {\n // Note: if several bookmarks match current folder, the first one will be used\n file = FileFactory.getFile(bookmark.getLocation());\n //return getFileIcon(file, preferredResolution);\n return FileIcons.getFileIcon(file, preferredResolution);\n }\n }\n }\n\n // Look for the file icon in the provider's cache\n Icon icon = isCacheable ? cacheableFip.lookupCache(file, preferredResolution) : null;\n\n // Icon is not cacheable or isn't present in the cache, retrieve it from the provider\n if (icon == null) {\n icon = cacheableFip.getFileIcon(file, preferredResolution);\n\n // Cache the icon\n if (isCacheable && icon != null) {\n cacheableFip.addToCache(file, icon, preferredResolution);\n }\n }\n\n return icon;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/icon/FileIconProvider.java",
"content": "package com.mucommander.commons.file.icon;\n\nimport com.mucommander.commons.file.AbstractFile;\n\nimport javax.swing.*;\nimport java.awt.*;\n\n/**\n * FileIconProvider provides a standard interface for retrieving file icons. Icon providers can fetch icons from any\n * type of source, whether they be some API or a set of icon images. There is no requirement on the resolution in which\n * the icons are provided, nor on the set of file criteria used to select the icon (file kind, name, size, ...).\n * Implementations should however be able to return icons for any type of {@link AbstractFile}.\n * The specialized {@link com.mucommander.commons.file.icon.LocalFileIconProvider} class can come in handy for icon sources\n * that can only cope with local files.\n *\n * @see com.mucommander.commons.file.FileFactory#getDefaultFileIconProvider()\n * @author Maxence Bernard\n */\npublic interface FileIconProvider {\n\n /**\n * Returns an icon for the given file, or null if it couldn't be retrieved, either because the\n * given file doesn't exist or for any other reason.\n *\n * Dimension is used as a hint at the preferred icon's resolution; there is\n * absolutely no guarantee that the returned Icon will indeed have this resolution. This dimension is\n * only used to choose between different resolutions should more than one resolution be available, and return the\n * one that most closely matches the specified one.
\n * The implementation is not expected to perform any rescaling (either up or down), this method should only return\n * icons in their 'native' resolutions, using the preferred resolution to choose between different native dimensions.\n * For example, if this provider is able to create icons both in 16x16 and 32x32 resolutions, and a 48x48 resolution\n * is preferred, the 32x32 resolution should be favored as it is closer to 32x32.\n *\n * @param file the AbstractFile instance for which an icon is requested\n * @param preferredResolution the preferred icon resolution\n * @return an icon for the requested file\n */\n Icon getFileIcon(AbstractFile file, Dimension preferredResolution);\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/icon/IconCache.java",
"content": "/*\n * This file is part of muCommander, http://www.mucommander.com\n * Copyright (C) 2002-2010 Maxence Bernard\n *\n * muCommander is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * muCommander is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program. If not, see Object keys onto {@link Icon} instances.\n * Any kind of Object may be used as the key: a file, a URL, an extension, ... allowing different of icon caching\n * strategies to be implemented.\n *\n * Apache Commons Collection library.\n * All accesses to the underlying map is synchronized, making this cache thread-safe.\n *\n * @author Maxence Bernard\n */\npublic class IconCache {\n\n /** The actual hash map */\n private final ReferenceMapnull if no\n * such mapping existed\n */\n public synchronized Icon put(Object key, Icon value) {\n return hashMap.put(key, value);\n }\n\n /**\n * Returns the {@link Icon} instance mapped onto the given key if there is one,\n * null otherwise\n *\n * @param key key of the icon instance to retrieve\n * @return the {@link Icon} instance mapped onto the given key if there is one,\n * null otherwise\n */\n public synchronized Icon get(Object key) {\n return hashMap.get(key);\n }\n\n /**\n * Returns true if this cache currently contains a key/icon mapping where the given key is used as\n * the mapping's key.\n *\n * @param key key to lookup\n * @return true if this cache currently contains a key/icon mapping where the given key is used as\n * the mapping's key.\n */\n public synchronized boolean containsKey(Object key) {\n return hashMap.containsKey(key);\n }\n\n /**\n * Returns true if this cache currently contains a key/icon mapping where the given icon is used as\n * the mapping's value.\n *\n * @param icon icon to lookup\n * @return true if this cache currently contains a key/icon mapping where the given icon is used as\n * the mapping's key.\n */\n public synchronized boolean containsValue(Icon icon) {\n return hashMap.containsValue(icon);\n }\n\n /**\n * Removes all existing key/icon mapping from this cache, leaving the cache in the same state as it was right after\n * its creation.\n */\n public synchronized void clear() {\n hashMap.clear();\n }\n\n /**\n * Returns the number of key/icon mapping this cache currently contains.\n *\n * @return the number of key/icon mapping this cache currently contains.\n */\n public synchronized int size() {\n return hashMap.size();\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/icon/LocalFileIconProvider.java",
"content": "package com.mucommander.commons.file.icon;\n\nimport com.mucommander.commons.file.AbstractFile;\nimport com.mucommander.commons.file.FileFactory;\nimport com.mucommander.commons.file.impl.local.LocalFile;\n\nimport javax.swing.*;\nimport java.awt.*;\nimport java.io.IOException;\n\n/**\n * LocalFileIconProvider is an abstract {@link FileIconProvider} which makes things easier for\n * implementations that are only able to provide icons for local files.\n *\n * null if the temporary file/directory could not be created.\n *\n * @param nonLocalFile the non-local file for which to create a temporary file.\n * @return a temporary local file/directory with the same extension as the specified file/directory\n */\n private LocalFile createTempLocalFile(AbstractFile nonLocalFile) {\n try {\n // Note: the returned temporary file may be an AbstractArchiveFile if the filename's extension corresponds\n // to a registered archive format\n LocalFile tempFile = FileFactory.getTemporaryFile(nonLocalFile.getName(), false).getAncestor(LocalFile.class);\n if (tempFile == null) {\n return null;\n }\n // create a directory\n if (nonLocalFile.isDirectory()) {\n tempFile.mkdir();\n } else { // create a regular file\n tempFile.getOutputStream().close();\n }\n return tempFile;\n } catch (IOException e) {\n return null;\n }\n }\n\n\n /////////////////////////////////////\n // FileIconProvider implementation //\n /////////////////////////////////////\n\n public Icon getFileIcon(AbstractFile originalFile, Dimension preferredResolution) {\n if (originalFile == null) {\n return null;\n }\n // Specified file is a LocalFile or a ProxyFile proxying a LocalFile (e.g. an archive file): let's simply get\n // the icon using #getLocalFileIcon(LocalFile)\n AbstractFile topFile = originalFile.getTopAncestor();\n\n if (topFile instanceof LocalFile) {\n return getLocalFileIcon((LocalFile)topFile, originalFile, preferredResolution);\n }\n // File is a remote file: create a temporary local file (or directory) with the same extension to grab the icon\n // and then delete the file. This operation is I/O bound and thus expensive, so an LRU is used to cache\n // frequently-accessed file extensions.\n\n LocalFile tempFile = createTempLocalFile(topFile);\n if (tempFile == null) {\n // No temp file, no icon!\n return null;\n }\n\n // Get the file icon\n Icon icon = getLocalFileIcon(tempFile, originalFile, preferredResolution);\n\n // Delete the temporary file\n try {\n tempFile.delete();\n } catch (IOException e) {\n // Not much to do\n }\n\n return icon;\n }\n\n\n //////////////////////\n // Abstract methods //\n //////////////////////\n\n /**\n * Returns an icon for the given local file, null if the icon couldn't be retrieved. This method is\n * called by {@link #getFileIcon(com.mucommander.commons.file.AbstractFile, java.awt.Dimension)} with a {@link LocalFile}\n * equivalent to the {@link AbstractFile} originally requested.\n *\n * Dimension is used as a hint at the preferred icon's resolution; there is\n * absolutely no guarantee that the returned Icon will indeed have this resolution. This dimension is\n * only used to choose between different resolutions should more than one resolution be available, and return the\n * one that most closely matches the specified one.
\n * This method is not expected to perform any rescaling (either up or down), returned resolutions should only be\n * 'native' icon resolutions. For example, if this provider is able to create icons both in 16x16 and 32x32\n * resolutions, and a 48x48 resolution is preferred, the 32x32 resolution should be favored for the returned icon.\n *\n * @param localFile the LocalFile instance for which an icon is requested\n * @param originalFile the AbstractFile for which an icon was originally requested\n * @param preferredResolution the preferred icon resolution\n * @return an icon for the requested file\n */\n public abstract Icon getLocalFileIcon(LocalFile localFile, AbstractFile originalFile, Dimension preferredResolution);\n\n}"
},
{
"path": "src/main/java/com/mucommander/commons/file/icon/impl/SwingFileIconProvider.java",
"content": "package com.mucommander.commons.file.icon.impl;\n\nimport com.mucommander.commons.file.icon.CachedFileIconProvider;\nimport com.mucommander.commons.file.icon.LocalFileIconProvider;\n\n/**\n * This {@link LocalFileIconProvider} returns system file icons fetched from the Swing API. Those icons are only\n * available under one resolution, usually 16x16 but this may vary across platforms.\n *\n * \n *
\n * Those classes are only capable of returning icons for javax.swing.filechooser.FileSystemView: used on all platforms but Mac OS Xjavax.swing.JFileChooser: used on Mac OS X onlyjava.io.File instances, thus only work with local\n * files. {@link com.mucommander.commons.file.icon.LocalFileIconProvider} provides transparent creation of local temporary file\n * to handle non-local files.
\n * It is also noteworthy that those Swing classes maintain an icon cache. Therefore, local file icons are not cached,\n * only non-local files (remote protocol or archive entries) have their icons cached to avoid excessive temporary file\n * creation, using their extension as the cache's key.\n *\n * @author Maxence Bernard\n */\npublic class SwingFileIconProvider extends CachedFileIconProvider {\n\n public SwingFileIconProvider() {\n super(new SwingFileIconProviderImpl());\n }\n\n /**\n * This method forces the initialization of the Swing object that is used to retrieve file icons the first time it\n * is called, does nothing on subsequent calls.\n * java.io.File using the underlying Swing provider component,\n * null in case of an error.\n *\n * @param javaIoFile the file for which to return an icon\n * @return an icon for the specified file, null in case of an unexpected error\n */\n private static Icon getSwingIcon(File javaIoFile, int preferredSize) {\n try {\n if (fileSystemView != null) {\n // FileSystemView.getSystemIcon() will behave in the following way if the specified file doesn't exist\n // when the icon is requested:\n // - throw a NullPointerException (caused by a java.io.FileNotFoundException) => OK why not\n // - dump the stack trace to System.err => bad! bad! bad!\n //\n // A way to workaround this odd behavior would be to test if the file exists when it is requested,\n // but a/ this is an expensive operation (especially under Windows) and b/ it wouldn't guarantee that\n // the file effectively exists when the icon is requested.\n // So the workaround here is to catch exceptions and 'silence' System.err output during the call.\n\n errOut.setSilenced(true);\n return fileSystemView.getSystemIcon(javaIoFile);\n } else {\n if (fileChooser == null) {\n if (RetinaImageIcon.IS_RETINA) {\n Icon icon = OSXFile.getIcon(javaIoFile, preferredSize*2);\n if (icon instanceof ImageIcon imageIcon) {\n return new RetinaImageIcon(imageIcon.getImage());\n }\n }\n return OSXFile.getIcon(javaIoFile, preferredSize);\n }\n return fileChooser.getIcon(javaIoFile);\n }\n } catch (Exception e) {\n log.info(\"Caught exception while retrieving system icon for file {}\", javaIoFile.getAbsolutePath(), e);\n return null;\n } finally {\n if (fileSystemView != null) {\n errOut.setSilenced(false);\n }\n }\n }\n\n\n /**\n * Returns an icon symbolizing a symlink to the given target icon. The returned icon uses the specified icon as\n * its background and overlays a 'link' icon on top of it.\n *\n * @param targetFileIcon the icon representing the symlink's target\n * @return an icon symbolizing a symlink to the given target\n */\n private static ImageIcon getSymlinkIcon(Icon targetFileIcon) {\n BufferedImage bi = new BufferedImage(targetFileIcon.getIconWidth(), targetFileIcon.getIconHeight(), BufferedImage.TYPE_INT_ARGB);\n\n Graphics g = bi.getGraphics();\n targetFileIcon.paintIcon(null, g, 0, 0);\n SYMLINK_OVERLAY_ICON.paintIcon(null, g, 0, 0);\n\n return new ImageIcon(bi);\n }\n\n /**\n * Returns the extension of the given file using {@link AbstractFile#getExtension()}. If the extension is\n * null, the empty string \"\" is returned, making the returned extension safe for use\n * in a hash map where null keys are forbidden.\n *\n * @param file file on which to call {@link AbstractFile#getExtension}\n * @return the file's extension, may be the empty string but never null\n */\n private static String getCheckedExtension(AbstractFile file) {\n String extension = file.getExtension();\n return extension == null ? \"\" : extension;\n }\n\n\n /**\n * Implementation notes: returns false (no caching) for:\n * \n *
\n * true is returned for non-local files that are not symlinks to avoid excessive temporary file\n * creation.\n */\n @Override\n public boolean isCacheable(AbstractFile file, Dimension preferredResolution) {\n return file != null && !((file.getTopAncestor() instanceof LocalFile) || file.isSymlink());\n }\n\n @Override\n public Icon lookupCache(AbstractFile file, Dimension preferredResolution) {\n // Under Mac OS X, return the icon of /Network for the root of remote (non-local) locations. \n if (OsFamily.MAC_OS_X.isCurrent() && !FileProtocols.FILE.equals(file.getURL().getScheme()) && file.isRoot()) {\n return getSwingIcon(new File(\"/Network\"), preferredResolution.width);\n }\n // Look for an existing icon instance for the file's extension\n return (file.isDirectory()? directoryIconCache : fileIconCache).get(getCheckedExtension(file));\n }\n\n @Override\n public void addToCache(AbstractFile file, Icon icon, Dimension preferredResolution) {\n // Map the extension onto the given icon\n (file.isDirectory() ? directoryIconCache : fileIconCache).put(getCheckedExtension(file), icon);\n }\n\n /**\n * Implementation note: only one resolution is available (usually 16x16) and blindly returned, the\n * preferredResolution argument is simply ignored.\n */\n @Override\n public Icon getLocalFileIcon(LocalFile localFile, AbstractFile originalFile, Dimension preferredResolution) {\n // Initialize the Swing object the first time this method is called\n checkInit();\n\n // Retrieve the icon using the Swing provider component\n Icon icon = getSwingIcon((File)localFile.getUnderlyingFileObject(), preferredResolution.width);\n\n // Add a symlink indication to the icon if:\n // - the original file is a symlink AND\n // - the original file is not a local file OR\n // - the original file is a local file but the Swing component generates icons which do not have a symlink\n // indication. That is the case on Mac OS X 10.5 (regression, 10.4 did this just fine).\n //\n // Note that the symlink test is performed last because it is the most expensive.\n //\n if ((!(originalFile.getTopAncestor() instanceof LocalFile) || (OsFamily.MAC_OS_X.isCurrent() && OsVersion.MAC_OS_X_10_5.isCurrent()))\n && originalFile.isSymlink()) {\n icon = icon == null ? null : getSymlinkIcon(icon);\n }\n\n return icon;\n }\n\n public void cleanCache() {\n directoryIconCache.clear();\n fileIconCache.clear();\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/impl/CachedFile.java",
"content": "package com.mucommander.commons.file.impl;\r\n\r\nimport com.mucommander.commons.file.AbstractFile;\r\nimport com.mucommander.commons.file.FileOperation;\r\nimport com.mucommander.commons.file.FilePermissions;\r\nimport com.mucommander.commons.file.FileProtocols;\r\nimport com.mucommander.commons.file.filter.FileFilter;\r\nimport com.mucommander.commons.file.filter.FilenameFilter;\r\nimport com.mucommander.commons.file.impl.local.LocalFile;\r\nimport com.mucommander.commons.runtime.OsFamily;\r\nimport lombok.extern.slf4j.Slf4j;\r\nimport ru.trolsoft.jni.NativeFileUtils;\r\n\r\nimport java.io.File;\r\nimport java.io.IOException;\r\nimport java.lang.reflect.Field;\r\nimport java.lang.reflect.Method;\r\n\r\n/**\r\n * CachedFile is a ProxyFile that caches the return values of most {@link AbstractFile} getter methods. This allows\r\n * to limit the number of calls to the underlying file methods which can have a cost since they are often I/O bound.\r\n * The methods that are cached are those overridden by this class, except for the ls methods, which are\r\n * overridden only to allow recursion (see {@link #CachedFile(com.mucommander.commons.file.AbstractFile, boolean)}).\r\n *\r\n * isFileOperationSupported method\r\n */\r\n private int supportedOperationsValuesMask;\r\n private int supportedOperationsCachedMask;\r\n\r\n\r\n\r\n static {\r\n // Exposes the java.io.FileSystem class which by default has package access, in order to use its\r\n // 'getBooleanAttributes' method to speed up access to file attributes under Windows.\r\n // This method allows to retrieve the values of the 'exists', 'isDirectory' and 'isHidden' attributes in one\r\n // pass, resolving the underlying file only once instead of 3 times. Since resolving a file is a particularly\r\n // expensive operation under Windows due to improper use of the Win32 API, this helps speed things up a little.\r\n // References:\r\n // - http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5036988\r\n // - http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6240028\r\n //\r\n // This hack was made for Windows, but is now used for other platforms as well as it is necessarily faster than\r\n // retrieving file attributes individually.\r\n boolean getFileAttributesAvailable;\r\n Method mGetBooleanAttributes;\r\n int baExists, baDirectory, baHidden;\r\n Object fs;\r\n\r\n if (NATIVE_FILE_UTILS_AVAILABLE) {\r\n getFileAttributesAvailable = true;\r\n mGetBooleanAttributes = null;\r\n baExists = 0;\r\n baDirectory = 0;\r\n baHidden = 0;\r\n fs = null;\r\n } else {\r\n try {\r\n // Resolve FileSystem class, 'getBooleanAttributes' method and fields\r\n Class cFile = File.class;\r\n Class cFileSystem = Class.forName(\"java.io.FileSystem\");\r\n mGetBooleanAttributes = cFileSystem.getDeclaredMethod(\"getBooleanAttributes\", cFile);\r\n Field fBA_EXISTS = cFileSystem.getDeclaredField(\"BA_EXISTS\");\r\n Field fBA_DIRECTORY = cFileSystem.getDeclaredField(\"BA_DIRECTORY\");\r\n Field fBA_HIDDEN = cFileSystem.getDeclaredField(\"BA_HIDDEN\");\r\n Field fFs;\r\n try {\r\n fFs = cFile.getDeclaredField(\"FS\");\r\n } catch (NoSuchFieldException e) {\r\n fFs = cFile.getDeclaredField(\"fs\");\r\n }\r\n\r\n // Allow access to the 'getBooleanAttributes' method and to the fields we're interested in\r\n mGetBooleanAttributes.setAccessible(true);\r\n fFs.setAccessible(true);\r\n\r\n fBA_EXISTS.setAccessible(true);\r\n fBA_DIRECTORY.setAccessible(true);\r\n fBA_HIDDEN.setAccessible(true);\r\n\r\n // Retrieve constant field values once for all\r\n baExists = (Integer) fBA_EXISTS.get(null);\r\n baDirectory = (Integer) fBA_DIRECTORY.get(null);\r\n baHidden = (Integer) fBA_HIDDEN.get(null);\r\n fs = fFs.get(null);\r\n getFileAttributesAvailable = true;\r\n log.trace(\"Access to java.io.FileSystem granted\");\r\n } catch (Exception e) {\r\n getFileAttributesAvailable = false;\r\n mGetBooleanAttributes = null;\r\n baExists = 0;\r\n baDirectory = 0;\r\n baHidden = 0;\r\n fs = null;\r\n log.info(\"Error while allowing access to java.io.FileSystem\", e);\r\n }\r\n }\r\n GET_FILE_ATTRIBUTES_AVAILABLE = getFileAttributesAvailable;\r\n M_GET_BOOLEAN_ATTRIBUTES = mGetBooleanAttributes;\r\n BA_EXISTS = baExists;\r\n BA_DIRECTORY = baDirectory;\r\n BA_HIDDEN = baHidden;\r\n FS = fs;\r\n }\r\n\r\n\r\n /**\r\n * Creates a new CachedFile instance around the specified AbstractFile, caching returned values of cached methods\r\n * as they are called. If recursion is enabled, the methods returning AbstractFile will return CachedFile instances,\r\n * allowing the cache files recursively.\r\n *\r\n * @param file the AbstractFile instance for which returned values of getter methods should be cached\r\n * @param recursiveInstances if true, AbstractFile instances returned by this class will be wrapped into CachedFile instances\r\n */\r\n public CachedFile(AbstractFile file, boolean recursiveInstances) {\r\n super(file);\r\n if (recursiveInstances) {\r\n bitmask |= RECURSE_INSTANCES_MASK;\r\n }\r\n }\r\n\r\n\r\n /**\r\n * Creates a CachedFile instance for each of the AbstractFile instances in the given array.\r\n */\r\n private AbstractFile[] createCachedFiles(AbstractFile[] files) {\r\n int nbFiles = files.length;\r\n for (int i = 0; i < nbFiles; i++) {\r\n files[i] = new CachedFile(files[i], true);\r\n }\r\n\r\n return files;\r\n }\r\n\r\n\r\n /**\r\n * Pre-fetches values of {@link #isDirectory}, {@link #exists} and {@link #isHidden} for the given local file,\r\n * using the java.io.FileSystem#getBooleanAttributes(java.io.File) method.\r\n * The given {@link AbstractFile} must be a local file or a proxy to a local file ('file' protocol). This method\r\n * must only be called if the {@link #GET_FILE_ATTRIBUTES_AVAILABLE} field is true.\r\n */\r\n private void getFileAttributes(AbstractFile file) {\r\n file = file.getTopAncestor();\r\n\r\n if (file instanceof LocalFile) {\r\n if (NATIVE_FILE_UTILS_AVAILABLE) {\r\n initAttributesNativeCall(file);\r\n } else {\r\n initAttributesReflectionCall(file);\r\n }\r\n }\r\n }\r\n\r\n private void initAttributesReflectionCall(AbstractFile file) {\r\n try {\r\n int ba = (Integer) M_GET_BOOLEAN_ATTRIBUTES.invoke(FS, file.getUnderlyingFileObject());\r\n\r\n if ((ba & BA_DIRECTORY) != 0) {\r\n bitmask |= DIRECTORY_VALUE_MASK;\r\n } else {\r\n bitmask &= ~DIRECTORY_VALUE_MASK;\r\n }\r\n if ((ba & BA_EXISTS) != 0) {\r\n bitmask |= EXISTS_VALUE_MASK;\r\n } else {\r\n bitmask &= ~EXISTS_VALUE_MASK;\r\n }\r\n if ((ba & BA_HIDDEN) != 0) {\r\n bitmask |= HIDDEN_VALUE_MASK;\r\n } else {\r\n bitmask &= ~HIDDEN_VALUE_MASK;\r\n }\r\n bitmask |= DIRECTORY_SET_MASK | HIDDEN_SET_MASK | EXISTS_SET_MASK;\r\n } catch (Exception e) {\r\n log.info(\"Could not retrieve file attributes for {}\", file, e);\r\n }\r\n }\r\n\r\n private void initAttributesNativeCall(AbstractFile file) {\r\n int attr = NativeFileUtils.getLocalFileAttributes(file.getAbsolutePath());\r\n if ((attr & NativeFileUtils.FA_MASK_DIRECTORY) != 0) {\r\n bitmask |= DIRECTORY_VALUE_MASK;\r\n } else {\r\n bitmask &= ~DIRECTORY_VALUE_MASK;\r\n }\r\n if ((attr & NativeFileUtils.FA_MASK_EXISTS) != 0) {\r\n bitmask |= EXISTS_VALUE_MASK;\r\n } else {\r\n bitmask &= ~EXISTS_VALUE_MASK;\r\n }\r\n if ((attr & NativeFileUtils.FA_MASK_HIDDEN) != 0) {\r\n bitmask |= HIDDEN_VALUE_MASK;\r\n } else {\r\n bitmask &= ~HIDDEN_VALUE_MASK;\r\n }\r\n bitmask |= DIRECTORY_SET_MASK | HIDDEN_SET_MASK | EXISTS_SET_MASK;\r\n }\r\n\r\n\r\n ////////////////////////////////////////////////////\r\n // Overridden methods to cache their return value //\r\n ////////////////////////////////////////////////////\r\n\r\n @Override\r\n public long getSize() {\r\n if ((bitmask & SIZE_SET_MASK) == 0) {\r\n getSize = file.getSize();\r\n bitmask |= SIZE_SET_MASK;\r\n }\r\n return getSize;\r\n }\r\n\r\n @Override\r\n public long getLastModifiedDate() {\r\n if ((bitmask & LAST_MODIFICATION_SET_MASK) == 0) {\r\n getLastModified = file.getLastModifiedDate();\r\n bitmask |= LAST_MODIFICATION_SET_MASK;\r\n }\r\n return getLastModified;\r\n }\r\n\r\n @Override\r\n public long getCreationDate() throws IOException {\r\n if ((bitmask & CREATION_DATE_SET_MASK) == 0) {\r\n getCreationDate = file.getCreationDate();\r\n bitmask |= CREATION_DATE_SET_MASK;\r\n }\r\n return getCreationDate;\r\n }\r\n\r\n @Override\r\n public long getLastAccessDate() throws IOException {\r\n if ((bitmask & LAST_ACCESS_SET_MASK) == 0) {\r\n getLastAccessDate = file.getLastAccessDate();\r\n bitmask |= LAST_ACCESS_SET_MASK;\r\n }\r\n return getLastAccessDate;\r\n }\r\n\r\n @Override\r\n public boolean isSymlink() {\r\n if ((bitmask & SYMLINK_SET_MASK) == 0) {\r\n if (file.isSymlink()) {\r\n bitmask |= SYMLINK_VALUE_MASK;\r\n } else {\r\n bitmask &= ~SYMLINK_VALUE_MASK;\r\n }\r\n bitmask |= SYMLINK_SET_MASK;\r\n }\r\n return (bitmask & SYMLINK_VALUE_MASK) != 0;\r\n }\r\n\r\n @Override\r\n public boolean isDirectory() {\r\n if ((bitmask & DIRECTORY_SET_MASK) == 0) {\r\n if (isFileAttributesSupported()) {\r\n getFileAttributes(file);\r\n }\r\n // Note: getFileAttributes() might fail to retrieve file attributes, so we need to test isDirectorySet again\r\n if ((bitmask & DIRECTORY_SET_MASK) == 0) {\r\n if (file.isDirectory()) {\r\n bitmask |= DIRECTORY_VALUE_MASK;\r\n } else {\r\n bitmask &= ~DIRECTORY_VALUE_MASK;\r\n }\r\n bitmask |= DIRECTORY_SET_MASK;\r\n }\r\n }\r\n return (bitmask & DIRECTORY_VALUE_MASK) != 0;\r\n }\r\n\r\n private boolean isFileAttributesSupported() {\r\n return GET_FILE_ATTRIBUTES_AVAILABLE && FileProtocols.FILE.equals(file.getURL().getScheme());\r\n }\r\n\r\n @Override\r\n public boolean isArchive() {\r\n if ((bitmask & ARCHIVE_SET_MASK) == 0) {\r\n if (file.isArchive()) {\r\n bitmask |= ARCHIVE_VALUE_MASK;\r\n } else {\r\n bitmask &= ~ARCHIVE_VALUE_MASK;\r\n }\r\n bitmask |= ARCHIVE_SET_MASK;\r\n }\r\n return (bitmask & ARCHIVE_VALUE_MASK) != 0;\r\n }\r\n\r\n @Override\r\n public boolean isHidden() {\r\n if ((bitmask & HIDDEN_SET_MASK) == 0) {\r\n if (isFileAttributesSupported()) {\r\n getFileAttributes(file);\r\n }\r\n // Note: getFileAttributes() might fail to retrieve file attributes, so we need to test isDirectorySet again\r\n if ((bitmask & HIDDEN_SET_MASK) == 0) {\r\n if (file.isHidden()) {\r\n bitmask |= HIDDEN_VALUE_MASK;\r\n } else {\r\n bitmask &= ~HIDDEN_VALUE_MASK;\r\n }\r\n bitmask |= HIDDEN_SET_MASK;\r\n }\r\n }\r\n return (bitmask & HIDDEN_VALUE_MASK) != 0;\r\n }\r\n\r\n @Override\r\n public boolean isExecutable() {\r\n if ((bitmask & EXECUTABLE_SET_MASK) == 0) {\r\n if (file.isExecutable()) {\r\n bitmask |= EXECUTABLE_VALUE_MASK;\r\n } else {\r\n bitmask &= ~EXECUTABLE_VALUE_MASK;\r\n }\r\n bitmask |= EXECUTABLE_SET_MASK;\r\n }\r\n return (bitmask & EXECUTABLE_VALUE_MASK) != 0;\r\n }\r\n\r\n @Override\r\n public String getAbsolutePath() {\r\n if ((bitmask & ABSOLUTE_PATH_SET_MASK) == 0) {\r\n getAbsolutePath = file.getAbsolutePath();\r\n bitmask |= ABSOLUTE_PATH_SET_MASK;\r\n }\r\n return getAbsolutePath;\r\n }\r\n\r\n @Override\r\n public String getCanonicalPath() {\r\n if ((bitmask & CANONICAL_PATH_SET_MASK) == 0) {\r\n getCanonicalPath = file.getCanonicalPath();\r\n bitmask |= CANONICAL_PATH_SET_MASK;\r\n }\r\n return getCanonicalPath;\r\n }\r\n\r\n @Override\r\n public String getExtension() {\r\n if ((bitmask & EXTENSION_SET_MASK) == 0) {\r\n getExtension = file.getExtension();\r\n bitmask |= EXTENSION_SET_MASK;\r\n }\r\n return getExtension;\r\n }\r\n\r\n @Override\r\n public String getName() {\r\n if ((bitmask & NAME_SET_MASK) == 0) {\r\n getName = file.getName();\r\n bitmask |= NAME_SET_MASK;\r\n }\r\n return getName;\r\n }\r\n\r\n @Override\r\n public long getFreeSpace() throws IOException {\r\n if ((bitmask & FREE_SPACE_SET_MASK) == 0) {\r\n getFreeSpace = file.getFreeSpace();\r\n bitmask |= FREE_SPACE_SET_MASK;\r\n }\r\n return getFreeSpace;\r\n }\r\n\r\n @Override\r\n public long getTotalSpace() throws IOException {\r\n if ((bitmask & TOTAL_SPACE_SET_MASK) == 0) {\r\n getTotalSpace = file.getTotalSpace();\r\n bitmask |= TOTAL_SPACE_SET_MASK;\r\n }\r\n return getTotalSpace;\r\n }\r\n\r\n @Override\r\n public boolean exists() {\r\n if ((bitmask & EXISTS_SET_MASK) == 0) {\r\n if (isFileAttributesSupported()) {\r\n getFileAttributes(file);\r\n }\r\n // Note: getFileAttributes() might fail to retrieve file attributes, so we need to test isDirectorySet again\r\n if ((bitmask & EXISTS_SET_MASK) == 0) {\r\n if (file.exists()) {\r\n bitmask |= EXISTS_VALUE_MASK;\r\n } else {\r\n bitmask &= ~EXISTS_VALUE_MASK;\r\n }\r\n bitmask |= EXISTS_SET_MASK;\r\n }\r\n }\r\n return (bitmask & EXISTS_VALUE_MASK) != 0;\r\n }\r\n\r\n @Override\r\n public FilePermissions getPermissions() {\r\n if ((bitmask & PERMISSIONS_SET_MASK) == 0) {\r\n getPermissions = file.getPermissions();\r\n bitmask |= PERMISSIONS_SET_MASK;\r\n }\r\n return getPermissions;\r\n }\r\n\r\n @Override\r\n public String getPermissionsString() {\r\n if ((bitmask & PERMISSIONS_STRING_SET_MASK) == 0) {\r\n getPermissionsString = file.getPermissionsString();\r\n bitmask |= PERMISSIONS_STRING_SET_MASK;\r\n }\r\n return getPermissionsString;\r\n }\r\n\r\n @Override\r\n public String getOwner() {\r\n if ((bitmask & OWNER_SET_MASK) == 0) {\r\n getOwner = file.getOwner();\r\n bitmask |= OWNER_SET_MASK;\r\n }\r\n return getOwner;\r\n }\r\n\r\n @Override\r\n public String getGroup() {\r\n if ((bitmask & GROUP_SET_MASK) == 0) {\r\n getGroup = file.getGroup();\r\n bitmask |= GROUP_SET_MASK;\r\n }\r\n return getGroup;\r\n }\r\n\r\n @Override\r\n public boolean isRoot() {\r\n if ((bitmask & IS_ROOT_SET_MASK) == 0) {\r\n if (file.isRoot()) {\r\n bitmask |= IS_ROOT_VALUE_MASK;\r\n } else {\r\n bitmask &= ~IS_ROOT_VALUE_MASK;\r\n }\r\n bitmask |= IS_ROOT_SET_MASK;\r\n }\r\n return (bitmask & IS_ROOT_VALUE_MASK) != 0;\r\n }\r\n\r\n\r\n @Override\r\n public AbstractFile getParent() {\r\n if ((bitmask & PARENT_SET_MASK) == 0) {\r\n getParent = file.getParent();\r\n // create a CachedFile instance around the file if recursion is enabled\r\n if ((bitmask & RECURSE_INSTANCES_MASK) != 0 && getParent != null) {\r\n getParent = new CachedFile(getParent, true);\r\n }\r\n bitmask |= PARENT_SET_MASK;\r\n }\r\n return getParent;\r\n }\r\n\r\n @Override\r\n public AbstractFile getRoot() {\r\n if ((bitmask & GET_ROOT_SET_MASK) == 0) {\r\n getRoot = file.getRoot();\r\n // create a CachedFile instance around the file if recursion is enabled\r\n if ((bitmask & RECURSE_INSTANCES_MASK) != 0) {\r\n getRoot = new CachedFile(getRoot, true);\r\n }\r\n bitmask |= GET_ROOT_SET_MASK;\r\n }\r\n return getRoot;\r\n }\r\n\r\n @Override\r\n public AbstractFile getCanonicalFile() {\r\n if ((bitmask & CANONICAL_FILE_SET_MASK) == 0) {\r\n getCanonicalFile = file.getCanonicalFile();\r\n // create a CachedFile instance around the file if recursion is enabled\r\n if ((bitmask & RECURSE_INSTANCES_MASK) != 0) {\r\n // AbstractFile#getCanonicalFile() may return 'this' if the file is not a symlink. In that case,\r\n // no need to create a new CachedFile, simply use this one. \r\n if (getCanonicalFile == file) {\r\n getCanonicalFile = this;\r\n } else {\r\n getCanonicalFile = new CachedFile(getCanonicalFile, true);\r\n }\r\n }\r\n bitmask |= CANONICAL_FILE_SET_MASK;\r\n }\r\n return getCanonicalFile;\r\n }\r\n\r\n\r\n @Override\r\n public AbstractFile[] ls() throws IOException {\r\n // Don't cache ls() result but create a CachedFile instance around each of the files if recursion is enabled\r\n AbstractFile[] files = file.ls();\r\n\r\n if ((bitmask & RECURSE_INSTANCES_MASK) != 0) {\r\n return createCachedFiles(files);\r\n }\r\n\r\n return files;\r\n }\r\n\r\n @Override\r\n public AbstractFile[] ls(FileFilter filter) throws IOException {\r\n // Don't cache ls() result but create a CachedFile instance around each of the files if recursion is enabled\r\n AbstractFile[] files = file.ls(filter);\r\n\r\n if ((bitmask & RECURSE_INSTANCES_MASK) != 0) {\r\n return createCachedFiles(files);\r\n }\r\n\r\n return files;\r\n }\r\n\r\n @Override\r\n public AbstractFile[] ls(FilenameFilter filter) throws IOException {\r\n // Don't cache ls() result but create a CachedFile instance around each of the files if recursion is enabled\r\n AbstractFile[] files = file.ls(filter);\r\n\r\n if ((bitmask & RECURSE_INSTANCES_MASK) != 0) {\r\n return createCachedFiles(files);\r\n }\r\n\r\n return files;\r\n }\r\n\r\n\r\n @Override\r\n public boolean isFileOperationSupported(FileOperation op) {\r\n int bitMask = 1 << op.ordinal();\r\n if ((supportedOperationsCachedMask & bitMask) != 0) {\r\n return (supportedOperationsValuesMask & bitMask) != 0;\r\n }\r\n boolean result = super.isFileOperationSupported(op);\r\n if (result) {\r\n supportedOperationsValuesMask |= bitMask;\r\n }\r\n supportedOperationsCachedMask |= bitMask;\r\n return result;\r\n }\r\n}\r\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/impl/DebugFile.java",
"content": "package com.mucommander.commons.file.impl;\n\nimport com.mucommander.commons.file.AbstractFile;\nimport com.mucommander.commons.file.FilePermissions;\nimport java.io.IOException;\nimport java.util.Random;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\n/**\n * DebugFile is a {@link ProxyFile} to be used for debugging purposes. It allows to track the calls made to\n * {@link com.mucommander.commons.file.AbstractFile} methods that are commonly I/O-bound, by logging calls to each of those\n * methods. It also allows to slow those methods down to simulate a slow filesystem.\n *\n * @author Maxence Bernard\n */\npublic class DebugFile extends ProxyFile {\n private static final Logger LOGGER = LoggerFactory.getLogger(DebugFile.class);\n\n /** Maximum latency in milliseconds */\n private int maxLatency;\n\n /** Used to randomize the latency for each calls to slowed-down methods */\n private static final Random random = new Random();\n\n \n /**\n * Creates a DebugFile that proxies the calls made to the given AbstractFile's methods, with no latency.\n *\n * @param file the AbstractFile to proxy and debug\n */\n public DebugFile(AbstractFile file) {\n this(file, 0);\n }\n\n /**\n * Creates a DebugFile that proxies the calls made to the given AbstractFile and slows those methods down by\n * simulating latency by making I/O bound methods wait.\n *\n * @param file the AbstractFile to proxy and debug\n * @param maxLatency the maximum amount of latency in milliseconds\n */\n public DebugFile(AbstractFile file, int maxLatency) {\n super(file);\n \n this.maxLatency = maxLatency;\n }\n\n\n /**\n * Sets the the maximum amount of latency in milliseconds to add to calls made to IO-bound AbstractFile methods\n * (i.e. those that are overridden by this class). The latency is randomized for each method call and uniformly \n * distributed, the specified value serving as the maximum.\n *\n * @param maxLatency the maximum amount of latency in milliseconds to add to IO-bound AbstractFile method calls\n * (those overridden by this class).\n */\n public void setMaxLatency(int maxLatency) {\n this.maxLatency = maxLatency;\n }\n\n\n /**\n * Sleeps a random number of milliseconds, up to {@link #maxLatency}.\n */\n private void lag() {\n if (maxLatency > 0) {\n try {\n Thread.sleep(random.nextInt(maxLatency));\n } catch(InterruptedException ignored) {}\n }\n }\n\n /**\n * Returns the debug string printed for all calls made to the AbstractFile methods overridden by this class.\n */\n private String getDebugString() {\n return \"called on \"+super.getAbsolutePath()+\" (\"+file.getClass().getName()+\")\";\n }\n\n\n @Override\n public long getLastModifiedDate() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.getLastModifiedDate();\n }\n\n @Override\n public long getSize() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.getSize();\n }\n\n @Override\n public boolean exists() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.exists();\n }\n\n @Override\n public boolean isDirectory() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.isDirectory();\n }\n\n @Override\n public boolean isSymlink() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.isSymlink();\n }\n\n @Override\n public long getFreeSpace() throws IOException {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.getFreeSpace();\n }\n\n @Override\n public long getTotalSpace() throws IOException {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.getTotalSpace();\n }\n\n @Override\n public String getName() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.getName();\n }\n\n @Override\n public String getExtension() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.getExtension();\n }\n\n @Override\n public String getAbsolutePath() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.getAbsolutePath();\n }\n\n @Override\n public String getCanonicalPath() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.getCanonicalPath();\n }\n\n @Override\n public AbstractFile getCanonicalFile() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.getCanonicalFile();\n }\n\n @Override\n public boolean isArchive() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.isArchive();\n }\n\n @Override\n public boolean isHidden() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.isHidden();\n }\n\n @Override\n public FilePermissions getPermissions() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.getPermissions();\n }\n\n @Override\n public String getOwner() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.getOwner();\n }\n\n @Override\n public String getGroup() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.getGroup();\n }\n\n @Override\n public AbstractFile getRoot() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.getRoot();\n }\n\n @Override\n public boolean isRoot() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.isRoot();\n }\n\n @Override\n public boolean equalsCanonical(Object f) {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.equals(f);\n }\n\n public String toString() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.toString();\n }\n\n @Override\n public AbstractFile getParent() {\n LOGGER.trace(getDebugString());\n lag();\n\n return super.getParent();\n }\n\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/impl/ProxyFile.java",
"content": "package com.mucommander.commons.file.impl;\n\nimport com.mucommander.commons.file.*;\nimport com.mucommander.commons.file.filter.FileFilter;\nimport com.mucommander.commons.file.filter.FilenameFilter;\nimport com.mucommander.commons.io.FileTransferException;\nimport com.mucommander.commons.io.RandomAccessInputStream;\nimport com.mucommander.commons.io.RandomAccessOutputStream;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\nimport java.io.IOException;\nimport java.io.InputStream;\nimport java.io.OutputStream;\nimport java.io.PushbackInputStream;\nimport java.lang.reflect.Method;\nimport java.net.MalformedURLException;\nimport java.net.URL;\n\n/**\n * ProxyFile is an {@link AbstractFile} that acts as a proxy between the class that extends it\n * and the proxied AbstractFile instance specified to the constructor.\n * All AbstractFile public methods (abstract or not) are delegated to the proxied file.\n * The {@link #getProxiedFile()} method allows to retrieve the proxied file instance.\n *\n * AbstractFile instance (the proxied file).\n * By implementing/overriding every AbstractFile methods, ProxyFile ensures that\n * all AbstractFile methods can safely be used, even if they are overridden by the proxied\n * file instance's class.\n *\n * java.lang.reflect.Proxy class can unfortunately not be\n * used as it only works with interfaces (not abstract class). There doesn't seem to be any dynamic way to\n * proxy method invocations, so any modifications made to {@link com.mucommander.commons.file.AbstractFile} must be also\n * reflected in ProxyFile.\n *\n * @see com.mucommander.commons.file.AbstractArchiveFile\n * @author Maxence Bernard\n */\npublic abstract class ProxyFile extends AbstractFile {\n private static Logger logger;\n\n /** The proxied file instance */\n protected AbstractFile file;\n\n\n /**\n * Creates a new ProxyFile using the given file to delegate AbstractFile method calls to.\n *\n * @param file the file to be proxied\n */\n public ProxyFile(AbstractFile file) {\n super(file.getURL());\n this.file = file;\n }\n\n /**\n * Returns the AbstractFile instance proxied by this ProxyFile.\n *\n * @return the AbstractFile instance proxied by this ProxyFile\n */\n public AbstractFile getProxiedFile() {\n return file;\n }\n\n\n @Override\n public long getLastModifiedDate() {\n return file.getLastModifiedDate();\n }\n\n @Override\n public void setLastModifiedDate(long lastModified) throws IOException {\n file.setLastModifiedDate(lastModified);\n }\n\n @Override\n public long getSize() {\n return file.getSize();\n }\n\n @Override\n public AbstractFile getParent() {\n return file.getParent();\n }\n\n @Override\n public void setParent(AbstractFile parent) {\n file.setParent(parent);\n }\n\n @Override\n public boolean exists() {\n return file.exists();\n }\n\n @Override\n public void changePermission(int access, int permission, boolean enabled) throws IOException {\n file.changePermission(access, permission, enabled);\n }\n\n @Override\n public String getOwner() {\n return file.getOwner();\n }\n\n @Override\n public boolean canGetOwner() {\n return file.canGetOwner();\n }\n\n @Override\n public String getGroup() {\n return file.getGroup();\n }\n\n @Override\n public boolean canGetGroup() {\n return file.canGetGroup();\n }\n\n @Override\n public boolean isDirectory() {\n return file.isDirectory();\n }\n\n @Override\n public boolean isSymlink() {\n return file.isSymlink();\n }\n\n @Override\n public boolean isSystem() {\n return file.isSystem();\n }\n\n @Override\n public AbstractFile[] ls() throws IOException {\n return file.ls();\n }\n\n @Override\n public void mkdir() throws IOException {\n file.mkdir();\n }\n\n @Override\n public InputStream getInputStream() throws IOException {\n return file.getInputStream();\n }\n\n @Override\n public OutputStream getOutputStream() throws IOException {\n return file.getOutputStream();\n }\n\n @Override\n public OutputStream getAppendOutputStream() throws IOException {\n return file.getAppendOutputStream();\n }\n\n @Override\n public RandomAccessInputStream getRandomAccessInputStream() throws IOException {\n return file.getRandomAccessInputStream();\n }\n\n @Override\n public RandomAccessOutputStream getRandomAccessOutputStream() throws IOException {\n return file.getRandomAccessOutputStream();\n }\n\n @Override\n public void delete() throws IOException {\n file.delete();\n }\n\n @Override\n public void copyRemotelyTo(AbstractFile destFile) throws IOException {\n file.copyRemotelyTo(destFile);\n }\n\n @Override\n public void renameTo(AbstractFile destFile) throws IOException {\n file.renameTo(destFile);\n }\n\n @Override\n public long getFreeSpace() throws IOException {\n return file.getFreeSpace();\n }\n\n @Override\n public long getTotalSpace() throws IOException {\n return file.getTotalSpace();\n }\n\n @Override\n public Object getUnderlyingFileObject() {\n return file.getUnderlyingFileObject();\n }\n\n \n /////////////////////////////////////\n // Overridden AbstractFile methods //\n /////////////////////////////////////\n\n @Override\n public boolean isFileOperationSupported(FileOperation op) {\n Class thisClass = getClass();\n Method opMethod = op.getCorrespondingMethod(thisClass);\n // If the method corresponding to the file operation has been overridden by this class (a ProxyFile subclass),\n // check the presence of the UnsupportedFileOperation annotation in this class.\n try {\n if (!thisClass.getMethod(opMethod.getName(), opMethod.getParameterTypes()).getDeclaringClass().equals(ProxyFile.class)) {\n return AbstractFile.isFileOperationSupported(op, thisClass);\n }\n } catch(Exception e) {\n // Should never happen, unless AbstractFile method signatures have changed and FileOperation has not been updated\n getLogger().warn(\"Exception caught, this should not have happened\", e);\n }\n\n // Otherwise, check for the presence of the UnsupportedFileOperation annotation in the wrapped AbstractFile.\n return file.isFileOperationSupported(op);\n }\n\n @Override\n public FileURL getURL() {\n return file.getURL();\n }\n\n @Override\n public URL getJavaNetURL() throws MalformedURLException {\n return file.getJavaNetURL();\n }\n\n @Override\n public String getName() {\n return file.getName();\n }\n\n @Override\n public String getExtension() {\n return file.getExtension();\n }\n\n @Override\n public String getBaseName() {\n \treturn file.getBaseName();\n }\n \n @Override\n public String getAbsolutePath() {\n return file.getAbsolutePath();\n }\n\n @Override\n public String getCanonicalPath() {\n return file.getCanonicalPath();\n }\n\n @Override\n public AbstractFile getCanonicalFile() {\n return file.getCanonicalFile();\n }\n\n @Override\n public String getSeparator() {\n return file.getSeparator();\n }\n\n @Override\n public boolean isArchive() {\n return file.isArchive();\n }\n\n @Override\n public boolean isHidden() {\n return file.isHidden();\n }\n\n @Override\n public FilePermissions getPermissions() {\n return file.getPermissions();\n }\n\n @Override\n public void changePermissions(int permissions) throws IOException {\n file.changePermissions(permissions);\n }\n\n @Override\n public PermissionBits getChangeablePermissions() {\n return file.getChangeablePermissions();\n }\n\n @Override\n public String getPermissionsString() {\n return file.getPermissionsString();\n }\n\n @Override\n public AbstractFile getRoot() {\n return file.getRoot();\n }\n\n @Override\n public boolean isRoot() {\n return file.isRoot();\n }\n\n @Override\n public AbstractFile getVolume() {\n return file.getVolume();\n }\n\n @Override\n public InputStream getInputStream(long offset) throws IOException {\n return file.getInputStream(offset);\n }\n\n @Override\n public void copyStream(InputStream in, boolean append, long length) throws FileTransferException {\n file.copyStream(in, append, length);\n }\n\n @Override\n public AbstractFile[] ls(FileFilter filter) throws IOException {\n return file.ls(filter);\n }\n\n @Override\n public AbstractFile[] ls(FilenameFilter filter) throws IOException {\n return file.ls(filter);\n }\n\n @Override\n public void mkfile() throws IOException {\n file.mkfile();\n }\n\n @Override\n public void deleteRecursively() throws IOException {\n file.deleteRecursively();\n }\n\n @Override\n public boolean equals(Object f) {\n return file.equals(f);\n }\n\n @Override\n public boolean equalsCanonical(Object f) {\n return file.equalsCanonical(f);\n }\n\n public int hashCode() {\n return file.hashCode();\n }\n\n public String toString() {\n return file.toString();\n }\n\n @Override\n public short getReplication() throws UnsupportedFileOperationException {\n return file.getReplication();\n }\n\n @Override\n public long getBlocksize() throws UnsupportedFileOperationException {\n return file.getBlocksize();\n }\n\n @Override\n public void changeReplication(short replication) throws IOException {\n file.changeReplication(replication);\n }\n\n @Override\n public boolean isExecutable() {\n \treturn file.isExecutable();\n }\n\n @Override\n public PushbackInputStream getPushBackInputStream(int bufferSize) throws IOException {\n \treturn file.getPushBackInputStream(bufferSize);\n }\n\n @Override\n public void closePushbackInputStream() throws IOException {\n \tfile.closePushbackInputStream();\n }\n\n @Override\n public boolean isLocalFile() {\n return super.isLocalFile();\n }\n\n @Override\n public long getCreationDate() throws IOException {\n return super.getCreationDate();\n }\n\n @Override\n public long getLastAccessDate() throws IOException {\n return super.getLastAccessDate();\n }\n\n @Override\n public boolean canRead() {\n return file.canRead();\n }\n\n private static Logger getLogger() {\n if (logger == null) {\n logger = LoggerFactory.getLogger(ProxyFile.class);\n }\n return logger;\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/impl/SevenZipJBindingROArchiveFile.java",
"content": "package com.mucommander.commons.file.impl;\r\n\r\nimport com.mucommander.commons.file.*;\r\nimport com.mucommander.commons.file.impl.sevenzip.SevenZipArchiveFile.ExtractCallback;\r\nimport com.mucommander.commons.file.impl.sevenzip.SignatureCheckedRandomAccessFile;\r\nimport com.mucommander.commons.file.impl.sevenzip.multivolume.InArchiveWrapper;\r\nimport com.mucommander.commons.file.impl.sevenzip.multivolume.SevenZipMultiVolumeCallbackHandler;\r\nimport com.mucommander.commons.file.impl.sevenzip.multivolume.SevenZipRarMultiVolumeCallbackHandler;\r\nimport com.mucommander.commons.runtime.OsFamily;\r\nimport com.mucommander.commons.util.CircularByteBuffer;\r\nimport net.sf.sevenzipjbinding.*;\r\nimport net.sf.sevenzipjbinding.impl.VolumedArchiveInStream;\r\nimport org.slf4j.Logger;\r\nimport org.slf4j.LoggerFactory;\r\n\r\nimport java.io.File;\r\nimport java.io.IOException;\r\nimport java.io.InputStream;\r\nimport java.util.ArrayList;\r\nimport java.util.Date;\r\nimport java.util.List;\r\nimport java.util.regex.Pattern;\r\n\r\npublic class SevenZipJBindingROArchiveFile extends AbstractROArchiveFile {\r\n private static final Logger LOGGER = LoggerFactory.getLogger(SevenZipJBindingROArchiveFile.class);\r\n\r\n private static final Pattern MULTI_PART_RAR_PATTERN = Pattern.compile(\"[.]part\\\\d+[.]rar\");\r\n\r\n private static final String MULTI_PART_7Z_EXT = \".7z.001\";\r\n\r\n private static volatile boolean libraryInit = false;\r\n protected IInArchive inArchive;\r\n private ArchiveFormat sevenZipJBindingFormat;\r\n private final SevenZipArchiveFormatDetector formatDetector;\r\n\r\n private final byte[] formatSignature;\r\n\r\n /**\r\n * Creates an AbstractROArchiveFile on top of the given file.\r\n *\r\n * @param file the file on top of which to create the archive\r\n *\r\n * @see \r\n * ArchiveFormat\r\n */\r\n public SevenZipJBindingROArchiveFile(AbstractFile file, ArchiveFormat sevenZipJBindingFormat, byte[] formatSignature) {\r\n super(file);\r\n this.sevenZipJBindingFormat = sevenZipJBindingFormat;\r\n this.formatSignature = formatSignature;\r\n this.formatDetector = null;\r\n initSevenZipBindings();\r\n }\r\n\r\n public SevenZipJBindingROArchiveFile(AbstractFile file, SevenZipArchiveFormatDetector formatDetector) {\r\n super(file);\r\n this.sevenZipJBindingFormat = null;\r\n this.formatSignature = new byte[] {};\r\n this.formatDetector = formatDetector;\r\n initSevenZipBindings();\r\n }\r\n\r\n\r\n private static void initSevenZipBindings() {\r\n if (!libraryInit) {\r\n synchronized (SevenZipJBindingROArchiveFile.class) {\r\n try {\r\n if (OsFamily.getCurrent() == OsFamily.MAC_OS_X && OsFamily.isAarch64()) {\r\n SevenZip.initSevenZipFromPlatformJAR(\"Mac-arm64\");\r\n } else if (OsFamily.getCurrent() == OsFamily.MAC_OS_X) {\r\n SevenZip.initSevenZipFromPlatformJAR(\"Mac-x86_64\");\r\n } else if (OsFamily.getCurrent() == OsFamily.LINUX && OsFamily.isAmd64()) {\r\n SevenZip.initSevenZipFromPlatformJAR(\"Linux-amd64\");\r\n } else if (OsFamily.getCurrent() == OsFamily.LINUX) {\r\n SevenZip.initSevenZipFromPlatformJAR(\"Linux-i386\");\r\n } else {\r\n System.out.println(\"Arch: \" + System.getProperty(\"os.arch\"));\r\n SevenZip.initSevenZipFromPlatformJAR();\r\n }\r\n libraryInit = true;\r\n } catch (SevenZipNativeInitializationException ex) {\r\n throw new RuntimeException(\"Unable to init 7-Zip-JBinding library bindings\", ex);\r\n }\r\n }\r\n }\r\n }\r\n\r\n// private IInArchive openInArchive() throws IOException {\r\n// if (inArchive == null) {\r\n// if (formatDetector != null) {\r\n// sevenZipJBindingFormat = formatDetector.detect(file);\r\n// }\r\n// SignatureCheckedRandomAccessFile in = new SignatureCheckedRandomAccessFile(file, formatSignature);\r\n// inArchive = SevenZip.openInArchive(sevenZipJBindingFormat, in);\r\n// }\r\n// return inArchive;\r\n// }\r\n\r\n /**\r\n * Open the file and check its signature compared to the one provided in {@link #SevenZipJBindingROArchiveFile(AbstractFile, ArchiveFormat, byte[])}\r\n * @return this {@code SevenZipJBindingROArchiveFile} instance when file signature matches the specified signature\r\n * @throws IOException in case the file cannot be opened or its signature differs from the specified signature\r\n */\r\n public SevenZipJBindingROArchiveFile check() throws IOException {\r\n openInArchive();\r\n return this;\r\n }\r\n\r\n private IInArchive openInArchive() throws IOException {\r\n if (inArchive == null) {\r\n boolean multiPartRar = MULTI_PART_RAR_PATTERN.matcher(file.getName()).find();\r\n boolean multiPartSevenZip = file.getName().toLowerCase().endsWith(MULTI_PART_7Z_EXT);\r\n\r\n\r\n// if (formatDetector != null) {\r\n// sevenZipJBindingFormat = formatDetector.detect(file);\r\n// }\r\n// SignatureCheckedRandomAccessFile in = new SignatureCheckedRandomAccessFile(file, formatSignature);\r\n// inArchive = SevenZip.openInArchive(sevenZipJBindingFormat, in);\r\n\r\n if (multiPartRar) {\r\n SevenZipRarMultiVolumeCallbackHandler handler = new SevenZipRarMultiVolumeCallbackHandler(formatSignature, password);\r\n IInStream firstStream = handler.getStream(file.getAbsolutePath());\r\n IInArchive tmpInArchive = SevenZip.openInArchive(sevenZipJBindingFormat, firstStream, handler);\r\n inArchive = new InArchiveWrapper(tmpInArchive, handler);\r\n } else if (multiPartSevenZip) {\r\n SevenZipMultiVolumeCallbackHandler handler = new SevenZipMultiVolumeCallbackHandler(formatSignature, file, password);\r\n IInArchive tmpInArchive = SevenZip.openInArchive(sevenZipJBindingFormat, new VolumedArchiveInStream(handler));\r\n if (isEnc(tmpInArchive) && password == null) {\r\n // Throwing this exception to trigger password dialog\r\n throw new IOException(String.format(\"Password protected file but password is null [file = %s]\", file.getName()));\r\n }\r\n inArchive = new InArchiveWrapper(tmpInArchive, handler);\r\n } else {\r\n SignatureCheckedRandomAccessFile in = new SignatureCheckedRandomAccessFile(file, formatSignature);\r\n IInArchive tmpInArchive = SevenZip.openInArchive(sevenZipJBindingFormat, in, password);\r\n inArchive = new InArchiveWrapper(tmpInArchive, in);\r\n }\r\n }\r\n return inArchive;\r\n }\r\n\r\n private boolean isEnc(IInArchive archive) {\r\n try {\r\n if (Boolean.TRUE.equals(archive.getArchiveProperty(PropID.ENCRYPTED))) {\r\n return true;\r\n }\r\n\r\n for (int i = 0; i < archive.getNumberOfItems(); i++) {\r\n if (Boolean.TRUE.equals(archive.getProperty(i, PropID.ENCRYPTED))) {\r\n return true;\r\n }\r\n }\r\n } catch (SevenZipException e) {\r\n LOGGER.error(\"Error checking if file is encrypted\", e);\r\n }\r\n return false;\r\n }\r\n\r\n @Override\r\n public ArchiveEntryIterator getEntryIterator() throws IOException {\r\n try {\r\n final IInArchive sevenZipFile = openInArchive();\r\n int nbEntries = sevenZipFile.getNumberOfItems();\r\n ListArchiveEntryIterator that iterates through an AR archive. \n *\n * @author Maxence Bernard\n */\nclass ArArchiveEntryIterator implements ArchiveEntryIterator {\n private static final Logger LOGGER = LoggerFactory.getLogger(ArArchiveEntryIterator.class);\n\n /** InputStream to the the archive file */\n private InputStream in;\n\n /** The current entry, where the stream is currently positionned */\n private ArchiveEntry currentEntry;\n\n /** GNU variant: extended filenames contained in the special // entry's data */\n private byte gnuExtendedNames[];\n\n\n /**\n * Creates a new ArArchiveEntryIterator that parses the given AR InputStream.\n * The InputStream will be closed by {@link #close()}.\n *\n * @param in an AR archive InputStream\n * @throws IOException if an I/O error occurred while initializing this iterator\n */\n ArArchiveEntryIterator(InputStream in) throws IOException {\n this.in = in;\n\n // Skip the global header: \"!\n * ftp://garfield/stuff/somefile\n *\n *
\n * ftp://john:p4sswd@garfield/stuff/somefile
\n * ftp://anonymous:john@somewhere.net@garfield/stuff/somefile
\n * \n *
\n * These properties are only used when the FTP connection is created. Setting them after the connection is created\n * will not have any immediate effect, their values will only be used if the connection needs to be re-established.\n *\n * \"true\" for\n * passive mode, \"false\" for activemode. If the property is not specified when the connection is created,\n * passive mode is assumed.\n * Commons-net library distributed under the Apache Software License.\n * The {@link #getUnderlyingFileObject()} method allows to retrieve a org.apache.commons.net.ftp.FTPFile\n * instance corresponding to this FTPFile.\n *\n * @see ConnectionPool\n * @author Maxence Bernard\n */\npublic class FTPFile extends ProtocolFile implements ConnectionHandlerFactory {\n private static final Logger LOGGER = LoggerFactory.getLogger(FTPFile.class);\n\n private org.apache.commons.net.ftp.FTPFile file;\n\n private final String absPath;\n\n private AbstractFile parent;\n private boolean parentValSet;\n private final FilePermissions permissions;\n\n private boolean fileExists;\n\n private AbstractFile canonicalFile;\n\n private final static String SEPARATOR = \"/\";\n\n /** Name of the FTP passive mode property */\n public final static String PASSIVE_MODE_PROPERTY_NAME = \"passiveMode\";\n\n /** Name of the FTP encoding property */\n public final static String ENCODING_PROPERTY_NAME = \"encoding\";\n\n /** Default FTP encoding if {@link #ENCODING_PROPERTY_NAME} is not set */\n public final static String DEFAULT_ENCODING = \"UTF-8\";\n\n /** Name of the property that holds the number of retries after a recoverable connection failure (connection error\n * or temporary server error in the 4xx range) */\n public final static String NB_CONNECTION_RETRIES_PROPERTY_NAME = \"nbConnectionRetries\";\n\n /** Default value if {@link #NB_CONNECTION_RETRIES_PROPERTY_NAME} is not set */\n public final static int DEFAULT_NB_CONNECTION_RETRIES = 0;\n\n /** Name of the property that holds the amount of time (in seconds) to wait before retrying to connect after a\n * temporary connection failure. */\n public final static String CONNECTION_RETRY_DELAY_PROPERTY_NAME = \"connectionRetryDelay\";\n\n /** Default value if {@link #CONNECTION_RETRY_DELAY_PROPERTY_NAME} is not set */\n public final static int DEFAULT_CONNECTION_RETRY_DELAY = 15;\n\n /** Date format used by the SITE UTIME command */\n private final static SimpleDateFormat SITE_UTIME_DATE_FORMAT = new SimpleDateFormat(\"yyyyMMddHHmm\");\n\n\n FTPFile(FileURL fileURL) throws IOException {\n this(fileURL, null);\n }\n\n FTPFile(FileURL fileURL, org.apache.commons.net.ftp.FTPFile file) throws IOException {\n super(fileURL);\n\n this.absPath = fileURL.getPath();\n\n if (file == null) {\n this.file = getFTPFile(fileURL);\n // If file doesn't exist (could not be resolved), create it\n if (this.file == null) {\n String name = fileURL.getFilename(); // Filename could potentially be null\n this.file = createFTPFile(name == null ? \"\" : name, false);\n this.fileExists = false;\n } else {\n this.fileExists = true;\n }\n } else {\n this.file = file;\n this.fileExists = true;\n }\n this.permissions = new FTPFilePermissions(this.file);\n }\n\n\n private org.apache.commons.net.ftp.FTPFile getFTPFile(FileURL fileURL) throws IOException {\n // Todo: this method is very ineffective as it lists the parent directory to retrieve the information about the\n // requested file to workaround the fact that FTPClient#listFiles follows directories.\n // => Use the MLST command if supported by the server (use FEAT command to find out if it is supported).\n // See http://tools.ietf.org/html/draft-ietf-ftpext-mlst-16\n FileURL parentURL = fileURL.getParent();\n LOGGER.trace(\"fileURL={} parent={}\", fileURL, parentURL);\n\n // Parent is null, create '/' file\n if (parentURL == null) {\n return createFTPFile(\"/\", true);\n } else {\n FTPConnectionHandler connHandler = (FTPConnectionHandler)ConnectionPool.getConnectionHandler(this, fileURL, true);\n org.apache.commons.net.ftp.FTPFile[] files;\n try {\n // Makes sure the connection is started, if not starts it\n connHandler.checkConnection();\n\n // List files contained by this file's parent in order to retrieve the FTPFile instance corresponding\n // to this file\n files = listFiles(connHandler, parentURL.getPath());\n } finally {\n // Release the lock on the ConnectionHandler\n connHandler.releaseLock();\n }\n\n // File doesn't exist\n if (files == null || files.length == 0) {\n return null;\n }\n\n // Find the file in the parent folder's contents\n String wantedName = fileURL.getFilename();\n for (org.apache.commons.net.ftp.FTPFile f : files) {\n if (f.getName().equalsIgnoreCase(wantedName)) {\n return f;\n }\n }\n\n // File doesn't exists\n return null;\n }\n }\n\n\n private org.apache.commons.net.ftp.FTPFile createFTPFile(String name, boolean isDirectory) {\n org.apache.commons.net.ftp.FTPFile file = new org.apache.commons.net.ftp.FTPFile();\n file.setName(name);\n file.setSize(0);\n file.setTimestamp(java.util.Calendar.getInstance());\n file.setType(isDirectory?org.apache.commons.net.ftp.FTPFile.DIRECTORY_TYPE:org.apache.commons.net.ftp.FTPFile.FILE_TYPE);\n return file;\n }\n\n\n /**\n * Lists and returns the contents of the given path on the server using the given connection handler.\n * The directory contents is listed by issuing a CWD followed by a LIST so after this method is called, the current\n * working directory is left to the specified path.\n *\n * @param connHandler the connection handler to use for communicating with the server\n * @param absPath absolute path to the directory to list\n * @return the directory's contents. The returned array may be empty but never null. The array may contain null\n * individual entries as FTPClient#listFiles's Javadoc mentions.\n * @throws IOException if an error occurred while communicating with the server\n * @throws AuthException if the user is not allowed to access this directory\n */\n private static org.apache.commons.net.ftp.FTPFile[] listFiles(FTPConnectionHandler connHandler, String absPath) throws IOException {\n org.apache.commons.net.ftp.FTPFile[] files;\n try {\n // Important: the folder is listed by changing the current working directory using the CWD command and then\n // issuing a LIST to list the current directory, instead of issuing a LIST with the path as an argument.\n // So we're sending:\n //\n // CWD path\n // LIST\n //\n // Instead of:\n //\n // LIST path\n //\n // The reason for that is that on some servers 'LIST path with spaces' fails whereas 'CWD path with spaces'\n // succeeds. Most FTP clients seem to be doing this (CWD/LIST instead of LIST), there must be a reason.\n //\n // See:\n // http://www.mucommander.com/forums/viewtopic.php?f=4&t=714\n // http://issues.apache.org/jira/browse/NET-10\n\n connHandler.ftpClient.changeWorkingDirectory(absPath);\n files = connHandler.ftpClient.listFiles();\n\n // Throw an IOException if server replied with an error\n connHandler.checkServerReply();\n\n if (files==null) // In some rare conditions (bug) this method can return null\n return new org.apache.commons.net.ftp.FTPFile[0];\n\n return files;\n }\n // This exception is not an IOException and needs to be caught and thrown back as an IOException\n catch(org.apache.commons.net.ftp.parser.ParserInitializationException e) {\n LOGGER.info(\"ParserInitializationException caught\", e);\n throw new IOException();\n } catch(IOException e) {\n // Checks if the IOException corresponds to a socket error and in that case, closes the connection\n connHandler.checkSocketException(e);\n\n // Throw back the IOException\n throw e;\n }\n }\n\n\n /////////////////////////////////////////////\n // ConnectionHandlerFactory implementation //\n /////////////////////////////////////////////\n\n public ConnectionHandler createConnectionHandler(FileURL location) {\n return new FTPConnectionHandler(location);\n }\n\n\n /////////////////////////////////////////\n // AbstractFile methods implementation //\n /////////////////////////////////////////\n\n @Override\n public boolean isSymlink() {\n return file.isSymbolicLink();\n }\n\n @Override\n public boolean isSystem() {\n return false;\n }\n\n @Override\n public long getLastModifiedDate() {\n if (isSymlink()) {\n return ((org.apache.commons.net.ftp.FTPFile) getCanonicalFile().getUnderlyingFileObject()).getTimestamp().getTimeInMillis();\n }\n\n return file.getTimestamp().getTimeInMillis();\n }\n\n /**\n * Attempts to change this file's date using the 'SITE UTIME' FTP command.\n * This command seems to be implemented by modern FTP servers such as ProFTPd or PureFTP Server but since it is not\n * part of the basic FTP command set, it may as well not be supported by the remote server.\n */\n @Override\n public void setLastModifiedDate(long lastModified) throws IOException {\n // Note: FTPFile.setTimeStamp only changes the instance's date, but doesn't change it on the server-side.\n FTPConnectionHandler connHandler = null;\n try {\n // Retrieve a ConnectionHandler and lock it\n connHandler = (FTPConnectionHandler)ConnectionPool.getConnectionHandler(this, fileURL, true);\n\n // Throw UnsupportedFileOperationException if we know the 'SITE UTIME' command is not supported by the server\n if (!connHandler.utimeCommandSupported) {\n throw new UnsupportedFileOperationException(FileOperation.CHANGE_DATE);\n }\n\n // Makes sure the connection is started, if not starts it\n connHandler.checkConnection();\n\n String sdate;\n // SimpleDateFormat instance must be synchronized externally if it is accessed concurrently\n synchronized(SITE_UTIME_DATE_FORMAT) {\n sdate = SITE_UTIME_DATE_FORMAT.format(new Date(lastModified));\n }\n\n LOGGER.info(\"sending SITE UTIME {} {}\", sdate, absPath);\n boolean success = connHandler.ftpClient.sendSiteCommand(\"UTIME \"+sdate+\" \"+absPath);\n LOGGER.info(\"server reply: {}\", connHandler.ftpClient.getReplyString());\n\n if (!success) {\n int replyCode = connHandler.ftpClient.getReplyCode();\n\n // If server reported that the command is not supported, mark it in the ConnectionHandler so that\n // we don't try it anymore\n if(replyCode==FTPReply.UNRECOGNIZED_COMMAND\n || replyCode==FTPReply.COMMAND_NOT_IMPLEMENTED \n || replyCode==FTPReply.COMMAND_NOT_IMPLEMENTED_FOR_PARAMETER) {\n\n LOGGER.info(\"marking UTIME command as unsupported\");\n connHandler.utimeCommandSupported = false;\n }\n\n throw new IOException();\n }\n } catch (IOException e) {\n // Checks if the IOException corresponds to a socket error and in that case, closes the connection\n if(connHandler!=null)\n connHandler.checkSocketException(e);\n\n throw e;\n } finally {\n // Release the lock on the ConnectionHandler\n if (connHandler != null) {\n connHandler.releaseLock();\n }\n }\n }\n\n @Override\n public long getSize() {\n if (isSymlink()) {\n return ((org.apache.commons.net.ftp.FTPFile) getCanonicalFile().getUnderlyingFileObject()).getSize();\n }\n return file.getSize();\n }\n\n\n @Override\n public AbstractFile getParent() {\n if (!parentValSet) {\n FileURL parentFileURL = this.fileURL.getParent();\n if (parentFileURL != null) {\n try {\n parent = FileFactory.getFile(parentFileURL, null, createFTPFile(parentFileURL.getFilename(), true));\n } catch(IOException e) {\n // No parent, that's all\n }\n }\n\n parentValSet = true;\n }\n\n return parent;\n }\n\n\n @Override\n public void setParent(AbstractFile parent) {\n this.parent = parent;\n this.parentValSet = true;\n }\n\n\n @Override\n public boolean exists() {\n return this.fileExists;\n }\n\n @Override\n public FilePermissions getPermissions() {\n if (isSymlink()) {\n FTPFile ancestor = getCanonicalFile().getAncestor(FTPFile.class);\n return ancestor != null ? ancestor.permissions : null;\n }\n\n return permissions;\n }\n\n @Override\n public void changePermission(int access, int permission, boolean enabled) throws IOException {\n changePermissions(ByteUtils.setBit(permissions.getIntValue(), (permission << (access*3)), enabled));\n }\n\n /**\n * Returns {@link PermissionBits#FULL_PERMISSION_BITS} if the server supports the 'site chmod' command (not all\n * servers do), {@link PermissionBits#EMPTY_PERMISSION_BITS} otherwise.\n *\n * @return {@link PermissionBits#FULL_PERMISSION_BITS} if the server supports the 'site chmod' command (not all\n * servers do), {@link PermissionBits#EMPTY_PERMISSION_BITS} otherwise\n */\n @Override\n public PermissionBits getChangeablePermissions() {\n try {\n // Do not lock the connection handler, not needed.\n return ((FTPConnectionHandler)ConnectionPool.getConnectionHandler(this, fileURL, false)).chmodCommandSupported\n ?PermissionBits.FULL_PERMISSION_BITS // Full permission support (777 octal)\n :PermissionBits.EMPTY_PERMISSION_BITS; // Permissions can't be changed\n } catch (InterruptedIOException e) {\n // Should not happen in practice\n return PermissionBits.EMPTY_PERMISSION_BITS; // Permissions can't be changed\n }\n }\n\n @Override\n public String getOwner() {\n return file.getUser();\n }\n\n @Override\n public boolean canGetOwner() {\n return true;\n }\n\n @Override\n public String getGroup() {\n return file.getGroup();\n }\n\n @Override\n public boolean canGetGroup() {\n return true;\n }\n\n @Override\n public boolean isDirectory() {\n // org.apache.commons.net.ftp.FTPFile#isDirectory() returns false if the file is a symlink pointing to a\n // directory, this is a limitation of the Commons-net library.\n // Todo: fix this by either:\n // a) find a combination of 'LIST' switches which allows the output to contain both the 'is symlink' and the\n // 'is the symlink target a directory' information. At a first glance, there doesn't seem to be one: either\n // symlinks are followed or there aren't.\n // b) Patch #ls() to issue an extra 'LIST -ldH *' to retrieve all symlinks' information when the directory has\n // at least one symlink.\n // c) if this file is a symlink, retrieve the symlink's target using #getFTPFile(FileURL) with '-ldH' switches\n // and return the value of isDirectory(). This clearly is the least effective solution at it requires issuing\n // one 'ls' command per symlink.\n\n if (isSymlink()) {\n return ((org.apache.commons.net.ftp.FTPFile) getCanonicalFile().getUnderlyingFileObject()).isDirectory();\n }\n\n return file.isDirectory();\n }\n\n @Override\n public InputStream getInputStream() throws IOException {\n return getInputStream(0);\n }\n\n @Override\n public OutputStream getOutputStream() throws IOException {\n return new FTPOutputStream(false);\n }\n\n @Override\n public OutputStream getAppendOutputStream() throws IOException {\n return new FTPOutputStream(true);\n }\n\n /**\n * Always throws an {@link UnsupportedFileOperationException}: random read access is not available.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public RandomAccessInputStream getRandomAccessInputStream() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.RANDOM_READ_FILE);\n }\n\n// public RandomAccessInputStream getRandomAccessInputStream() throws IOException {\n// return new FTPRandomAccessInputStream();\n// }\n\n /**\n * Always throws an {@link UnsupportedFileOperationException}: random write access is not available.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public RandomAccessOutputStream getRandomAccessOutputStream() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.RANDOM_WRITE_FILE);\n }\n\n @Override\n public void delete() throws IOException {\n // Retrieve a ConnectionHandler and lock it\n FTPConnectionHandler connHandler = (FTPConnectionHandler)ConnectionPool.getConnectionHandler(this, fileURL, true);\n try {\n // Makes sure the connection is started, if not starts it\n connHandler.checkConnection();\n\n if (isDirectory()) {\n connHandler.ftpClient.removeDirectory(absPath);\n } else {\n connHandler.ftpClient.deleteFile(absPath);\n }\n fileExists = false; // need be false because the file can be get from cache pool\n\n // Throw an IOException if server replied with an error\n connHandler.checkServerReply();\n } catch(IOException e) {\n // Checks if the IOException corresponds to a socket error and in that case, closes the connection\n connHandler.checkSocketException(e);\n\n // Re-throw IOException\n throw e;\n } finally {\n // Release the lock on the ConnectionHandler\n connHandler.releaseLock();\n }\n }\n\n\n @Override\n public AbstractFile[] ls() throws IOException {\n // Retrieve a ConnectionHandler and lock it\n FTPConnectionHandler connHandler = (FTPConnectionHandler)ConnectionPool.getConnectionHandler(this, fileURL, true);\n org.apache.commons.net.ftp.FTPFile[] files;\n try {\n // Makes sure the connection is started, if not starts it\n connHandler.checkConnection();\n\n files = listFiles(connHandler, absPath);\n } finally {\n // Release the lock on the ConnectionHandler\n connHandler.releaseLock();\n }\n\n if (files == null || files.length == 0) {\n return new AbstractFile[]{};\n }\n\n AbstractFile[] children = new AbstractFile[files.length];\n int nbFiles = files.length;\n int fileCount = 0;\n String parentPath = fileURL.getPath();\n if (!parentPath.endsWith(SEPARATOR)) {\n parentPath += SEPARATOR;\n }\n\n for (org.apache.commons.net.ftp.FTPFile file1 : files) {\n if (file1 == null) {\n continue;\n }\n\n String childName = file1.getName();\n if (childName.equals(\".\") || childName.equals(\"..\")) {\n continue;\n }\n\n // Note: properties and credentials are cloned for every children's url\n FileURL childURL = (FileURL) fileURL.clone();\n childURL.setPath(parentPath + childName);\n\n // Discard '.' and '..' files\n if (childName.equals(\".\") || childName.equals(\"..\")) {\n continue;\n }\n\n AbstractFile child = FileFactory.getFile(childURL, this, file1);\n children[fileCount++] = child;\n }\n\n // create new array of the exact file count\n if (fileCount < nbFiles) {\n AbstractFile[] newChildren = new AbstractFile[fileCount];\n System.arraycopy(children, 0, newChildren, 0, fileCount);\n return newChildren;\n }\n\n return children;\n }\n\n\n @Override\n public void mkdir() throws IOException {\n // Retrieve a ConnectionHandler and lock it\n FTPConnectionHandler connHandler = (FTPConnectionHandler)ConnectionPool.getConnectionHandler(this, fileURL, true);\n try {\n // Makes sure the connection is started, if not starts it\n connHandler.checkConnection();\n\n connHandler.ftpClient.makeDirectory(absPath);\n // Throw an IOException if server replied with an error\n connHandler.checkServerReply();\n\n file.setType(org.apache.commons.net.ftp.FTPFile.DIRECTORY_TYPE);\n fileExists = true;\n } catch(IOException e) {\n // Checks if the IOException corresponds to a socket error and in that case, closes the connection\n connHandler.checkSocketException(e);\n // Re-throw IOException\n throw e;\n } finally {\n // Release the lock on the ConnectionHandler\n connHandler.releaseLock();\n }\n }\n\n /**\n * Always throws {@link UnsupportedFileOperationException} when called.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public long getFreeSpace() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.GET_FREE_SPACE);\n }\n\n /**\n * Always throws {@link UnsupportedFileOperationException} when called.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public long getTotalSpace() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.GET_TOTAL_SPACE);\n }\n\n /**\n * Returns an org.apache.commons.net.FTPFile instance corresponding to this file.\n */\n @Override\n public Object getUnderlyingFileObject() {\n return file;\n }\n\n @Override\n @UnsupportedFileOperation\n public short getReplication() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.GET_REPLICATION);\n }\n\n @Override\n @UnsupportedFileOperation\n public long getBlocksize() throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.GET_BLOCKSIZE);\n }\n\n @Override\n @UnsupportedFileOperation\n public void changeReplication(short replication) throws IOException {\n throw new UnsupportedFileOperationException(FileOperation.CHANGE_REPLICATION);\n }\n\n /**\n * Changes permissions using the SITE CHMOD FTP command.\n *\n * This command is optional but seems to be supported by modern FTP servers such as ProFTPd or PureFTP Server.\n * But it may as well not be supported by the remote FTP server as it is not part of the basic FTP command set.\n *\n * Implementation note: FTPFile.setPermission only changes the instance's permissions, but doesn't change it on the\n * server-side.\n */\n @Override\n public void changePermissions(int permissions) throws IOException {\n FTPConnectionHandler connHandler = null;\n try {\n // Retrieve a ConnectionHandler and lock it\n connHandler = (FTPConnectionHandler)ConnectionPool.getConnectionHandler(this, fileURL, true);\n\n // Return if we know the CHMOD command is not supported by the server\n if(!connHandler.chmodCommandSupported)\n throw new UnsupportedFileOperationException(FileOperation.CHANGE_PERMISSION);\n\n // Makes sure the connection is started, if not starts it\n connHandler.checkConnection();\n\n LOGGER.info(\"sending SITE CHMOD {} {}\", Integer.toOctalString(permissions), absPath);\n boolean success = connHandler.ftpClient.sendSiteCommand(\"CHMOD \"+Integer.toOctalString(permissions)+\" \"+absPath);\n LOGGER.info(\"server reply: {}\", connHandler.ftpClient.getReplyString());\n\n if (!success) {\n int replyCode = connHandler.ftpClient.getReplyCode();\n\n // If server reported that the command is not supported, mark it in the ConnectionHandler so that\n // we don't try it anymore\n if(replyCode==FTPReply.UNRECOGNIZED_COMMAND\n || replyCode==FTPReply.COMMAND_NOT_IMPLEMENTED\n || replyCode==FTPReply.COMMAND_NOT_IMPLEMENTED_FOR_PARAMETER) {\n\n LOGGER.info(\"marking CHMOD command as unsupported\");\n connHandler.chmodCommandSupported = false;\n }\n\n throw new IOException();\n }\n } catch(IOException e) {\n // Checks if the IOException corresponds to a socket error and in that case, closes the connection\n if (connHandler != null) {\n connHandler.checkSocketException(e);\n }\n\n throw e;\n } finally {\n // Release the lock on the ConnectionHandler\n if (connHandler != null) {\n connHandler.releaseLock();\n }\n }\n }\n\n /**\n * Implementation notes: always throws an {@link UnsupportedFileOperationException}.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public void copyRemotelyTo(AbstractFile destFile) throws UnsupportedFileOperationException {\n throw new UnsupportedFileOperationException(FileOperation.COPY_REMOTELY);\n }\n \n /**\n * Implementation notes: server-to-server renaming will work if the destination file also uses the 'FTP' scheme\n * and is located on the same host.\n */\n @Override\n public void renameTo(AbstractFile destFile) throws IOException {\n // Throw an exception if the file cannot be renamed to the specified destination\n checkRenamePrerequisites(destFile, false, false);\n\n FTPConnectionHandler connHandler = null;\n try {\n // Retrieve a ConnectionHandler and lock it\n connHandler = (FTPConnectionHandler)ConnectionPool.getConnectionHandler(this, fileURL, true);\n // Makes sure the connection is started, if not starts it\n connHandler.checkConnection();\n\n if(!connHandler.ftpClient.rename(absPath, destFile.getURL().getPath()))\n throw new IOException();\n } catch(IOException e) {\n // Checks if the IOException corresponds to a socket error and in that case, closes the connection\n if(connHandler!=null)\n connHandler.checkSocketException(e);\n\n throw e;\n } finally {\n // Release the lock on the ConnectionHandler\n if (connHandler!=null) {\n connHandler.releaseLock();\n }\n }\n }\n\n\n @Override\n public InputStream getInputStream(long offset) throws IOException {\n return new FTPInputStream(offset);\n }\n\n @Override\n public AbstractFile getCanonicalFile() {\n if (!isSymlink()) {\n return this;\n }\n\n // create the canonical file instance and cache it\n if (canonicalFile == null) {\n // getLink() returns the raw symlink target which can either be an absolute or a relative path. If the path is\n // relative, prepared the absolute path of the symlink's parent folder.\n String symlinkTargetPath = file.getLink();\n if (!symlinkTargetPath.startsWith(\"/\")) {\n String parentPath = fileURL.getParent().getPath();\n if (!parentPath.endsWith(\"/\")) {\n parentPath += \"/\";\n }\n symlinkTargetPath = parentPath + symlinkTargetPath;\n }\n\n FileURL canonicalURL = (FileURL)fileURL.clone();\n canonicalURL.setPath(symlinkTargetPath);\n\n canonicalFile = FileFactory.getFile(canonicalURL);\n }\n\n return canonicalFile;\n }\n\n /**\n * If the FTPFile is a symbolic link, this method returns the name of the file being pointed to by the symbolic link.\n * @return The file pointed to by the symbolic link (null if the FTPFile is not a symbolic link).\n */\n public String getLink() {\n return file.getLink();\n }\n\n\n ///////////////////\n // Inner classes //\n ///////////////////\n\n// private class FTPProcess extends AbstractProcess {\n//\n// /** True if the command returned a positive FTP reply code */\n// private boolean success;\n//\n// /** Allows to read the command's output */\n// private ByteArrayInputStream bais;\n//\n//\n// public FTPProcess(String tokens[]) throws IOException {\n//\n// // Concatenates all tokens to create the command string\n// String command = \"\";\n// int nbTokens = tokens.length;\n// for(int i=0; i\n *
\n *\n * true to force the listing of hidden files, false to leave it for the\n * server to decide whether to show hidden files or not.\n */\n // Todo: check if this is still needed after upgrading to commons-net 2.0\n // Todo: this should not be a configuration variable but rather a FileURL property\n public static void setForceHiddenFilesListing(boolean value) {\n forceHiddenFilesListing = value;\n }\n\n /**\n * Returns true if the listing of hidden files is forced, false if the decision to show\n * them is left to the server.\n *\n * @return true if the listing of hidden files is forced, false if the decision to show\n * them is left to the server.\n * @see #setForceHiddenFilesListing(boolean)\n */\n public static boolean getForceHiddenFilesListing() {\n return forceHiddenFilesListing;\n }\n\n @Override\n public AbstractFile getFile(FileURL url, Object... instantiationParams) throws IOException {\n return instantiationParams.length==0\n ?new FTPFile(url)\n :new FTPFile(url, (org.apache.commons.net.ftp.FTPFile)instantiationParams[0]);\n }\n}\n"
},
{
"path": "src/main/java/com/mucommander/commons/file/impl/ftp/package.html",
"content": "HadoopFile. All is left for subclasses is to implement\n * the abstract methods defined in this class.\n *\n * @see HDFSFile\n * @author Maxence Bernard\n */\npublic abstract class HadoopFile extends ProtocolFile {\n private static final Logger LOGGER = LoggerFactory.getLogger(HadoopFile.class);\n\n /** The Hadoop FileSystem object */\n private final FileSystem fs;\n /** The Hadoop */\n private final Path path;\n\n /** Holds file attributes */\n private final HadoopFileAttributes fileAttributes;\n\n /** Cached parent file instance, null if not created yet or if this file has no parent */\n private AbstractFile parent;\n /** Has the parent file been determined yet? */\n private boolean parentValSet;\n\n /** True if this file is currently being written */\n private boolean isWriting;\n\n /** Default Hadoop Configuration, whose values are fetched from XML configuration files. */\n final static Configuration DEFAULT_CONFIGURATION = new Configuration();\n \n\n HadoopFile(FileURL url) throws IOException {\n this(url, null, null);\n }\n\n HadoopFile(FileURL url, FileSystem fs, FileStatus fileStatus) throws IOException {\n super(url);\n\n if(fs==null) {\n try {\n this.fs = getHadoopFileSystem(url);\n }\n catch(IOException e) {\n throw e;\n }\n catch(Exception e) {\n // FileSystem implementations throw IllegalArgumentException under various circumstances\n throw new IOException(e.getMessage());\n }\n } else {\n this.fs = fs;\n }\n\n if (fileStatus == null) {\n this.path = new Path(fileURL.getPath());\n this.fileAttributes = new HadoopFileAttributes();\n } else {\n this.fileAttributes = new HadoopFileAttributes(fileStatus);\n this.path = fileStatus.getPath();\n }\n }\n\n private OutputStream getOutputStream(boolean append) throws IOException {\n OutputStream out = new CounterOutputStream(\n append?fs.append(path):fs.create(path, true),\n new ByteCounter() {\n @Override\n public synchronized void add(long nbBytes) {\n fileAttributes.addToSize(nbBytes);\n fileAttributes.setDate(System.currentTimeMillis());\n }\n }\n ) {\n @Override\n public void close() throws IOException {\n super.close();\n isWriting = false;\n }\n };\n\n // Update local attributes\n fileAttributes.setExists(true);\n fileAttributes.setDate(System.currentTimeMillis());\n fileAttributes.setSize(0);\n\n isWriting = true;\n\n return out;\n }\n\n\n /////////////////////////////////\n // AbstractFile implementation //\n /////////////////////////////////\n\n @Override\n public AbstractFile getParent() {\n if(!parentValSet) {\n FileURL parentFileURL = this.fileURL.getParent();\n if(parentFileURL!=null)\n parent = FileFactory.getFile(fileURL.getParent());\n\n parentValSet = true;\n }\n\n return parent;\n }\n\n @Override\n public void setParent(AbstractFile parent) {\n this.parent = parent;\n this.parentValSet = true;\n }\n\n @Override\n public Object getUnderlyingFileObject() {\n return fileAttributes;\n }\n\n // File attributes manipulation\n\n @Override\n public boolean exists() {\n return fileAttributes.exists();\n }\n\n @Override\n public boolean isDirectory() {\n return fileAttributes.isDirectory();\n }\n\n /**\n * Always returns false, Hadoop filesystems have no symlink support.\n *\n * @return returns false, Hadoop filesystems have no symlink support.\n */\n @Override\n public boolean isSymlink() {\n // No support for symlinks\n return false;\n }\n\n @Override\n public boolean isSystem() {\n return false;\n }\n\n @Override\n public long getLastModifiedDate() {\n return fileAttributes.getLastModifiedDate();\n }\n\n @Override\n public long getSize() {\n return fileAttributes.getSize();\n }\n\n @Override\n public PermissionBits getChangeablePermissions() {\n return FilePermissions.FULL_PERMISSION_BITS;\n }\n\n @Override\n public FilePermissions getPermissions() {\n return fileAttributes.getPermissions();\n }\n\n @Override\n public String getOwner() {\n return fileAttributes.getOwner();\n }\n\n @Override\n public boolean canGetOwner() {\n return true;\n }\n\n @Override\n public String getGroup() {\n return fileAttributes.getGroup();\n }\n\n @Override\n public boolean canGetGroup() {\n return true;\n }\n\n @Override\n public short getReplication() {\n return fileAttributes.getReplication();\n }\n\n @Override\n public long getBlocksize() {\n return fileAttributes.getBlockSize();\n }\n\n // Supported file operations\n\n @Override\n public void mkdir() throws IOException {\n if(exists() || !fs.mkdirs(path))\n throw new IOException();\n\n // Update local attributes\n fileAttributes.setExists(true);\n fileAttributes.setDirectory(true);\n fileAttributes.setDate(System.currentTimeMillis());\n fileAttributes.setSize(0);\n }\n\n @Override\n public void delete() throws IOException {\n if(!fs.delete(path, false))\n throw new IOException();\n\n // Update local attributes\n fileAttributes.setExists(false);\n fileAttributes.setDirectory(false);\n fileAttributes.setSize(0);\n }\n\n @Override\n public void renameTo(AbstractFile destFile) throws IOException {\n // Throw an exception if the file cannot be renamed to the specified destination\n checkRenamePrerequisites(destFile, false, false);\n\n // Delete the destination if it already exists as FileSystem#rename would otherwise fail.\n // Note: HadoopFile#delete() does not delete directories recursively (good).\n if(destFile.exists())\n destFile.delete();\n\n if(!fs.rename(path, ((HadoopFile)destFile).path))\n throw new IOException();\n\n // Update destination file attributes by fetching them from the server\n ((HadoopFileAttributes)destFile.getUnderlyingFileObject()).fetchAttributes();\n\n // Update this file's attributes locally\n fileAttributes.setExists(false);\n fileAttributes.setDirectory(false);\n fileAttributes.setSize(0);\n }\n\n @Override\n public void setLastModifiedDate(long lastModified) throws IOException {\n // Note: setTimes seems to fail on HDFS directories.\n fs.setTimes(path, lastModified, lastModified);\n\n // Update local attributes\n fileAttributes.setDate(lastModified);\n }\n\n @Override\n public void changeReplication(short replication) throws IOException {\n // Note: setTimes seems to fail on HDFS directories.\n fs.setReplication(path, replication);\n\n // Update local attributes\n fileAttributes.setReplication(replication);\n }\n\n @Override\n public void changePermission(int access, int permission, boolean enabled) throws IOException {\n changePermissions(ByteUtils.setBit(getPermissions().getIntValue(), (permission << (access*3)), enabled));\n }\n\n @Override\n public InputStream getInputStream() throws IOException {\n return fs.open(path);\n }\n\n @Override\n public OutputStream getOutputStream() throws IOException {\n return getOutputStream(false);\n }\n\n @Override\n public RandomAccessInputStream getRandomAccessInputStream() throws IOException {\n return new HadoopRandomAccessInputStream(fs.open(path), getSize());\n }\n\n @Override\n public AbstractFile[] ls() throws IOException {\n return ls(null);\n }\n\n\n // Unsupported file operations\n\n @Override\n @UnsupportedFileOperation\n public OutputStream getAppendOutputStream() throws IOException {\n // Currently not supported by any of the filesystems (S3, HDFS)\n throw new UnsupportedFileOperationException(FileOperation.APPEND_FILE);\n }\n\n @Override\n @UnsupportedFileOperation\n public RandomAccessOutputStream getRandomAccessOutputStream() throws IOException {\n throw new UnsupportedFileOperationException(FileOperation.RANDOM_WRITE_FILE);\n }\n\n /**\n * Always throws {@link UnsupportedFileOperationException} when called.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n @UnsupportedFileOperation\n public void copyRemotelyTo(AbstractFile destFile) throws UnsupportedFileOperationException {\n // TODO: implement for S3\n throw new UnsupportedFileOperationException(FileOperation.COPY_REMOTELY);\n }\n\n /**\n * Always throws {@link UnsupportedFileOperationException} when called.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n public long getFreeSpace() throws IOException {\n return fs.getStatus().getRemaining();\n }\n\n /**\n * Always throws {@link UnsupportedFileOperationException} when called.\n *\n * @throws UnsupportedFileOperationException always\n */\n @Override\n public long getTotalSpace() throws IOException {\n return fs.getStatus().getCapacity();\n }\n\n\n\n @Override\n public AbstractFile[] ls(FilenameFilter filter) throws IOException {\n // We need to ensure that the file is a directory: if it isn't listStatus returns an empty array but doesn't\n // throw an exception\n if(!exists() || !isDirectory())\n throw new IOException();\n\n FileStatus[] statuses = filter==null\n ?fs.listStatus(path)\n :fs.listStatus(path, new HadoopFilenameFilter(filter));\n\n int nbChildren = statuses==null?0:statuses.length;\n AbstractFile[] children = new AbstractFile[nbChildren];\n String parentPath = fileURL.getPath();\n if(!parentPath.endsWith(\"/\"))\n parentPath += \"/\";\n FileURL childURL;\n FileStatus childStatus;\n\n for(int i=0; i\n * http://www.mucommander.com/index.html\n *\n *
\n * http://www.mucommander.com/index.php?
\n * http://john:p4sswd@www.mucommander.com/restricted_area/
\n * \n *
\n *\n * true).\n * -1 (undetermined), and a date\n * returned by {@link #getLastModifiedDate()} corresponding to 'now' (current time).\n *\n * java.net API. The {@link #getUnderlyingFileObject()} method\n * allows to retrieve a java.net.URL instance corresponding to this HTTPFile.\n *\n * @author Maxence Bernard\n */\npublic class HTTPFile extends ProtocolFile {\n private static final Logger LOGGER = LoggerFactory.getLogger(HTTPFile.class);\n\n /** java.net.URL corresponding to this */\n private final URL url;\n\n /** Contains the attributes of the remote HTTP resource. Contains default values until the file has been resolved */\n private final SimpleFileAttributes attributes;\n\n /** True if the file should be resolved on the remote HTTP server to fetch attribute values, false if these are\n * guessed. */\n private final boolean resolve;\n\n /** True if file has been resolved on the remote HTTP server, either successfully or unsuccessfully */\n private boolean fileResolved;\n\n private boolean parentValSet;\n protected AbstractFile parent;\n\t\n /** Permissions for HTTP files: r-- (400 octal). Only the 'user' permissions bits are supported. */\n private final static FilePermissions PERMISSIONS = new SimpleFilePermissions(256, 448);\n\n /** User agent used for all HTTP connections made by HTTPFile */\n // TODO: add file API version, like trolCommander-file-API/1.0\n private static final String USER_AGENT = \"trolCommander-file-API (Java \"+System.getProperty(\"java.vm.version\")\n + \"; \" + System.getProperty(\"os.name\") + \" \" +\n System.getProperty(\"os.version\") + \" \" + System.getProperty(\"os.arch\") + \")\";\n\n /** Matches HTML and XHTML attribute key/value pairs, where the value is surrounded by Single Quotes */\n private final static Pattern linkAttributePatternSQ = Pattern.compile(\"(src|href|SRC|HREF)='.*?'\");\n\n /** Matches HTML and XHTML attribute key/value pairs, where the value is surrounded by Double Quotes */\n private final static Pattern linkAttributePatternDQ = Pattern.compile(\"(src|href|SRC|HREF)=\\\".*?\\\"\");\n\n\n HTTPFile(FileURL fileURL) throws IOException {\n // TODO: optimize this\n this(fileURL, new URL(fileURL.toString(false)));\n }\n\n\t\n HTTPFile(FileURL fileURL, URL url) throws IOException {\n super(fileURL);\n\n String scheme = fileURL.getScheme().toLowerCase();\n if ((!scheme.equals(FileProtocols.HTTP) && !scheme.equals(FileProtocols.HTTPS)) || fileURL.getHost() == null) {\n throw new IOException();\n }\n\n this.url = url;\n\n attributes = getDefaultAttributes();\n\n String mimeType;\n String filename = fileURL.getFilename();\n // Simple/fuzzy heuristic to avoid file resolution (HEAD) in cases where we have good reasons to believe that\n // the URL denotes a HTML/XTHML document:\n // - URL's path has no filename (e.g. http://www.mucommander.com/) or path ends with '/' (e.g. http://www.mucommander.com/download/)\n // - URL has a query part (works most of the time, must not always)\n // - URL has an extension that registered with an HTML/XHTML mime type\n if ((filename == null || fileURL.getPath().endsWith(\"/\") || fileURL.getQuery()!=null || ((mimeType=MimeTypes.getMimeType(this))!=null && isParsableMimeType(mimeType)))) {\n attributes.setDirectory(true);\n resolve = false;\n } else {\n resolve = true;\n }\n }\n\n\n private static SimpleFileAttributes getDefaultAttributes() {\n SimpleFileAttributes attributes = new SimpleFileAttributes();\n attributes.setDate(System.currentTimeMillis());\n attributes.setSize(-1); // Unknown\n attributes.setPermissions(PERMISSIONS);\n // exist = false\n // isDirectory = false\n // path = null (unused)\n\n return attributes;\n }\n\n\n /**\n * Returns true if the given mime type corresponds to HTML or XHTML and can be parsed.\n *\n * @param mimeType a MIME type / content type\n * @return true if the given mime type corresponds to HTML or XHTML and can be parsed\n */\n private boolean isParsableMimeType(String mimeType) {\n return mimeType != null\n && (mimeType.startsWith(\"text/html\") || mimeType.startsWith(\"application/xhtml+xml\") || mimeType.startsWith(\"application/xml\"));\n }\n\n\n /**\n * Performs a HEAD request on the HTTP server to retrieve the file's attributes.\n *\n * @throws IOException if the HEAD request failed, either because the resource doesn't exist (404) or for any other\n * reason\n */\n private void resolveFile() throws IOException {\n try {\n LOGGER.info(\"Resolving {}\", url);\n\n // Get URLConnection instance\n HttpURLConnection conn = getHttpURLConnection(url);\n\n // Use HEAD instead of GET as we don't need the body\n conn.setRequestMethod(\"HEAD\");\n\n // Establish connection\n conn.connect();\n\n // Check HTTP response code and throw appropriate IOException if request failed\n checkHTTPResponse(conn);\n\n // Resolve date: use last-modified header, if not set use date header, and if still not set use System.currentTimeMillis\n long date = conn.getLastModified();\n if (date == 0) {\n date = conn.getDate();\n if (date == 0) {\n date = System.currentTimeMillis();\n }\n }\n attributes.setDate(date);\n\n // Resolve size with content-length header (-1 if not available)\n attributes.setSize(conn.getContentLength());\n\n // Test if content is HTML\n String contentType = conn.getContentType();\n if (isParsableMimeType(contentType)) {\n attributes.setDirectory(true);\n }\n\n // File was successfully resolved on the remote HTTP server and thus exists\n attributes.setExists(true);\n } catch(IOException e) {\n LOGGER.info(\"Failed to resolve file {}\", url, e);\n } finally {\n // Mark the file as resolved, even if the request failed\n fileResolved = true;\n }\n }\n\n\n /**\n * Opens and returns a HttpURLConnection to the resource denoted by the specified URL.\n * If the {@link FileURL} contained by this HTTPFile contains {@link Credentials}, these will be used as credentials\n * for HTTP Basic Authentication.\n *\n * @param url the URL to open\n * @return a HttpURLConnection to the resource denoted by the specified URL\n * @throws IOException if the HttpURLConnection could not be opened\n */\n private HttpURLConnection getHttpURLConnection(URL url) throws IOException {\n // Get URLConnection instance\n HttpURLConnection conn = (HttpURLConnection)url.openConnection();\n\n // If credentials are contained in this HTTPFile's FileURL, use them for Basic HTTP Authentication\n Credentials credentials = fileURL.getCredentials();\n if (credentials != null)\n conn.setRequestProperty(\n \"Authorization\",\n \"Basic \"+ Base64Encoder.encode(credentials.getLogin()+\":\"+credentials.getPassword())\n );\n\n // Set user-agent header.\n conn.setRequestProperty(\"User-Agent\", USER_AGENT);\n\n return conn;\n }\n\n\n /**\n * Checks the response code of the given HttpURLConnection and :\n * \n *
java.net.URL instance corresponding to this file.\n */\n @Override\n public Object getUnderlyingFileObject() {\n return url;\n }\n\n @Override\n public AbstractFile[] ls() throws IOException {\n // Implementation note: javax.swing.text.html.HTMLEditorKit isn't quite powerful enough to be used\n try {\n HttpURLConnection conn = resolveAndConnect(this.url);\n URL contextURL = conn.getURL();\n\n try (BufferedReader br = createReader(conn)) {\n return findChildren(br, contextURL);\n }\n } catch (Exception e) {\n LOGGER.info(\"Exception caught while parsing HTML, throwing IOException\", e);\n\n if (e instanceof IOException) {\n throw (IOException) e;\n }\n\n throw new IOException();\n }\n }\n\n private HttpURLConnection resolveAndConnect(URL url) throws IOException {\n final int maxRedirects = 10;\n for (int i = 0; i < maxRedirects; i++) {\n // Get a connection instance\n HttpURLConnection conn = getHttpURLConnection(url);\n\n // Disable automatic redirections to track URL change\n conn.setInstanceFollowRedirects(false);\n\n // Establish connection\n conn.connect();\n\n // Check HTTP response code and throw appropriate IOException if request failed\n checkHTTPResponse(conn);\n\n int responseCode = conn.getResponseCode();\n\n // Test if response code is in the 3xx range (redirection) and if 'Location' field is set\n\n if (responseCode >= 300 && responseCode < 400) {\n String locationHeader = conn.getHeaderField(\"Location\");\n if (locationHeader != null) {\n // Redirect to Location field and remember context url\n LOGGER.info(\"Location header = {}\", locationHeader);\n url = new URL(url, locationHeader);\n // One more time\n continue;\n }\n }\n return conn;\n }\n throw new IOException(\"too many redirects\");\n }\n\n private AbstractFile[] findChildren(BufferedReader br, URL contextURL) throws IOException {\n List