From cd6d4007aa4f72b51756e4a571abf876fa3e3133 Mon Sep 17 00:00:00 2001 From: Matthias Klose Date: Tue, 21 Oct 2008 17:55:01 +0000 Subject: re PR libgcj/37636 (java tools are unable to find resource files) libjava/ChangeLog: 2008-10-21 Andrew John Hughes * sources.am, Makfile.in: Regenerate. 2008-10-17 Matthias Klose * configure.ac: Fix bashisms. * configure: Regenerate. 2008-10-15 Matthias Klose * configure.ac: Disable build of gjdoc, if configured without --with-antlr-jar or if no antlr.jar found. * configure: Regenerate. 2008-10-09 Andrew John Hughes * classpath/configure.ac, * classpath/m4/ac_prog_antlr.m4, * classpath/m4/ac_prog_java.m4, * classpath/tools/Makefile.am: Ported --regen-gjdoc-parser patch and cantlr support from GNU Classpath. 2008-10-06 Andrew Haley * java/lang/Thread.java (Thread): Always create the ThreadLocalMap when creating a thread. (getThreadLocals) Don't lazily create the ThreadLocalMap. 2008-09-28 Andrew John Hughes * classpath/java/lang/ThreadLocalMap.java, * java/lang/ThreadLocalMap$Entry.h, * java/lang/ThreadLocalMap.h, * lib/java/lang/ThreadLocalMap.class, * lib/java/lang/ThreadLocalMap$Entry.class: Add the new files for the ThreadLocal patch. 2008-09-28 Andrew John Hughes * classpath/ChangeLog, * classpath/java/lang/InheritableThreadLocal.java, * classpath/java/lang/Thread.java, * classpath/java/lang/ThreadLocal.java: Merge Daniel Frampton's ThreadLocal patch. * gcj/javaprims.h: Updated. * java/lang/Thread.h: Regenerated. * java/lang/Thread.java: Replace WeakIdentityHashMap with ThreadLocalMap. (getThreadLocals()): Likewise. * java/lang/ThreadLocal.h: Regenerated. * java/lang/ThreadLocal.java: (computeNextHash()): New method. (ThreadLocal()): Initialise fastHash. (internalGet()): Updated to match Classpath's get(). (internalSet(Object)): Likewise for set(Object). (internalRemove()): Likewise for remove(). 2008-09-25 Andrew John Hughes * classpath/configure, * classpath/configure.ac: Resynchronise with Classpath's configure. * classpath/examples/Makefile.in: Add equivalent support for building as in tools/Makefile.in. * classpath/java/nio/Buffer.java, * classpath/java/nio/ByteBuffer.java, * classpath/java/nio/ByteBufferImpl.java, * classpath/java/nio/CharBuffer.java, * classpath/java/nio/CharBufferImpl.java, * classpath/java/nio/CharSequenceBuffer.java, * classpath/java/nio/CharViewBufferImpl.java, * classpath/java/nio/DirectByteBufferImpl.java, * classpath/java/nio/DoubleBuffer.java, * classpath/java/nio/DoubleBufferImpl.java, * classpath/java/nio/DoubleViewBufferImpl.java, * classpath/java/nio/FloatBuffer.java, * classpath/java/nio/FloatBufferImpl.java, * classpath/java/nio/FloatViewBufferImpl.java, * classpath/java/nio/IntBuffer.java, * classpath/java/nio/IntBufferImpl.java, * classpath/java/nio/IntViewBufferImpl.java, * classpath/java/nio/LongBuffer.java, * classpath/java/nio/LongBufferImpl.java, * classpath/java/nio/LongViewBufferImpl.java, * classpath/java/nio/MappedByteBuffer.java, * classpath/java/nio/MappedByteBufferImpl.java, * classpath/java/nio/ShortBuffer.java, * classpath/java/nio/ShortBufferImpl.java, * classpath/java/nio/ShortViewBufferImpl.java: Replace use of gnu.classpath.Pointer with gnu.gcj.RawData, and fix some formatting issues. * classpath/tools/gnu/classpath/tools/gjdoc/expr/JavaLexer.java, * classpath/tools/gnu/classpath/tools/gjdoc/expr/JavaLexer.smap, * classpath/tools/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.java, * classpath/tools/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.smap, * classpath/tools/gnu/classpath/tools/gjdoc/expr/JavaTokenTypes.java, * classpath/tools/gnu/classpath/tools/gjdoc/expr/JavaTokenTypes.txt: Regenerated (later version of antlr). * java/nio/Buffer.h: Regenerated. * java/nio/Buffer.java: Ported changes from Classpath. * java/nio/ByteBuffer.h, * java/nio/CharBuffer.h: Regenerated. * java/nio/DirectByteBufferImpl.java: Ported changes from Classpath. * java/nio/DoubleBuffer.h, * java/nio/FloatBuffer.h, * java/nio/IntBuffer.h, * java/nio/LongBuffer.h, * java/nio/MappedByteBuffer.h, * java/nio/MappedByteBufferImpl.h: Regenerated. * java/nio/MappedByteBufferImpl.java: Ported changes from Classpath. * java/nio/ShortBuffer.h: Regenerated. 2008-09-24 Matthias Klose * configure.ac: Search for antlr.jar, if not configured. * configure: Regenerate. 2008-09-24 Matthias Klose * Makefile.am: Build a gjdoc binary, if enabled. * configure.ac: Add options --disable-gjdoc, --with-antlr-jar=file. * Makefile.in, */Makefile.in, configure: Regenerate. 2008-09-22 Andrew Haley * java/lang/String.java (toString(char[], int, int)): New method. 2008-09-14 Matthias Klose Import GNU Classpath (libgcj-import-20080914). * Regenerate class and header files. * Regenerate auto* files. * configure.ac: Don't pass --disable-gjdoc to classpath. * sources.am: Regenerated. * HACKING: Mention to build gjdoc in maintainer builds. * gnu/classpath/Configuration.java: Update classpath version. * gcj/javaprims.h: Update. 2008-09-08 Andrew John Hughes * Makefile.am: Replace natStringBuffer.cc and natStringBuilder.cc with natAbstractStringBuffer.cc. * Makefile.in: Regenerated. * java/lang/AbstractStringBuffer.java: (append(int)): Made native. (regionMatches(int,String)): Likewise. * java/lang/StringBuffer.h: Regenerated. * java/lang/StringBuffer.java: Remerged with GNU Classpath. * java/lang/StringBuilder.h: Regenerated. * java/lang/StringBuilder.java: Remerged with GNU Classpath. * java/lang/natAbstractStringBuffer.cc: Provide common native methods for StringBuffer and StringBuilder. * java/lang/natStringBuffer.cc, * java/lang/natStringBuilder.cc: Removed. 2008-09-04 Andrew John Hughes * Makefile.in, * classpath/configure: Regenerated. * gnu/gcj/util/natDebug.cc, * gnu/gcj/xlib/natColormap.cc, * gnu/gcj/xlib/natDisplay.cc, * gnu/gcj/xlib/natDrawable.cc, * gnu/gcj/xlib/natFont.cc, * gnu/gcj/xlib/natWMSizeHints.cc, * gnu/gcj/xlib/natWindow.cc, * gnu/gcj/xlib/natXImage.cc: Add :: prefix to namespaces. * java/io/CharArrayWriter.h, * java/lang/StringBuffer.h: Regenerated using patched gjavah. * java/lang/natStringBuffer.cc: Fix naming of append(jint). * java/sql/Timestamp.h: Regenerated using patched gjavah. * jni.cc: Rename p to functions to match change in GNU Classpath. * scripts/makemake.tcl: Switch gnu.java.math to BC compilation. * sources.am: Regenerated. 2008-08-21 Andrew John Hughes * Makefile.in: Updated location of Configuration.java. * classpath/lib/gnu/java/locale/LocaleData.class: Regenerated. 2008-08-18 Andrew John Hughes * Makefile.in: Updated with new Java files. * classpath/configure: Regenerated. * classpath/tools/Makefile.am: Add missing use of GJDOC_EX so --disable-gjdoc works. * classpath/tools/Makefile.in: Regenerated. 2008-08-15 Matthias Klose Import GNU Classpath (libgcj-import-20080811). * Regenerate class and header files. * Regenerate auto* files. * configure.ac: Don't pass --with-fastjar to classpath, substitute new dummy value in classpath/gnu/classpath/Configuration.java.in, pass --disable-gjdoc to classpath. * scripts/makemake.tcl: * sources.am: Regenerated. * java/lang/AbstractStringBuffer.java, gnu/java/lang/VMCPStringBuilder.java: New, copied from classpath, use System instead of VMSystem. * java/lang/StringBuffer.java: Merge from classpath. * java/lang/ClassLoader.java: Merge from classpath. * gcj/javaprims.h: Update class definitions, remove _Jv_jobjectRefType, jobjectRefType definitions. libjava/classpath/ChangeLog.gcj: 2008-10-21 Matthias Klose * classpath/tools/gnu/classpath/tools/gjdoc/expr/Java*: Move from ... * classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/ ... here. * Update .class files. 2008-10-21 Andrew John Hughes * tools/Makefile.am: Always generate parser in the srcdir. 2008-10-21 Matthias Klose * doc/Makefile.am (MAINTAINERCLEANFILES): Add gjdoc.1. * doc/Makefile.in: Regenerate. 2008-10-20 Matthias Klose * configure.ac: Don't check for working java, if not configured with --enable-java-maintainer-mode. * configure: Regenerate. 2008-10-19 Matthias Klose * m4/ac_prog_java.m4: Revert previous change. * m4/ac_prog_javac.m4: Apply it here. * configure: Regenerate. 2008-10-19 Matthias Klose * m4/ac_prog_javac.m4: Don't check for working javac, if not configured with --enable-java-maintainer-mode. * configure: Regenerate. * Makefile.in, */Makefile.in: Regenerate. 2008-09-30 Matthias Klose * m4/ac_prog_antlr.m4: Check for cantlr binary as well. 2008-09-29 Matthias Klose * m4/ac_prog_antlr.m4: Check for antlr binary as well. 2008-09-28 Matthias Klose * PR libgcj/37636. Revert: 2008-02-20 Matthias Klose * tools/Makefile.am ($(TOOLS_ZIP)): Revert part of previous change, Do copy resource files in JAVA_MAINTAINER_MODE only. * tools/Makefile.in: Regenerate. 2008-09-14 Matthias Klose * m4/ac_prog_javac_works.m4, m4/ac_prog_javac.m4, m4/acinclude.m4: Revert local changes. * m4/ac_prog_antlr.m4: Check for an runantlr binary. * tools/Makefile.am, lib/Makefile.am: Revert local changes (JCOMPILER). * tools/Makefile.am: Remove USE_JAVAC_FLAGS, pass ANTLR_JAR in GLIBJ_CLASSPATH. 2008-09-14 Matthias Klose Revert: Daniel Frampton * AUTHORS: Added. * java/lang/InheritableThreadLocal.java, * java/lang/Thread.java, * java/lang/ThreadLocal.java: Modified to use java.lang.ThreadLocalMap. * java/lang/ThreadLocalMap.java: New cheaper ThreadLocal-specific WeakHashMap. 2008-08-15 Matthias Klose * m4/acinclude.m4 (CLASSPATH_JAVAC_MEM_CHECK): Remove unknown args for javac. libjava/classpath/ChangeLog: 2008-10-20 Andrew John Hughes * m4/ac_prog_antlr.m4: Remove redundant checks. * tools/Makefile.am: Use gjdoc_gendir when calling antlr. 2008-10-15 Andrew John Hughes * configure.ac: Remove superfluous AC_PROG_JAVA call. 2008-10-06 Andrew John Hughes * m4/ac_prog_antlr: Check for cantlr as well. * tools/Makefile.am: Only build GJDoc parser when both CREATE_GJDOC and CREATE_GJDOC_PARSER are on. 2008-10-02 Andrew John Hughes * configure.ac: Add regen-gjdoc-parser option, and separate antlr tests. * m4/ac_prog_antlr.m4: Turn single test into AC_LIB_ANTLR and AC_PROG_ANTLR. * m4/ac_prog_java.m4: Quote tests. * tools/Makefile.am: Support CREATE_GJDOC_PARSER option. 2008-09-14 Andrew John Hughes * examples/Makefile.am: Check lib directly as well as glibj.zip for boot classes. * m4/acinclude.m4: Only require the class files to be built to allow the tools and examples to be built, not the installation of glibj.zip. * tools/Makefile.am: Check lib directly as well as glibj.zip for boot classes. 2008-09-13 Andrew John Hughes * examples/Makefile.am, * lib/Makefile.am: Add GCJ rules. * m4/ac_prog_javac.m4: Check whether JAVAC is gcj. * m4/ac_prog_javac_works.m4: Add GCJ rules. * m4/acinclude.m4: Don't bother checking for -J if using GCJ. * tools/Makefile.am: Add GCJ rules. 2007-08-23 Daniel Frampton * AUTHORS: Added. * java/lang/InheritableThreadLocal.java, * java/lang/Thread.java, * java/lang/ThreadLocal.java: Modified to use java.lang.ThreadLocalMap. * java/lang/ThreadLocalMap.java: New cheaper ThreadLocal-specific WeakHashMap. 2008-02-07 Ian Rogers * java/util/zip/ZipEntry.java: Use byte fields instead of integer fields, store the time as well as the DOS time and don't retain a global Calendar instance. (setDOSTime(int)): Set KNOWN_DOSTIME instead of KNOWN_TIME, and unset KNOWN_TIME. (getDOSTime()): Compute DOS time from UNIX time only when needed. (clone()): Provide cloning via the ZipEntry constructor where possible. (setTime(long)): Don't compute DOS time at this point. (getCalendar()): Removed. 2008-09-09 Andrew John Hughes * tools/gnu/classpath/tools/getopt/Parser.java: (setHeader(String)): Make synchronized. (setFooter(String)): Likewise. * tools/gnu/classpath/tools/rmic/SourceGiopRmicCompiler.java, (reset()): Make synchronized. (name(Class)): Likewise. 2008-09-04 Robert Schuster * gnu/java/nio/charset/ByteDecodeLoopHelper: (arrayDecodeLoop): Added new break label, escape to that label. * gnu/java/nio/charset/ByteEncodeLoopHelper: (arrayDecodeLoop): Added new break label, escape to that label. 2008-09-04 Robert Schuster * java/text/DecimalFormat.java: (scanFix): Use 'i + 1' when looking at following character. (scanNegativePattern): Dito. 2008-09-02 Andrew John Hughes * tools/gnu/classpath/tools/javah/ClassWrapper.java: (makeVtable()): Populate methodNameMap. (printMethods(CniPrintStream)): Always use pre-populated methodNameMap for bridge targets. 2008-09-01 Mario Torre * gnu/java/awt/peer/x/XImage.java (XImageProducer): remove @Override annotation to allow compilation on javac < 1.6 and ecj < 3.4. 2008-09-01 Mario Torre * gnu/java/awt/peer/x/XGraphicsDevice.java (getDisplay): fix to support new Escher API. * gnu/java/awt/peer/x/XImage.java (getSource): method implemented. * gnu/java/awt/peer/x/XImage.java (XImageProducer): implement ImageProducer for getSource. 2008-09-01 Andrew John Hughes * gnu/java/util/regex/BacktrackStack.java, * gnu/java/util/regex/CharIndexed.java, * gnu/java/util/regex/CharIndexedCharArray.java, * gnu/java/util/regex/CharIndexedCharSequence.java, * gnu/java/util/regex/CharIndexedInputStream.java, * gnu/java/util/regex/CharIndexedString.java, * gnu/java/util/regex/CharIndexedStringBuffer.java, * gnu/java/util/regex/RE.java, * gnu/java/util/regex/REException.java, * gnu/java/util/regex/REFilterInputStream.java, * gnu/java/util/regex/REMatch.java, * gnu/java/util/regex/REMatchEnumeration.java, * gnu/java/util/regex/RESyntax.java, * gnu/java/util/regex/REToken.java, * gnu/java/util/regex/RETokenAny.java, * gnu/java/util/regex/RETokenBackRef.java, * gnu/java/util/regex/RETokenChar.java, * gnu/java/util/regex/RETokenEnd.java, * gnu/java/util/regex/RETokenEndOfPreviousMatch.java, * gnu/java/util/regex/RETokenEndSub.java, * gnu/java/util/regex/RETokenIndependent.java, * gnu/java/util/regex/RETokenLookAhead.java, * gnu/java/util/regex/RETokenLookBehind.java, * gnu/java/util/regex/RETokenNamedProperty.java, * gnu/java/util/regex/RETokenOneOf.java, * gnu/java/util/regex/RETokenPOSIX.java, * gnu/java/util/regex/RETokenRange.java, * gnu/java/util/regex/RETokenRepeated.java, * gnu/java/util/regex/RETokenStart.java, * gnu/java/util/regex/RETokenWordBoundary.java, * gnu/java/util/regex/UncheckedRE.java: Fix indentation. 2008-09-01 Andrew John Hughes * gnu/java/util/regex/RETokenStart.java: (getMaximumLength()): Add Override annotation. (matchThis(CharIndexed, REMatch)): Likewise. (returnsFixedLengthMatches()): Renamed from returnsFixedLengthmatches and added Override annotation. (findFixedLengthMatches(CharIndexed,REMatch,int)): Add Override annotation. (dump(CPStringBuilder)): Likewise. * gnu/javax/print/ipp/IppRequest.java: (RequestWriter.writeOperationAttributes(AttributeSet)): Throw exception, don't just create and drop it. * javax/management/MBeanServerPermission.java: (MBeanServerPermissionCollection.add(Permission)): Compare against individual Strings not the entire array, and store the result of replace. * javax/swing/text/html/StyleSheet.java: (setBaseFontSize(size)): Store result of trim(). 2008-09-01 Andrew John Hughes * javax/tools/FileObject.java: (openReader(boolean)): Document new parameter. 2008-03-27 Michael Franz PR classpath/35690: * javax/tools/FileObject.java: (toUri()): Fix case from toURI. (openReader(boolean)): Add missing boolean argument. 2008-08-26 Andrew John Hughes PR classpath/35487: * gnu/javax/management/Server.java: (beans): Change to ConcurrentHashMap. (defaultDomain): Make final. (outer): Likewise. (LazyListenersHolder): Added to wrap listeners, also now a ConcurrentHashMap, providing lazy initialisation safely. (sequenceNumber): Documented. (getBean(ObjectName)): Remove redundant cast. (addNotificationListener(ObjectName,NotificationListener, NotificationFilter,Object)): Remove map initialisation and use holder. (getObjectInstance(ObjectName)): Remove redundant cast. (registerMBean(Object,ObjectName)): Add bean atomically. (removeNotificationListener(ObjectName,NotificationListener)): Simplified. (removeNotificationListener(ObjectName,NotificationListener, NotificationFilter,Object)): Likewise. (notify(ObjectName,String)): Documented. 2008-08-26 Andrew John Hughes * gnu/javax/management/Server.java: Genericised. 2008-08-26 Andrew John Hughes * gnu/javax/management/Translator.java: Genericised. 2008-08-26 Andrew John Hughes * javax/management/DefaultLoaderRepository.java, * javax/management/JMX.java, * javax/management/MBeanAttributeInfo.java, * javax/management/MBeanConstructorInfo.java, * javax/management/MBeanOperationInfo.java, * javax/management/MBeanServerDelegate.java: Fix warnings due to generics. 2008-08-25 Andrew John Hughes * javax/management/MBeanPermission.java, * javax/management/MBeanServerDelegate.java, * javax/management/MBeanServerFactory.java, * javax/management/MBeanServerInvocationHandler.java, * javax/management/MBeanServerPermission.java: Fix warnings due to use of non-generic collections. 2008-08-25 Mario Torre * gnu/javax/rmi/CORBA/RmiUtilities.java (readValue): check if sender is null to avoid NPE. 2008-08-22 Mario Torre * gnu/CORBA/OrbFunctional.java (set_parameters): Fix NullPointerException checking when param is null. 2008-08-23 Andrew John Hughes * java/util/regex/Matcher.java: (reset()): Reset append position so we don't try and append to the end of the old input. 2008-08-22 Andrew John Hughes PR classpath/32028: * m4/acinclude.m4: Also allow versions of GJDoc from 0.8* on, as CVS is 0.8.0-pre. 2008-08-21 Andrew John Hughes PR classpath/32028: * m4/acinclude.m4: (CLASSPATH_WITH_GJDOC): Ensure version 0.7.9 is being used. 2008-08-20 Andrew John Hughes * tools/Makefile.am: Add taglets subdirectory to list of excluded paths when GJDoc is not compiled. 2008-08-19 David P Grove * scripts/check_jni_methods.sh.in: Fix build issue on AIX by splitting generation of method list. 2008-08-18 Andrew John Hughes * native/jni/gstreamer-peer/gst_native_pipeline.c: (get_free_space(int)): Use #else not #elif when there is no condition. 2008-08-17 Andrew John Hughes PR classpath/31895: * java/text/DecimalFormat.java: (setCurrency(Currency)): Update prefixes and suffixes when currency changes. * java/text/DecimalFormatSymbols.java: (DecimalFormatSymbols(Locale)): Set locale earlier so it can be used by setCurrency(Currency). (setCurrency(Currency)): Set the symbol correctly using the locale of the instance. * java/util/Currency.java: Throw error instead of just printing a message. 2008-08-17 Andrew John Hughes * javax/activation/ActivationDataFlavor.java: Suppress warnings from public API. (mimeType): Made final. (representationClass): Added generic type and made final. (normalizeMimeTypeParameter(String,String)): Use CPStringBuilder. * javax/activation/CommandInfo.java: (verb): Made final. (className): Made final. * javax/activation/DataHandler.java: (dataSource): Made final. * javax/activation/FileDataSource.java: (file): Made final. * javax/activation/MailcapCommandMap.java: Use generics on collections and CPStringBuilder instead of StringBuffer. * javax/activation/MimeType.java: (toString()): Use CPStringBuilder. (getBaseType()): Likewise. * javax/activation/MimeTypeParameterList.java: Use generics on collections and CPStringBuilder instead of StringBuffer. * javax/activation/MimeTypeParseException.java: (MimeTypeParseException(String,String)): Use CPStringBuilder. * javax/activation/MimetypesFileTypeMap.java: Use generics on collections and CPStringBuilder instead of StringBuffer. * javax/activation/URLDataSource.java: (url): Made final. 2008-08-17 Andrew John Hughes * gnu/javax/activation/viewers/ImageViewer.java, * gnu/javax/activation/viewers/TextEditor.java, * gnu/javax/activation/viewers/TextViewer.java, * javax/activation/ActivationDataFlavor.java, * javax/activation/CommandInfo.java, * javax/activation/CommandMap.java, * javax/activation/CommandObject.java, * javax/activation/DataContentHandler.java, * javax/activation/DataContentHandlerFactory.java, * javax/activation/DataHandler.java, * javax/activation/DataHandlerDataSource.java, * javax/activation/DataSource.java, * javax/activation/DataSourceDataContentHandler.java, * javax/activation/FileDataSource.java, * javax/activation/FileTypeMap.java, * javax/activation/MailcapCommandMap.java, * javax/activation/MimeType.java, * javax/activation/MimeTypeParameterList.java, * javax/activation/MimeTypeParseException.java, * javax/activation/MimetypesFileTypeMap.java, * javax/activation/ObjectDataContentHandler.java, * javax/activation/URLDataSource.java, * javax/activation/UnsupportedDataTypeException.java, * javax/activation/package.html, * resource/META-INF/mailcap.default, * resource/META-INF/mimetypes.default: Import GNU JAF CVS as of 17/08/2008. 2006-04-25 Archit Shah * javax/activation/MimeTypeParameterList.java: Insert ';' separator before parameter list. 2005-06-29 Xavier Poinsard * javax/activation/ObjectDataContentHandler.java: Fixed typo. 2005-05-28 Chris Burdess * javax/activation/CommandMap.java, * javax/activation/MailcapCommandMap.java: Updated to JAF 1.1. 2004-06-09 Chris Burdess * javax/activation/MailcapCommandMap.java: Fixed bug whereby x-java prefix was not attempted. 2008-08-17 Andrew John Hughes * AUTHORS: Added Laszlo. 2008-04-20 Andrew John Hughes PR classpath/30436: * java/util/Scanner.java: Fix package to be java.util and correct indentation. 2007-07-25 Laszlo Andras Hernadi PR classpath/30436: * java/util/Scanner.java: Initial implementation. 2008-08-17 Andrew John Hughes * java/util/regex/Matcher.java: (toMatchResult()): Implemented. 2008-08-13 Joshua Sumali * doc/Makefile.am (gjdoc.pod): Generate gjdoc pod from cp-tools.texinfo instead of invoke.texi. Remove invoke.texi from EXTRA_DIST. * doc/invoke.texi: Removed and merged into ... * doc/cp-tools.texinfo: Here 2008-08-12 Robert Schuster * native/jni/java-net/local.c (local_bind): Removed fprintf call, fixed access outside of array bounds. From-SVN: r141271 --- .../javax/activation/ActivationDataFlavor.java | 161 +++++ .../classpath/javax/activation/CommandInfo.java | 117 +++ libjava/classpath/javax/activation/CommandMap.java | 212 ++++++ .../classpath/javax/activation/CommandObject.java | 62 ++ .../javax/activation/DataContentHandler.java | 85 +++ .../activation/DataContentHandlerFactory.java | 56 ++ .../classpath/javax/activation/DataHandler.java | 482 ++++++++++++ .../javax/activation/DataHandlerDataSource.java | 84 +++ libjava/classpath/javax/activation/DataSource.java | 76 ++ .../activation/DataSourceDataContentHandler.java | 126 ++++ .../classpath/javax/activation/FileDataSource.java | 123 ++++ .../classpath/javax/activation/FileTypeMap.java | 108 +++ .../javax/activation/MailcapCommandMap.java | 804 +++++++++++++++++++++ libjava/classpath/javax/activation/MimeType.java | 293 ++++++++ .../javax/activation/MimeTypeParameterList.java | 336 +++++++++ .../javax/activation/MimeTypeParseException.java | 84 +++ .../javax/activation/MimetypesFileTypeMap.java | 440 +++++++++++ .../javax/activation/ObjectDataContentHandler.java | 128 ++++ .../classpath/javax/activation/URLDataSource.java | 138 ++++ .../activation/UnsupportedDataTypeException.java | 70 ++ libjava/classpath/javax/activation/package.html | 44 ++ 21 files changed, 4029 insertions(+) create mode 100644 libjava/classpath/javax/activation/ActivationDataFlavor.java create mode 100644 libjava/classpath/javax/activation/CommandInfo.java create mode 100644 libjava/classpath/javax/activation/CommandMap.java create mode 100644 libjava/classpath/javax/activation/CommandObject.java create mode 100644 libjava/classpath/javax/activation/DataContentHandler.java create mode 100644 libjava/classpath/javax/activation/DataContentHandlerFactory.java create mode 100644 libjava/classpath/javax/activation/DataHandler.java create mode 100644 libjava/classpath/javax/activation/DataHandlerDataSource.java create mode 100644 libjava/classpath/javax/activation/DataSource.java create mode 100644 libjava/classpath/javax/activation/DataSourceDataContentHandler.java create mode 100644 libjava/classpath/javax/activation/FileDataSource.java create mode 100644 libjava/classpath/javax/activation/FileTypeMap.java create mode 100644 libjava/classpath/javax/activation/MailcapCommandMap.java create mode 100644 libjava/classpath/javax/activation/MimeType.java create mode 100644 libjava/classpath/javax/activation/MimeTypeParameterList.java create mode 100644 libjava/classpath/javax/activation/MimeTypeParseException.java create mode 100644 libjava/classpath/javax/activation/MimetypesFileTypeMap.java create mode 100644 libjava/classpath/javax/activation/ObjectDataContentHandler.java create mode 100644 libjava/classpath/javax/activation/URLDataSource.java create mode 100644 libjava/classpath/javax/activation/UnsupportedDataTypeException.java create mode 100644 libjava/classpath/javax/activation/package.html (limited to 'libjava/classpath/javax/activation') diff --git a/libjava/classpath/javax/activation/ActivationDataFlavor.java b/libjava/classpath/javax/activation/ActivationDataFlavor.java new file mode 100644 index 0000000..07ba1a3 --- /dev/null +++ b/libjava/classpath/javax/activation/ActivationDataFlavor.java @@ -0,0 +1,161 @@ +/* ActivationDataFlavor.java -- Activation-specific DataFlavor instance. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +import gnu.java.lang.CPStringBuilder; + +import java.awt.datatransfer.DataFlavor; +import java.io.InputStream; + +/** + * Activation-specific DataFlavor with improved MIME parsing. + * + * @author Chris Burdess + * @version 1.0.2 + */ +public class ActivationDataFlavor extends DataFlavor +{ + + private final String mimeType; + private final Class representationClass; + private String humanPresentableName; + + /** + * Constructor. + * @param representationClass the representation class + * @param mimeType the MIME type of the data + * @param humanPresentableName the human-presentable name of the data + * flavor + */ + // Raw types enforced as part of spec. + @SuppressWarnings("unchecked") + public ActivationDataFlavor(Class representationClass, String mimeType, + String humanPresentableName) + { + super(mimeType, humanPresentableName); + this.mimeType = mimeType; + this.humanPresentableName = humanPresentableName; + this.representationClass = representationClass; + } + + /** + * Constructor. + * @param representationClass the representation class + * @param humanPresentableName the human-presentable name of the data + * flavor + */ + // Raw types enforced as part of spec. + @SuppressWarnings("unchecked") + public ActivationDataFlavor(Class representationClass, + String humanPresentableName) + { + super(representationClass, humanPresentableName); + mimeType = super.getMimeType(); + this.representationClass = representationClass; + this.humanPresentableName = humanPresentableName; + } + + /** + * Constructor. The representation class is an InputStream. + * @param mimeType the MIME type of the data + * @param humanPresentableName the human-presentable name of the data + * flavor + */ + public ActivationDataFlavor(String mimeType, String humanPresentableName) + { + super(mimeType, humanPresentableName); + this.mimeType = mimeType; + this.humanPresentableName = humanPresentableName; + representationClass = InputStream.class; + } + + public String getMimeType() + { + return mimeType; + } + + // Raw types enforced as part of spec. + @SuppressWarnings("unchecked") + public Class getRepresentationClass() + { + return representationClass; + } + + public String getHumanPresentableName() + { + return humanPresentableName; + } + + public void setHumanPresentableName(String humanPresentableName) + { + this.humanPresentableName = humanPresentableName; + } + + public boolean equals(DataFlavor dataFlavor) + { + return (isMimeTypeEqual(dataFlavor) && + dataFlavor.getRepresentationClass() == representationClass); + } + + public boolean isMimeTypeEqual(String mimeType) + { + try + { + return new MimeType(this.mimeType).match(new MimeType(mimeType)); + } + catch (MimeTypeParseException e) + { + return false; + } + } + + protected String normalizeMimeTypeParameter(String parameterName, + String parameterValue) + { + return new CPStringBuilder(parameterName) + .append('=') + .append(parameterValue) + .toString(); + } + + protected String normalizeMimeType(String mimeType) + { + return mimeType; + } + +} diff --git a/libjava/classpath/javax/activation/CommandInfo.java b/libjava/classpath/javax/activation/CommandInfo.java new file mode 100644 index 0000000..d420c6e --- /dev/null +++ b/libjava/classpath/javax/activation/CommandInfo.java @@ -0,0 +1,117 @@ +/* CommandInfo.java -- Description of the result of a command request. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +import java.beans.Beans; +import java.io.Externalizable; +import java.io.InputStream; +import java.io.IOException; +import java.io.ObjectInputStream; + +/** + * Description of the result of a command request. + * + * @author Chris Burdess + * @version 1.1 + */ +public class CommandInfo +{ + + private final String verb; + private final String className; + + /** + * Constructor. + * @param verb the command verb + * @param className the command class name + */ + public CommandInfo(String verb, String className) + { + this.verb = verb; + this.className = className; + } + + /** + * Returns the command verb. + */ + public String getCommandName() + { + return verb; + } + + /** + * Returns the command class name. + */ + public String getCommandClass() + { + return className; + } + + /** + * Returns the instantiated bean. + * If the bean implements CommandObject, its + * setCommandContext method will be called. + * @param dh the data handler describing the command data + * @param loader the class loader used to instantiate the bean + */ + public Object getCommandObject(DataHandler dh, ClassLoader loader) + throws IOException, ClassNotFoundException + { + Object object = Beans.instantiate(loader, className); + if (object != null) + { + if (object instanceof CommandObject) + { + CommandObject command = (CommandObject)object; + command.setCommandContext(verb, dh); + } + else if (dh != null && (object instanceof Externalizable)) + { + InputStream in = dh.getInputStream(); + if (in != null) + { + Externalizable externalizable = (Externalizable)object; + externalizable.readExternal(new ObjectInputStream(in)); + } + } + } + return object; + } + +} + diff --git a/libjava/classpath/javax/activation/CommandMap.java b/libjava/classpath/javax/activation/CommandMap.java new file mode 100644 index 0000000..fd74961 --- /dev/null +++ b/libjava/classpath/javax/activation/CommandMap.java @@ -0,0 +1,212 @@ +/* CommandMap.java -- Registry of available command objects. + Copyright (C) 2004, 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +/** + * Registry of command objects available to the system. + * + * @author Chris Burdess + * @version 1.1 + */ +public abstract class CommandMap +{ + + /* Class scope */ + + private static CommandMap defaultCommandMap; + + /** + * Returns the default command map. + * This returns a MailcapCommandMap if no value has been set using + * setDefaultCommandMap. + */ + public static CommandMap getDefaultCommandMap() + { + if (defaultCommandMap == null) + { + defaultCommandMap = new MailcapCommandMap(); + } + return defaultCommandMap; + } + + /** + * Sets the default command map. + * @param commandMap the new default command map + */ + public static void setDefaultCommandMap(CommandMap commandMap) + { + SecurityManager security = System.getSecurityManager(); + if (security != null) + { + try + { + security.checkSetFactory(); + } + catch (SecurityException e) + { + if (commandMap != null && CommandMap.class.getClassLoader() != + commandMap.getClass().getClassLoader()) + { + throw e; + } + } + } + defaultCommandMap = commandMap; + } + + /* Instance scope */ + + /** + * Returns the list of preferred commands for a MIME type. + * @param mimeType the MIME type + */ + public abstract CommandInfo[] getPreferredCommands(String mimeType); + + /** + * Returns the complete list of commands for a MIME type. + * @param mimeType the MIME type + */ + public abstract CommandInfo[] getAllCommands(String mimeType); + + /** + * Returns the command corresponding to the specified MIME type and + * command name. + * @param mimeType the MIME type + * @param cmdName the command name + */ + public abstract CommandInfo getCommand(String mimeType, String cmdName); + + /** + * Returns a DataContentHandler corresponding to the MIME type. + * @param mimeType the MIME type + */ + public abstract DataContentHandler createDataContentHandler(String mimeType); + + /** + * Get all the MIME types known to this command map. + * If the command map doesn't support this operation, null is returned. + * @return array of MIME types as strings, or null if not supported + * @since JAF 1.1 + */ + public String[] getMimeTypes() + { + return null; + } + + /** + * Get the preferred command list from a MIME Type. The actual semantics + * are determined by the implementation of the CommandMap. + *

+ * The DataSource provides extra information, such as + * the file name, that a CommandMap implementation may use to further + * refine the list of commands that are returned. The implementation + * in this class simply calls the getPreferredCommands + * method that ignores this argument. + * @param mimeType the MIME type + * @param ds a DataSource for the data + * @return the CommandInfo classes that represent the command Beans. + * @since JAF 1.1 + */ + public CommandInfo[] getPreferredCommands(String mimeType, + DataSource ds) + { + return getPreferredCommands(mimeType); + } + + /** + * Get all the available commands for this type. This method + * should return all the possible commands for this MIME type. + *

+ * The DataSource provides extra information, such as + * the file name, that a CommandMap implementation may use to further + * refine the list of commands that are returned. The implementation + * in this class simply calls the getAllCommands + * method that ignores this argument. + * @param mimeType the MIME type + * @param ds a DataSource for the data + * @return the CommandInfo objects representing all the commands. + * @since JAF 1.1 + */ + public CommandInfo[] getAllCommands(String mimeType, DataSource ds) + { + return getAllCommands(mimeType); + } + + /** + * Get the default command corresponding to the MIME type. + *

+ * The DataSource provides extra information, such as + * the file name, that a CommandMap implementation may use to further + * refine the command that is chosen. The implementation + * in this class simply calls the getCommand + * method that ignores this argument. + * @param mimeType the MIME type + * @param cmdName the command name + * @param ds a DataSource for the data + * @return the CommandInfo corresponding to the command. + * @since JAF 1.1 + */ + public CommandInfo getCommand(String mimeType, String cmdName, + DataSource ds) + { + return getCommand(mimeType, cmdName); + } + + /** + * Locate a DataContentHandler that corresponds to the MIME type. + * The mechanism and semantics for determining this are determined + * by the implementation of the particular CommandMap. + *

+ * The DataSource provides extra information, such as + * the file name, that a CommandMap implementation may use to further + * refine the choice of DataContentHandler. The implementation + * in this class simply calls the createDataContentHandler + * method that ignores this argument. + * @param mimeType the MIME type + * @param ds a DataSource for the data + * @return the DataContentHandler for the MIME type + * @since JAF 1.1 + */ + public DataContentHandler createDataContentHandler(String mimeType, + DataSource ds) + { + return createDataContentHandler(mimeType); + } + +} + diff --git a/libjava/classpath/javax/activation/CommandObject.java b/libjava/classpath/javax/activation/CommandObject.java new file mode 100644 index 0000000..594622d --- /dev/null +++ b/libjava/classpath/javax/activation/CommandObject.java @@ -0,0 +1,62 @@ +/* CommandObject.java -- Bean interface for notifications. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +import java.io.IOException; + +/** + * Bean interface to implement in order to receive notification of the + * command verb. + * + * @author Chris Burdess + * @version 1.1 + */ +public interface CommandObject +{ + + /** + * Initializes the command with the verb it is expected to perform and + * the data handler describing the data to operate on. + * @param verb the command verb + * @param dh the data handler describing the data to process + */ + void setCommandContext(String verb, DataHandler dh) + throws IOException; + +} + diff --git a/libjava/classpath/javax/activation/DataContentHandler.java b/libjava/classpath/javax/activation/DataContentHandler.java new file mode 100644 index 0000000..f950739 --- /dev/null +++ b/libjava/classpath/javax/activation/DataContentHandler.java @@ -0,0 +1,85 @@ +/* DataContentHandler.java -- Converts streams to objects and vice versa. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +import java.awt.datatransfer.DataFlavor; +import java.awt.datatransfer.UnsupportedFlavorException; +import java.io.IOException; +import java.io.OutputStream; + +/** + * Provider that can convert streams to objects and vice versa. + * + * @author Chris Burdess + * @version 1.1 + */ +public interface DataContentHandler +{ + + /** + * Returns a list of the flavors that data can be provided in, ordered + * by preference. + */ + DataFlavor[] getTransferDataFlavors(); + + /** + * Returns an object representing the data to be transferred. + * @param df the flavor representing the requested type + * @param ds the data source of the data to be converted + */ + Object getTransferData(DataFlavor df, DataSource ds) + throws UnsupportedFlavorException, IOException; + + /** + * Returns an object representing the data in its most preferred form. + * @param ds the data source of the data to be converted + */ + Object getContent(DataSource ds) + throws IOException; + + /** + * Writes the object as a stream of bytes. + * @param obj the object to convert + * @param mimeType the MIME type of the stream + * @param os the byte stream + */ + void writeTo(Object obj, String mimeType, OutputStream os) + throws IOException; + +} + diff --git a/libjava/classpath/javax/activation/DataContentHandlerFactory.java b/libjava/classpath/javax/activation/DataContentHandlerFactory.java new file mode 100644 index 0000000..c1f2b78 --- /dev/null +++ b/libjava/classpath/javax/activation/DataContentHandlerFactory.java @@ -0,0 +1,56 @@ +/* DataContentHandlerFactory.java -- Factory for creating DataContentHandlers. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +/** + * Factory interface for creating data content handlers. + * + * @author Chris Burdess + * @version 1.1 + */ +public interface DataContentHandlerFactory +{ + + /** + * Returns a new data content handler for the specified MIME type. + * @param mimeType the MIME type + */ + DataContentHandler createDataContentHandler(String mimeType); + +} + diff --git a/libjava/classpath/javax/activation/DataHandler.java b/libjava/classpath/javax/activation/DataHandler.java new file mode 100644 index 0000000..de786f9 --- /dev/null +++ b/libjava/classpath/javax/activation/DataHandler.java @@ -0,0 +1,482 @@ +/* DataHandler.java -- Handler for data available in multiple formats. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +import java.awt.datatransfer.DataFlavor; +import java.awt.datatransfer.Transferable; +import java.awt.datatransfer.UnsupportedFlavorException; +import java.io.InputStream; +import java.io.IOException; +import java.io.OutputStream; +import java.io.PipedInputStream; +import java.io.PipedOutputStream; +import java.net.URL; + +/** + * Handler for data available in multiple sources and formats. + * + * @author Chris Burdess + * @version 1.1 + */ +public class DataHandler + implements Transferable +{ + + private static final DataFlavor[] NO_FLAVORS = new DataFlavor[0]; + private static DataContentHandlerFactory factory = null; + + private final DataSource dataSource; + private DataSource objDataSource; + private Object object; + private String objectMimeType; + private CommandMap currentCommandMap; + private DataFlavor[] transferFlavors = NO_FLAVORS; + private DataContentHandler dataContentHandler; + private DataContentHandler factoryDCH; + private DataContentHandlerFactory oldFactory; + private String shortType; + + /** + * Constructor in which the data is read from a data source. + * @param ds the data source + */ + public DataHandler(DataSource ds) + { + dataSource = ds; + oldFactory = factory; + } + + /** + * Constructor using a reified object representation. + * @param obj the object representation of the data + * @param mimeType the MIME type of the object + */ + public DataHandler(Object obj, String mimeType) + { + dataSource = null; + object = obj; + objectMimeType = mimeType; + oldFactory = factory; + } + + /** + * Constructor in which the data is read from a URL. + * @param url the URL + */ + public DataHandler(URL url) + { + dataSource = new URLDataSource(url); + oldFactory = factory; + } + + /** + * Returns the data source from which data is read. + */ + public DataSource getDataSource() + { + if (dataSource != null) + { + return dataSource; + } + if (objDataSource == null) + { + objDataSource = new DataHandlerDataSource(this); + } + return objDataSource; + } + + /** + * Returns the name of the data object if created with a DataSource. + */ + public String getName() + { + if (dataSource != null) + { + return dataSource.getName(); + } + return null; + } + + /** + * Returns the MIME type of the data (with parameters). + */ + public String getContentType() + { + if (dataSource != null) + { + return dataSource.getContentType(); + } + return objectMimeType; + } + + /** + * Returns an input stream from which the data can be read. + */ + public InputStream getInputStream() + throws IOException + { + if (dataSource != null) + { + return dataSource.getInputStream(); + } + DataContentHandler dch = getDataContentHandler(); + if (dch == null) + { + throw new UnsupportedDataTypeException("no DCH for MIME type " + + getShortType()); + } + if ((dch instanceof ObjectDataContentHandler) && + ((ObjectDataContentHandler)dch).getDCH() == null) + { + throw new UnsupportedDataTypeException("no object DCH " + + "for MIME type " + + getShortType()); + } + PipedOutputStream pos = new PipedOutputStream(); + DataContentHandlerWriter dchw = + new DataContentHandlerWriter(dch, object, objectMimeType, pos); + Thread thread = new Thread(dchw, "DataHandler.getInputStream"); + thread.start(); + return new PipedInputStream(pos); + } + + static class DataContentHandlerWriter + implements Runnable + { + + DataContentHandler dch; + Object object; + String mimeType; + OutputStream out; + + DataContentHandlerWriter(DataContentHandler dch, Object object, + String mimeType, OutputStream out) + { + this.dch = dch; + this.object = object; + this.mimeType = mimeType; + this.out = out; + } + + public void run() + { + try + { + dch.writeTo(object, mimeType, out); + } + catch(IOException e) + { + } + finally + { + try + { + out.close(); + } + catch(IOException e) + { + } + } + } + } + + /** + * Writes the data as a byte stream. + * @param os the stream to write to + */ + public void writeTo(OutputStream os) + throws IOException + { + if (dataSource != null) + { + InputStream in = dataSource.getInputStream(); + byte[] buf = new byte[8192]; + for (int len = in.read(buf); len != -1; len = in.read(buf)) + { + os.write(buf, 0, len); + } + in.close(); + } + else + { + DataContentHandler dch = getDataContentHandler(); + dch.writeTo(object, objectMimeType, os); + } + } + + /** + * Returns an output stream that can be used to overwrite the underlying + * data, if the DataSource constructor was used. + */ + public OutputStream getOutputStream() + throws IOException + { + if (dataSource != null) + { + return dataSource.getOutputStream(); + } + return null; + } + + /** + * Returns the data flavors in which this data is available. + */ + public synchronized DataFlavor[] getTransferDataFlavors() + { + if (factory != oldFactory || transferFlavors == NO_FLAVORS) + { + DataContentHandler dch = getDataContentHandler(); + transferFlavors = dch.getTransferDataFlavors(); + } + return transferFlavors; + } + + /** + * Indicates whether the specified data flavor is supported for this + * data. + */ + public boolean isDataFlavorSupported(DataFlavor flavor) + { + DataFlavor[] flavors = getTransferDataFlavors(); + for (int i = 0; i < flavors.length; i++) + { + if (flavors[i].equals(flavor)) + { + return true; + } + } + return false; + } + + /** + * Returns an object representing the data to be transferred. + * @param flavor the requested data flavor + */ + public Object getTransferData(DataFlavor flavor) + throws UnsupportedFlavorException, IOException + { + DataContentHandler dch = getDataContentHandler(); + return dch.getTransferData(flavor, dataSource); + } + + /** + * Sets the command map to be used by this data handler. + * Setting to null uses the default command map. + * @param commandMap the command map to use + */ + public synchronized void setCommandMap(CommandMap commandMap) + { + if (commandMap != currentCommandMap || commandMap == null) + { + transferFlavors = NO_FLAVORS; + dataContentHandler = null; + currentCommandMap = commandMap; + } + } + + /** + * Returns the preferred commands for this type of data. + */ + public CommandInfo[] getPreferredCommands() + { + CommandMap commandMap = getCommandMap(); + return commandMap.getPreferredCommands(getShortType()); + } + + /** + * Returns the complete list of commands for this type of data. + */ + public CommandInfo[] getAllCommands() + { + CommandMap commandMap = getCommandMap(); + return commandMap.getAllCommands(getShortType()); + } + + /** + * Returns the specified command. + * @param cmdName the command name + */ + public CommandInfo getCommand(String cmdName) + { + CommandMap commandMap = getCommandMap(); + return commandMap.getCommand(getShortType(), cmdName); + } + + /** + * Returns the data as a reified object. + */ + public Object getContent() + throws IOException + { + DataContentHandler dch = getDataContentHandler(); + return dch.getContent(getDataSource()); + } + + /** + * Returns the instantiated bean using the specified command. + * @param cmdInfo the command to instantiate the bean with + */ + public Object getBean(CommandInfo cmdInfo) + { + try + { + return cmdInfo.getCommandObject(this, getClass().getClassLoader()); + } + catch (IOException e) + { + e.printStackTrace(System.err); + return null; + } + catch (ClassNotFoundException e) + { + e.printStackTrace(System.err); + return null; + } + } + + /** + * Sets the data content handler factory. + * If the factory has already been set, throws an Error. + * @param newFactory the factory to set + */ + public static synchronized void + setDataContentHandlerFactory(DataContentHandlerFactory newFactory) + { + if (factory != null) + { + throw new Error("DataContentHandlerFactory already defined"); + } + SecurityManager security = System.getSecurityManager(); + if (security != null) + { + try + { + security.checkSetFactory(); + } + catch (SecurityException e) + { + if (newFactory != null && DataHandler.class.getClassLoader() + != newFactory.getClass().getClassLoader()) + { + throw e; + } + } + } + factory = newFactory; + } + + /* + * Returns just the base part of the data's content-type, with no + * parameters. + */ + private synchronized String getShortType() + { + if (shortType == null) + { + String contentType = getContentType(); + try + { + MimeType mimeType = new MimeType(contentType); + shortType = mimeType.getBaseType(); + } + catch (MimeTypeParseException e) + { + shortType = contentType; + } + } + return shortType; + } + + /* + * Returns the command map for this handler. + */ + private synchronized CommandMap getCommandMap() + { + if (currentCommandMap != null) + { + return currentCommandMap; + } + return CommandMap.getDefaultCommandMap(); + } + + /* + * Returns the DCH for this handler. + */ + private synchronized DataContentHandler getDataContentHandler() + { + if (factory != oldFactory) + { + oldFactory = factory; + factoryDCH = null; + dataContentHandler = null; + transferFlavors = NO_FLAVORS; + } + if (dataContentHandler != null) + { + return dataContentHandler; + } + String mimeType = getShortType(); + if (factoryDCH == null && factory != null) + { + factoryDCH = factory.createDataContentHandler(mimeType); + } + if (factoryDCH != null) + { + dataContentHandler = factoryDCH; + } + if (dataContentHandler == null) + { + CommandMap commandMap = getCommandMap(); + dataContentHandler = commandMap.createDataContentHandler(mimeType); + } + if (dataSource != null) + { + dataContentHandler = + new DataSourceDataContentHandler(dataContentHandler, dataSource); + } + else + { + dataContentHandler = + new ObjectDataContentHandler(dataContentHandler, object, + objectMimeType); + } + return dataContentHandler; + } + +} + diff --git a/libjava/classpath/javax/activation/DataHandlerDataSource.java b/libjava/classpath/javax/activation/DataHandlerDataSource.java new file mode 100644 index 0000000..8dcd1a7 --- /dev/null +++ b/libjava/classpath/javax/activation/DataHandlerDataSource.java @@ -0,0 +1,84 @@ +/* DataHandlerDataSource.java -- Data source proxy for a DataHandler. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +import java.io.InputStream; +import java.io.IOException; +import java.io.OutputStream; + +/** + * Data source that is a proxy for a data handler. + * + * @author Chris Burdess + * @version 1.1 + */ +final class DataHandlerDataSource + implements DataSource +{ + + final DataHandler dh; + + DataHandlerDataSource(DataHandler dh) + { + this.dh = dh; + } + + public String getContentType() + { + return dh.getContentType(); + } + + public InputStream getInputStream() + throws IOException + { + return dh.getInputStream(); + } + + public String getName() + { + return dh.getName(); + } + + public OutputStream getOutputStream() + throws IOException + { + return dh.getOutputStream(); + } + +} + diff --git a/libjava/classpath/javax/activation/DataSource.java b/libjava/classpath/javax/activation/DataSource.java new file mode 100644 index 0000000..0d70843 --- /dev/null +++ b/libjava/classpath/javax/activation/DataSource.java @@ -0,0 +1,76 @@ +/* DataSource.java -- An interface for MIME data storage and retrieval. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +import java.io.InputStream; +import java.io.IOException; +import java.io.OutputStream; + +/** + * An interface by which MIME data can be retrieved and stored. + * + * @author Chris Burdess + * @version 1.1 + */ +public interface DataSource +{ + + /** + * Returns an input stream from which the data can be read. + */ + InputStream getInputStream() + throws IOException; + + /** + * Returns an output stream to which the data can be written. + */ + OutputStream getOutputStream() + throws IOException; + + /** + * Returns the MIME content type of the data. + */ + String getContentType(); + + /** + * Returns the underlying name of this object. + */ + String getName(); + +} + diff --git a/libjava/classpath/javax/activation/DataSourceDataContentHandler.java b/libjava/classpath/javax/activation/DataSourceDataContentHandler.java new file mode 100644 index 0000000..9706ac1 --- /dev/null +++ b/libjava/classpath/javax/activation/DataSourceDataContentHandler.java @@ -0,0 +1,126 @@ +/* DataSourceDataContentHolder.java -- DCH using an existing data source. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +import java.awt.datatransfer.DataFlavor; +import java.awt.datatransfer.UnsupportedFlavorException; +import java.io.IOException; +import java.io.OutputStream; + +/** + * Data content handler using an existing DCH and a data source. + * + * @author Chris Burdess + * @version 1.1 + */ +class DataSourceDataContentHandler + implements DataContentHandler +{ + + private DataSource ds; + private DataFlavor[] flavors; + private DataContentHandler dch; + + public DataSourceDataContentHandler(DataContentHandler dch, DataSource ds) + { + this.ds = ds; + this.dch = dch; + } + + public Object getContent(DataSource ds) + throws IOException + { + if (dch != null) + { + return dch.getContent(ds); + } + else + { + return ds.getInputStream(); + } + } + + public Object getTransferData(DataFlavor flavor, DataSource ds) + throws UnsupportedFlavorException, IOException + { + if (dch != null) + { + return dch.getTransferData(flavor, ds); + } + DataFlavor[] tdf = getTransferDataFlavors(); + if (tdf.length > 0 && flavor.equals(tdf[0])) + { + return ds.getInputStream(); + } + else + { + throw new UnsupportedFlavorException(flavor); + } + } + + public DataFlavor[] getTransferDataFlavors() + { + if (flavors == null) + { + if (dch != null) + { + flavors = dch.getTransferDataFlavors(); + } + else + { + String mimeType = ds.getContentType(); + flavors = new DataFlavor[1]; + flavors[0] = new ActivationDataFlavor(mimeType, mimeType); + } + } + return flavors; + } + + public void writeTo(Object obj, String mimeType, OutputStream out) + throws IOException + { + if (dch == null) + { + throw new UnsupportedDataTypeException("no DCH for content type " + + ds.getContentType()); + } + dch.writeTo(obj, mimeType, out); + } + +} + diff --git a/libjava/classpath/javax/activation/FileDataSource.java b/libjava/classpath/javax/activation/FileDataSource.java new file mode 100644 index 0000000..6e9035f --- /dev/null +++ b/libjava/classpath/javax/activation/FileDataSource.java @@ -0,0 +1,123 @@ +/* FileDataSource.java -- Data source for a File object. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.InputStream; +import java.io.IOException; +import java.io.OutputStream; + +/** + * Data source encapsulating a file. + * + * @author Chris Burdess + * @version 1.1 + */ +public class FileDataSource + implements DataSource +{ + + private final File file; + private FileTypeMap typeMap; + + /** + * Constructor. + * @param file the underlying file to use + */ + public FileDataSource(File file) + { + this.file = file; + } + + /** + * Constructor. + * @param name the path to the underlying file to use + */ + public FileDataSource(String name) + { + this(new File(name)); + } + + public InputStream getInputStream() + throws IOException + { + return new FileInputStream(file); + } + + public OutputStream getOutputStream() + throws IOException + { + return new FileOutputStream(file); + } + + public String getContentType() + { + if (typeMap == null) + { + FileTypeMap dftm = FileTypeMap.getDefaultFileTypeMap(); + return dftm.getContentType(file); + } + return typeMap.getContentType(file); + } + + public String getName() + { + return file.getName(); + } + + /** + * Returns the underlying file. + */ + public File getFile() + { + return file; + } + + /** + * Sets the file type map to use to determine the content type of the file. + * @param map the file type map + */ + public void setFileTypeMap(FileTypeMap map) + { + typeMap = map; + } + +} + diff --git a/libjava/classpath/javax/activation/FileTypeMap.java b/libjava/classpath/javax/activation/FileTypeMap.java new file mode 100644 index 0000000..2ef7805 --- /dev/null +++ b/libjava/classpath/javax/activation/FileTypeMap.java @@ -0,0 +1,108 @@ +/* FileTypeMap.java -- Classifies the MIME content of files. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +import java.io.File; + +/** + * Classifier for the MIME content type of files. + * + * @author Chris Burdess + * @version 1.1 + */ +public abstract class FileTypeMap +{ + + /* Class scope */ + + private static FileTypeMap defaultMap; + + /** + * Returns the system default file type map. + * If one has not been set, this returns a MimetypesFileTypeMap. + */ + public static FileTypeMap getDefaultFileTypeMap() + { + if (defaultMap == null) + { + defaultMap = new MimetypesFileTypeMap(); + } + return defaultMap; + } + + /** + * Sets the default file type map. + * @param map the new file type map + */ + public static void setDefaultFileTypeMap(FileTypeMap map) + { + SecurityManager security = System.getSecurityManager(); + if (security != null) + { + try + { + security.checkSetFactory(); + } + catch (SecurityException e) + { + if (map != null && FileTypeMap.class.getClassLoader() != + map.getClass().getClassLoader()) + { + throw e; + } + } + } + defaultMap = map; + } + + /* Instance scope */ + + /** + * Returns the content type of the specified file. + * @param file the file to classify + */ + public abstract String getContentType(File file); + + /** + * Returns the content type of the specified file path. + * @param filename the path of the file to classify + */ + public abstract String getContentType(String filename); + +} + diff --git a/libjava/classpath/javax/activation/MailcapCommandMap.java b/libjava/classpath/javax/activation/MailcapCommandMap.java new file mode 100644 index 0000000..cca5f04 --- /dev/null +++ b/libjava/classpath/javax/activation/MailcapCommandMap.java @@ -0,0 +1,804 @@ +/* MailcapCommandMap.java -- Command map implementation using a mailcap file. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +import gnu.java.lang.CPStringBuilder; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.IOException; +import java.io.Reader; +import java.io.StringReader; +import java.net.URL; +import java.util.ArrayList; +import java.util.Enumeration; +import java.util.LinkedHashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +/** + * Implementation of a command map using a mailcap file (RFC + * 1524). Mailcap files are searched for in the following places: + *

    + *
  1. Programmatically added entries to this interface
    2. + *
  2. the file .mailcap in the user's home directory
    3. + *
  3. the file <java.home>/lib/mailcap
    4. + *
  4. the resource META-INF/mailcap
    5. + *
  5. the resource META-INF/mailcap.default in the JAF + * distribution
    6. + *
+ * + * @author Chris Burdess + * @version 1.1 + */ +public class MailcapCommandMap + extends CommandMap +{ + + private static final int PROG = 0; + private static final int HOME = 1; + private static final int SYS = 2; + private static final int JAR = 3; + private static final int DEF = 4; + private static boolean debug = false; + private static final int NORMAL = 0; + private static final int FALLBACK = 1; + + static + { + try + { + String d = System.getProperty("javax.activation.debug"); + debug = Boolean.valueOf(d).booleanValue(); + } + catch (SecurityException e) + { + } + } + + private Map>>[][] mailcaps; + + /** + * Default constructor. + */ + public MailcapCommandMap() + { + init(null); + } + + /** + * Constructor specifying a filename. + * @param fileName the name of the file to read mailcap entries from + */ + public MailcapCommandMap(String fileName) + throws IOException + { + Reader in = null; + try + { + in = new FileReader(fileName); + } + catch (IOException e) + { + } + init(in); + if (in != null) + { + try + { + in.close(); + } + catch (IOException e) + { + } + } + } + + /** + * Constructor specifying an input stream. + * @param is the input stream to read mailcap entries from + */ + public MailcapCommandMap(InputStream is) + { + init(new InputStreamReader(is)); + } + + private void init(Reader in) + { + mailcaps = new Map[5][2]; + for (int i = 0; i < 5; i++) + { + for (int j = 0; j < 2; j++) + { + mailcaps[i][j] = + new LinkedHashMap>>(); + } + } + if (in != null) + { + if (debug) + { + System.out.println("MailcapCommandMap: load PROG"); + } + try + { + parse(PROG, in); + } + catch (IOException e) + { + } + } + + if (debug) + { + System.out.println("MailcapCommandMap: load HOME"); + } + try + { + String home = System.getProperty("user.home"); + if (home != null) + { + parseFile(HOME, new CPStringBuilder(home) + .append(File.separatorChar) + .append(".mailcap") + .toString()); + } + } + catch (SecurityException e) + { + } + + if (debug) + { + System.out.println("MailcapCommandMap: load SYS"); + } + try + { + parseFile(SYS, + new CPStringBuilder(System.getProperty("java.home")) + .append(File.separatorChar) + .append("lib") + .append(File.separatorChar) + .append("mailcap") + .toString()); + } + catch (SecurityException e) + { + } + + if (debug) + { + System.out.println("MailcapCommandMap: load JAR"); + } + List systemResources = getSystemResources("META-INF/mailcap"); + int len = systemResources.size(); + if (len > 0) + { + for (int i = 0; i < len ; i++) + { + Reader urlIn = null; + URL url = systemResources.get(i); + try + { + if (debug) + { + System.out.println("\t" + url.toString()); + } + urlIn = new InputStreamReader(url.openStream()); + parse(JAR, urlIn); + } + catch (IOException e) + { + if (debug) + { + System.out.println(e.getClass().getName() + ": " + + e.getMessage()); + } + } + finally + { + if (urlIn != null) + { + try + { + urlIn.close(); + } + catch (IOException e) + { + } + } + } + } + } + else + { + parseResource(JAR, "/META-INF/mailcap"); + } + + if (debug) + { + System.out.println("MailcapCommandMap: load DEF"); + } + parseResource(DEF, "/META-INF/mailcap.default"); + } + + /** + * Returns the list of preferred commands for a given MIME type. + * @param mimeType the MIME type + */ + public synchronized CommandInfo[] getPreferredCommands(String mimeType) + { + List cmdList = new ArrayList(); + List verbList = new ArrayList(); + for (int i = 0; i < 2; i++) + { + for (int j = 0; j < 5; j++) + { + Map> map = getCommands(mailcaps[j][i], mimeType); + if (map != null) + { + for (Map.Entry> entry : map.entrySet()) + { + String verb = entry.getKey(); + if (!verbList.contains(verb)) + { + List classNames = entry.getValue(); + String className = classNames.get(0); + CommandInfo cmd = new CommandInfo(verb, className); + cmdList.add(cmd); + verbList.add(verb); + } + } + } + } + } + CommandInfo[] cmds = new CommandInfo[cmdList.size()]; + cmdList.toArray(cmds); + return cmds; + } + + /** + * Returns all commands for the given MIME type. + * @param mimeType the MIME type + */ + public synchronized CommandInfo[] getAllCommands(String mimeType) + { + List cmdList = new ArrayList(); + for (int i = 0; i < 2; i++) + { + for (int j = 0; j < 5; j++) + { + Map> map = getCommands(mailcaps[j][i], mimeType); + if (map != null) + { + for (Map.Entry> entry : map.entrySet()) + { + String verb = entry.getKey(); + List classNames = entry.getValue(); + int len = classNames.size(); + for (int l = 0; l < len; l++) + { + String className = classNames.get(l); + CommandInfo cmd = new CommandInfo(verb, className); + cmdList.add(cmd); + } + } + } + } + } + CommandInfo[] cmds = new CommandInfo[cmdList.size()]; + cmdList.toArray(cmds); + return cmds; + } + + /** + * Returns the command with the specified name for the given MIME type. + * @param mimeType the MIME type + * @param cmdName the command verb + */ + public synchronized CommandInfo getCommand(String mimeType, + String cmdName) + { + for (int i = 0; i < 2; i++) + { + for (int j = 0; j < 5; j++) + { + Map> map = + getCommands(mailcaps[j][i], mimeType); + if (map != null) + { + List classNames = map.get(cmdName); + if (classNames == null) + { + classNames = map.get("x-java-" + cmdName); + } + if (classNames != null) + { + String className = classNames.get(0); + return new CommandInfo(cmdName, className); + } + } + } + } + return null; + } + + /** + * Adds entries programmatically to the registry. + * @param mailcap a mailcap string + */ + public synchronized void addMailcap(String mailcap) + { + if (debug) + { + System.out.println("MailcapCommandMap: add to PROG"); + } + try + { + parse(PROG, new StringReader(mailcap)); + } + catch (IOException e) + { + } + } + + /** + * Returns the DCH for the specified MIME type. + * @param mimeType the MIME type + */ + public synchronized DataContentHandler + createDataContentHandler(String mimeType) + { + if (debug) + { + System.out.println("MailcapCommandMap: " + + "createDataContentHandler for " + mimeType); + } + for (int i = 0; i < 2; i++) + { + for (int j = 0; j < 5; j++) + { + if (debug) + { + System.out.println(" search DB #" + i); + } + Map> map = getCommands(mailcaps[j][i], mimeType); + if (map != null) + { + List classNames = map.get("content-handler"); + if (classNames == null) + { + classNames = map.get("x-java-content-handler"); + } + if (classNames != null) + { + String className = classNames.get(0); + if (debug) + { + System.out.println(" In " + nameOf(j) + + ", content-handler=" + className); + } + try + { + Class clazz = Class.forName(className); + return (DataContentHandler)clazz.newInstance(); + } + catch (IllegalAccessException e) + { + if (debug) + { + e.printStackTrace(); + } + } + catch (ClassNotFoundException e) + { + if (debug) + { + e.printStackTrace(); + } + } + catch (InstantiationException e) + { + if (debug) + { + e.printStackTrace(); + } + } + } + } + } + } + return null; + } + + /** + * Get the native commands for the given MIME type. + * Returns an array of strings where each string is + * an entire mailcap file entry. The application + * will need to parse the entry to extract the actual + * command as well as any attributes it needs. See + * RFC 1524 + * for details of the mailcap entry syntax. Only mailcap + * entries that specify a view command for the specified + * MIME type are returned. + * @return array of native command entries + * @since JAF 1.1 + */ + public String[] getNativeCommands(String mimeType) + { + List acc = new ArrayList(); + for (int i = 0; i < 2; i++) + { + for (int j = 0; j < 5; j++) + { + addNativeCommands(acc, mailcaps[j][i], mimeType); + } + } + String[] ret = new String[acc.size()]; + acc.toArray(ret); + return ret; + } + + private void addNativeCommands(List acc, + Map>> mailcap, + String mimeType) + { + for (Map.Entry>> mEntry : mailcap.entrySet()) + { + String entryMimeType = mEntry.getKey(); + if (!entryMimeType.equals(mimeType)) + { + continue; + } + Map> commands = mEntry.getValue(); + String viewCommand = commands.get("view-command").get(0); + if (viewCommand == null) + { + continue; + } + CPStringBuilder buf = new CPStringBuilder(); + buf.append(mimeType); + buf.append(';'); + buf.append(' '); + buf.append(viewCommand); + for (Map.Entry> cEntry : commands.entrySet()) + { + String verb = cEntry.getKey(); + List classNames = cEntry.getValue(); + if (!"view-command".equals(verb)) + { + for (String command : classNames) + { + buf.append(';'); + buf.append(' '); + buf.append(verb); + buf.append('='); + buf.append(command); + } + } + } + if (buf.length() > 0) + { + acc.add(buf.toString()); + } + } + } + + private static String nameOf(int mailcap) + { + switch (mailcap) + { + case PROG: + return "PROG"; + case HOME: + return "HOME"; + case SYS: + return "SYS"; + case JAR: + return "JAR"; + case DEF: + return "DEF"; + default: + return "ERR"; + } + } + + private void parseFile(int index, String filename) + { + Reader in = null; + try + { + if (debug) + { + System.out.println("\t" + filename); + } + in = new FileReader(filename); + parse(index, in); + } + catch (IOException e) + { + if (debug) + { + System.out.println(e.getClass().getName() + ": " + + e.getMessage()); + } + } + finally + { + if (in != null) + { + try + { + in.close(); + } + catch (IOException e) + { + } + } + } + } + + private void parseResource(int index, String name) + { + Reader in = null; + try + { + InputStream is = getClass().getResourceAsStream(name); + if (is != null) + { + if (debug) + { + System.out.println("\t" + name); + } + in = new InputStreamReader(is); + parse(index, in); + } + } + catch (IOException e) + { + if (debug) + { + System.out.println(e.getClass().getName() + ": " + + e.getMessage()); + } + } + finally + { + if (in != null) + { + try + { + in.close(); + } + catch (IOException e) + { + } + } + } + } + + private void parse(int index, Reader in) + throws IOException + { + BufferedReader br = new BufferedReader(in); + CPStringBuilder buf = null; + for (String line = br.readLine(); line != null; line = br.readLine()) + { + line = line.trim(); + int len = line.length(); + if (len == 0 || line.charAt(0) == '#') + { + continue; // Comment + } + if (line.charAt(len - 1) == '\\') + { + if (buf == null) + { + buf = new CPStringBuilder(); + } + buf.append(line.substring(0, len - 1)); + } + else if (buf != null) + { + buf.append(line); + parseEntry(index, buf.toString()); + buf = null; + } + else + { + parseEntry(index, line); + } + } + } + + private void parseEntry(int index, String line) + { + // Tokenize entry into fields + char[] chars = line.toCharArray(); + int len = chars.length; + boolean inQuotedString = false; + boolean fallback = false; + CPStringBuilder buffer = new CPStringBuilder(); + List fields = new ArrayList(); + for (int i = 0; i < len; i++) + { + char c = chars[i]; + if (c == '\\') + { + c = chars[++i]; // qchar + } + if (c == ';' && !inQuotedString) + { + String field = buffer.toString().trim(); + if ("x-java-fallback-entry".equals(field)) + { + fallback = true; + } + fields.add(field); + buffer.setLength(0); + } + else + { + if (c == '"') + { + inQuotedString = !inQuotedString; + } + buffer.append(c); + } + } + String field = buffer.toString().trim(); + if ("x-java-fallback-entry".equals(field)) + { + fallback = true; + } + fields.add(field); + + len = fields.size(); + if (len < 2) + { + if (debug) + { + System.err.println("Invalid mailcap entry: " + line); + } + return; + } + + Map>> mailcap = + fallback ? mailcaps[index][FALLBACK] : mailcaps[index][NORMAL]; + String mimeType = fields.get(0); + addField(mailcap, mimeType, "view-command", (String) fields.get(1)); + for (int i = 2; i < len; i++) + { + addField(mailcap, mimeType, null, (String) fields.get(i)); + } + } + + private void addField(Map>> mailcap, + String mimeType, String verb, String command) + { + if (verb == null) + { + int ei = command.indexOf('='); + if (ei != -1) + { + verb = command.substring(0, ei); + command = command.substring(ei + 1); + } + } + if (command.length() == 0 || verb == null || verb.length() == 0) + { + return; // Invalid field or flag + } + + Map> commands = mailcap.get(mimeType); + if (commands == null) + { + commands = new LinkedHashMap>(); + mailcap.put(mimeType, commands); + } + List classNames = commands.get(verb); + if (classNames == null) + { + classNames = new ArrayList(); + commands.put(verb, classNames); + } + classNames.add(command); + } + + private Map> + getCommands(Map>> mailcap, + String mimeType) + { + int si = mimeType.indexOf('/'); + String genericMimeType = new CPStringBuilder(mimeType.substring(0, si)) + .append('/') + .append('*') + .toString(); + Map> specific = mailcap.get(mimeType); + Map> generic = mailcap.get(genericMimeType); + if (generic == null) + { + return specific; + } + if (specific == null) + { + return generic; + } + Map> combined = new LinkedHashMap>(); + combined.putAll(specific); + for (String verb : generic.keySet()) + { + List genericClassNames = generic.get(verb); + List classNames = combined.get(verb); + if (classNames == null) + { + combined.put(verb, genericClassNames); + } + else + { + classNames.addAll(genericClassNames); + } + } + return combined; + } + + // -- Utility methods -- + + private List getSystemResources(String name) + { + List acc = new ArrayList(); + try + { + for (Enumeration i = ClassLoader.getSystemResources(name); + i.hasMoreElements(); ) + { + acc.add(i.nextElement()); + } + } + catch (IOException e) + { + } + return acc; + } + +} + diff --git a/libjava/classpath/javax/activation/MimeType.java b/libjava/classpath/javax/activation/MimeType.java new file mode 100644 index 0000000..70045d6 --- /dev/null +++ b/libjava/classpath/javax/activation/MimeType.java @@ -0,0 +1,293 @@ +/* MimeType.java -- A MIME type as defined in RFC2046 and RFC2047. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +import gnu.java.lang.CPStringBuilder; + +import java.io.Externalizable; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; + +/** + * A MIME content type, as defined in RFCs 2045 and 2046. + * + * @author Chris Burdess + * @version 1.1 + */ +public class MimeType + implements Externalizable +{ + + static final String TSPECIALS = "()<>@,;:/[]?=\\\""; + + private String primaryType; + private String subType; + private MimeTypeParameterList parameters; + + /** + * Constructor for an application/* content type. + */ + public MimeType() + { + primaryType = "application"; + subType = "*"; + parameters = new MimeTypeParameterList(); + } + + /** + * Constructor that parses a raw String. + * @param rawdata the MIME type string + */ + public MimeType(String rawdata) + throws MimeTypeParseException + { + parse(rawdata); + } + + /** + * Constructor for a new MIME type with the given primary and sub types + * and an empty parameter list. + * @param primary the primary type + * @param sub the subtype + */ + public MimeType(String primary, String sub) + throws MimeTypeParseException + { + checkValidity(primary, "Primary type is invalid"); + checkValidity(sub, "Sub type is invalid"); + primaryType = primary.toLowerCase(); + subType = sub.toLowerCase(); + parameters = new MimeTypeParameterList(); + } + + /** + * Returns the primary type. + */ + public String getPrimaryType() + { + return primaryType; + } + + /** + * Sets the primary type. + * @param primary the new primary type + */ + public void setPrimaryType(String primary) + throws MimeTypeParseException + { + checkValidity(primary, "Primary type is invalid"); + primaryType = primary.toLowerCase(); + } + + /** + * Returns the subtype. + */ + public String getSubType() + { + return subType; + } + + /** + * Sets the subtype. + * @param sub the new subtype + */ + public void setSubType(String sub) + throws MimeTypeParseException + { + checkValidity(sub, "Sub type is invalid"); + subType = sub.toLowerCase(); + } + + /** + * Returns the MIME parameters. + */ + public MimeTypeParameterList getParameters() + { + return parameters; + } + + /** + * Returns the parameter value for the specified name. + * @param name the parameter name + */ + public String getParameter(String name) + { + return parameters.get(name); + } + + /** + * Sets the parameter value for the specified name. + * @param name the parameter name + * @param value the new value + */ + public void setParameter(String name, String value) + { + parameters.set(name, value); + } + + /** + * Removes the parameter value for the specified name. + * @param name the parameter name + */ + public void removeParameter(String name) + { + parameters.remove(name); + } + + /** + * Returns the complete string representation of this MIME type. + */ + public String toString() + { + return new CPStringBuilder(primaryType) + .append('/') + .append(subType) + .append(parameters.toString()) + .toString(); + } + + /** + * Returns the string representation of this MIME type without + * parameters. + */ + public String getBaseType() + { + return new CPStringBuilder(primaryType) + .append('/') + .append(subType) + .toString(); + } + + /** + * Returns true if the primary and subtype of this MIME type are the + * same as in the given MIME type. + */ + public boolean match(MimeType type) + { + String primary2 = type.getPrimaryType(); + String sub2 = type.getSubType(); + return primaryType.equals(primary2) && (subType.equals(sub2) || + "*".equals(subType) || + "*".equals(sub2)); + } + + /** + * Returns true if the primary and subtype of this MIME type are the + * same as in the given MIME type string. + */ + public boolean match(String rawdata) + throws MimeTypeParseException + { + return match(new MimeType(rawdata)); + } + + public void writeExternal(ObjectOutput out) + throws IOException + { + out.writeUTF(toString()); + out.flush(); + } + + public void readExternal(ObjectInput in) + throws IOException, ClassNotFoundException + { + try + { + parse(in.readUTF()); + } + catch (MimeTypeParseException e) + { + throw new IOException(e.getMessage()); + } + } + + private void parse(String rawdata) + throws MimeTypeParseException + { + int si = rawdata.indexOf('/'); + int pi = rawdata.indexOf(';'); + if (si == -1) + { + throw new MimeTypeParseException("Unable to find a sub type."); + } + if (pi == -1) + { + primaryType = rawdata.substring(0, si).toLowerCase().trim(); + subType = rawdata.substring(si + 1).toLowerCase().trim(); + parameters = new MimeTypeParameterList(); + } + else if (si < pi) + { + primaryType = rawdata.substring(0, si).toLowerCase().trim(); + subType = rawdata.substring(si + 1, pi).toLowerCase().trim(); + parameters = new MimeTypeParameterList(rawdata.substring(pi)); + } + else + { + throw new MimeTypeParseException("Unable to find a sub type."); + } + checkValidity(primaryType, "Primary type is invalid"); + checkValidity(subType, "Sub type is invalid"); + } + + static void checkValidity(String token, String message) + throws MimeTypeParseException + { + int len = token.length(); + if (len == 0) + { + throw new MimeTypeParseException(message, token); + } + for (int i = 0; i < len; i++) + { + char c = token.charAt(i); + if (!isValidChar(c)) + { + throw new MimeTypeParseException(message, token); + } + } + } + + static boolean isValidChar(char c) + { + return c > ' ' && c <= '~' && TSPECIALS.indexOf(c) == -1; + } + +} + diff --git a/libjava/classpath/javax/activation/MimeTypeParameterList.java b/libjava/classpath/javax/activation/MimeTypeParameterList.java new file mode 100644 index 0000000..e15469d --- /dev/null +++ b/libjava/classpath/javax/activation/MimeTypeParameterList.java @@ -0,0 +1,336 @@ +/* MimeTypeParameterList.java -- Handle a list of MIME type parameters. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +import gnu.java.lang.CPStringBuilder; + +import java.util.ArrayList; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +/** + * A list of MIME type parameters, as specified in RFCs 2045 and 2046. + * + * @author Chris Burdess + * @version 1.1 + */ +public class MimeTypeParameterList +{ + + private final List parameterNames; + private final Map parameterValues; + + /** + * Constructor for an empty parameter list. + */ + public MimeTypeParameterList() + { + parameterNames = new ArrayList(); + parameterValues = new HashMap(); + } + + /** + * Constructor that parses the specified MIME parameter data. + * @param parameterList a MIME parameter list string representation + */ + public MimeTypeParameterList(String parameterList) + throws MimeTypeParseException + { + this(); + parse(parameterList); + } + + /** + * Parses the specified MIME parameter data, storing the results in this + * object. + * @param parameterList a MIME parameter list string representation + */ + protected void parse(String parameterList) + throws MimeTypeParseException + { + if (parameterList == null) + { + return; + } + // Tokenize list into parameters + char[] chars = parameterList.toCharArray(); + int len = chars.length; + boolean inQuotedString = false; + CPStringBuilder buffer = new CPStringBuilder(); + List params = new ArrayList(); + for (int i = 0; i < len; i++) + { + char c = chars[i]; + if (c == ';' && !inQuotedString) + { + String param = buffer.toString().trim(); + if (param.length() > 0) + { + params.add(param); + } + buffer.setLength(0); + } + else + { + if (c == '"') + { + inQuotedString = !inQuotedString; + } + buffer.append(c); + } + } + String param = buffer.toString().trim(); + if (param.length() > 0) + { + params.add(param); + } + + // Tokenize each parameter into name + value + for (Iterator i = params.iterator(); i.hasNext();) + { + param = i.next(); + int ei = param.indexOf('='); + if (ei == -1) + { + throw new MimeTypeParseException("Couldn't find the '=' that " + + "separates a parameter name " + + "from its value."); + } + String name = param.substring(0, ei).trim(); + MimeType.checkValidity(name, "Parameter name is invalid"); + String value = param.substring(ei + 1).trim(); + len = value.length(); + if (len > 1 && value.charAt(0) == '"' && + value.charAt(len - 1) == '"') + { + value = unquote(value); + } + else + { + MimeType.checkValidity(name, "Parameter value is invalid"); + } + + parameterNames.add(name); + parameterValues.put(name.toLowerCase(), value); + } + } + + /** + * Returns the number of parameters. + */ + public synchronized int size() + { + return parameterNames.size(); + } + + /** + * Indicates if there are no parameters. + */ + public synchronized boolean isEmpty() + { + return parameterNames.isEmpty(); + } + + /** + * Returns the value for the specified parameter name. + * @param name the parameter name + */ + public synchronized String get(String name) + { + name = name.trim(); + return parameterValues.get(name.toLowerCase()); + } + + /** + * Sets the value for the specified parameter name. + * @param name the parameter name + * @param value the parameter value + */ + public synchronized void set(String name, String value) + { + name = name.trim(); + boolean exists = false; + for (String pname : parameterNames) + { + if (name.equalsIgnoreCase(pname)) + { + exists = true; + } + } + if (!exists) + { + parameterNames.add(name); + } + parameterValues.put(name.toLowerCase(), value); + } + + /** + * Removes the parameter identified by the specified name. + * @param name the parameter name + */ + public synchronized void remove(String name) + { + name = name.trim(); + for (Iterator i = parameterNames.iterator();i.hasNext();) + { + String pname = i.next(); + if (name.equalsIgnoreCase(pname)) + { + i.remove(); + } + } + parameterValues.remove(name.toLowerCase()); + } + + /** + * Returns an enumeration of all the parameter names. + */ + // Raw type is forced by public spec. + @SuppressWarnings("unchecked") + public synchronized Enumeration getNames() + { + return new IteratorEnumeration(parameterNames.iterator()); + } + + /** + * Returns an RFC 2045-compliant string representation of this parameter + * list. + */ + public synchronized String toString() + { + CPStringBuilder buffer = new CPStringBuilder(); + for (String name : parameterNames) + { + String value = parameterValues.get(name.toLowerCase()); + + buffer.append(';'); + buffer.append(' '); + buffer.append(name); + buffer.append('='); + buffer.append(quote(value)); + } + return buffer.toString(); + } + + private static String quote(String value) + { + boolean needsQuoting = false; + int len = value.length(); + for (int i = 0; i < len; i++) + { + if (!MimeType.isValidChar(value.charAt(i))) + { + needsQuoting = true; + break; + } + } + + if (needsQuoting) + { + CPStringBuilder buffer = new CPStringBuilder(); + buffer.append('"'); + for (int i = 0; i < len; i++) + { + char c = value.charAt(i); + if (c == '\\' || c == '"') + { + buffer.append('\\'); + } + buffer.append(c); + } + buffer.append('"'); + return buffer.toString(); + } + return value; + } + + private static String unquote(String value) + { + int len = value.length(); + CPStringBuilder buffer = new CPStringBuilder(); + for (int i = 1; i < len - 1; i++) + { + char c = value.charAt(i); + if (c == '\\') + { + i++; + if (i < len - 1) + { + c = value.charAt(i); + if (c != '\\' && c != '"') + { + buffer.append('\\'); + } + } + } + buffer.append(c); + } + return buffer.toString(); + } + + /** + * Enumeration proxy for an Iterator. + */ + static class IteratorEnumeration + implements Enumeration + { + + final Iterator iterator; + + IteratorEnumeration(Iterator iterator) + { + this.iterator = iterator; + } + + public boolean hasMoreElements() + { + return iterator.hasNext(); + } + + public String nextElement() + { + return iterator.next(); + } + + } + +} + diff --git a/libjava/classpath/javax/activation/MimeTypeParseException.java b/libjava/classpath/javax/activation/MimeTypeParseException.java new file mode 100644 index 0000000..b46e244 --- /dev/null +++ b/libjava/classpath/javax/activation/MimeTypeParseException.java @@ -0,0 +1,84 @@ +/* MimeTypeParseException.java -- Exception due to invalid MIME type. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +import gnu.java.lang.CPStringBuilder; + +/** + * Exception thrown to indicate a malformed MIME content type. + * + * @author Chris Burdess + * @version 1.1 + */ +public class MimeTypeParseException + extends Exception +{ + + /** + * Constructs a MimeTypeParseException with no detail message. + */ + public MimeTypeParseException() + { + } + + /** + * MimeTypeParseException with the specified detail message. + * @param message the exception message + */ + public MimeTypeParseException(String message) + { + super(message); + } + + /** + * Constructs a MimeTypeParseException with the specified detail message + * and token in error. + * @param message the exception message + * @param token the token in error + */ + MimeTypeParseException(String message, String token) + { + this(new CPStringBuilder(message) + .append(':') + .append(' ') + .append(token) + .toString()); + } + +} + diff --git a/libjava/classpath/javax/activation/MimetypesFileTypeMap.java b/libjava/classpath/javax/activation/MimetypesFileTypeMap.java new file mode 100644 index 0000000..d1566fd --- /dev/null +++ b/libjava/classpath/javax/activation/MimetypesFileTypeMap.java @@ -0,0 +1,440 @@ +/* MimeTypesFileTypeMap.java -- A file type map using mime.types. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +import gnu.java.lang.CPStringBuilder; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.IOException; +import java.io.Reader; +import java.io.StringReader; +import java.net.URL; +import java.util.ArrayList; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +/** + * Implementation of FileTypeMap that uses the mime.types format. + * File entries are searched for in the following locations and order: + *
    + *
  1. Programmatically added entries to this instance
    2. + *
  2. The file .mime.types in the user's home directory
    3. + *
  3. The file <java.home>/lib/mime.types
    4. + *
  4. The resource META-INF/mime.types
    5. + *
  5. The resource META-INF/mimetypes.default in the JAF + * distribution
    6. + *
+ * + * @author Chris Burdess + * @version 1.1 + */ +public class MimetypesFileTypeMap + extends FileTypeMap +{ + + private static final int PROG = 0; + private static final int HOME = 1; + private static final int SYS = 2; + private static final int JAR = 3; + private static final int DEF = 4; + private static final String DEFAULT_MIME_TYPE = "application/octet-stream"; + private static boolean debug = false; + static + { + try + { + String d = System.getProperty("javax.activation.debug"); + debug = Boolean.valueOf(d).booleanValue(); + } + catch (SecurityException e) + { + } + } + + private Map[] mimetypes; + + /** + * Default constructor. + */ + public MimetypesFileTypeMap() + { + init(null); + } + + /** + * Constructor specifying a filename. + * @param mimeTypeFileName the name of the file to read mime.types + * entries from + */ + public MimetypesFileTypeMap(String mimeTypeFileName) + throws IOException + { + Reader in = null; + try + { + in = new FileReader(mimeTypeFileName); + init(in); + } + finally + { + if (in != null) + { + in.close(); + } + } + } + + /** + * Constructor specifying an input stream. + * @param is the input stream to read mime.types entries from + */ + public MimetypesFileTypeMap(InputStream is) + { + init(new InputStreamReader(is)); + } + + private void init(Reader in) + { + mimetypes = new Map[5]; + for (int i = 0; i < mimetypes.length; i++) + { + mimetypes[i] = new HashMap(); + } + if (in != null) + { + if (debug) + { + System.out.println("MimetypesFileTypeMap: load PROG"); + } + try + { + parse(mimetypes[PROG], in); + } + catch (IOException e) + { + } + } + + if (debug) + { + System.out.println("MimetypesFileTypeMap: load HOME"); + } + try + { + String home = System.getProperty("user.home"); + if (home != null) + { + parseFile(mimetypes[HOME], new CPStringBuilder(home) + .append(File.separatorChar) + .append(".mime.types") + .toString()); + } + } + catch (SecurityException e) + { + } + + if (debug) + { + System.out.println("MimetypesFileTypeMap: load SYS"); + } + try + { + parseFile(mimetypes[SYS], + new CPStringBuilder(System.getProperty("java.home")) + .append(File.separatorChar) + .append("lib") + .append(File.separatorChar) + .append("mime.types") + .toString()); + } + catch (SecurityException e) + { + } + if (debug) + { + System.out.println("MimetypesFileTypeMap: load JAR"); + } + List systemResources = getSystemResources("META-INF/mime.types"); + int len = systemResources.size(); + if (len > 0) + { + for (int i = 0; i < len ; i++) + { + Reader urlIn = null; + URL url = (URL)systemResources.get(i); + try + { + urlIn = new InputStreamReader(url.openStream()); + parse(mimetypes[JAR], urlIn); + } + catch (IOException e) + { + } + finally + { + if (urlIn != null) + { + try + { + urlIn.close(); + } + catch (IOException e) + { + } + } + } + } + } + else + { + parseResource(mimetypes[JAR], "/META-INF/mime.types"); + } + + if (debug) + { + System.out.println("MimetypesFileTypeMap: load DEF"); + } + parseResource(mimetypes[DEF], "/META-INF/mimetypes.default"); + } + + /** + * Adds entries prorammatically to the registry. + * @param mime_types a mime.types formatted entries string + */ + public synchronized void addMimeTypes(String mime_types) + { + if (debug) + { + System.out.println("MimetypesFileTypeMap: add to PROG"); + } + try + { + parse(mimetypes[PROG], new StringReader(mime_types)); + } + catch (IOException e) + { + } + } + + /** + * Returns the MIME content type of the file. + * This calls getContentType(f.getName()). + * @param f the file + */ + public String getContentType(File f) + { + return getContentType(f.getName()); + } + + /** + * Returns the MIME type based on the given filename. + * If no entry is found, returns "application/octet-stream". + * @param filename the filename + */ + public synchronized String getContentType(String filename) + { + int di = filename.lastIndexOf('.'); + if (di < 0) + { + return DEFAULT_MIME_TYPE; + } + String tail = filename.substring(di + 1); + if (tail.length() < 1) + { + return DEFAULT_MIME_TYPE; + } + for (int i = 0; i < mimetypes.length; i++) + { + String mimeType = (String)mimetypes[i].get(tail); + if (mimeType != null) + { + return mimeType; + } + } + return DEFAULT_MIME_TYPE; + } + + private void parseFile(Map mimetypes, String filename) + { + Reader in = null; + try + { + in = new FileReader(filename); + parse(mimetypes, in); + } + catch (IOException e) + { + } + finally + { + if (in != null) + { + try + { + in.close(); + } + catch (IOException e) + { + } + } + } + } + + private void parseResource(Map mimetypes, String name) + { + Reader in = null; + try + { + InputStream is = getClass().getResourceAsStream(name); + if (is != null) + { + in = new InputStreamReader(is); + parse(mimetypes, in); + } + } + catch (IOException e) + { + } + finally + { + if (in != null) + { + try + { + in.close(); + } + catch (IOException e) + { + } + } + } + } + + private void parse(Map mimetypes, Reader in) + throws IOException + { + BufferedReader br = new BufferedReader(in); + CPStringBuilder buf = null; + for (String line = br.readLine(); line != null; line = br.readLine()) + { + line = line.trim(); + int len = line.length(); + if (len == 0 || line.charAt(0) == '#') + { + continue; // Empty line / comment + } + if (line.charAt(len - 1) == '\\') + { + if (buf == null) + { + buf = new CPStringBuilder(); + } + buf.append(line.substring(0, len - 1)); + } + else if (buf != null) + { + buf.append(line); + parseEntry(mimetypes, buf.toString()); + buf = null; + } + else + { + parseEntry(mimetypes, line); + } + } + } + + private void parseEntry(Map mimetypes, + String line) + { + // Tokenize + String mimeType = null; + char[] chars = line.toCharArray(); + int len = chars.length; + CPStringBuilder buffer = new CPStringBuilder(); + for (int i = 0; i < len; i++) + { + char c = chars[i]; + if (Character.isWhitespace(c)) + { + if (mimeType == null) + { + mimeType = buffer.toString(); + } + else if (buffer.length() > 0) + { + mimetypes.put(buffer.toString(), mimeType); + } + buffer.setLength(0); + } + else + buffer.append(c); + } + if (buffer.length() > 0) + { + mimetypes.put(buffer.toString(), mimeType); + } + } + + // -- Utility methods -- + + private List getSystemResources(String name) + { + List acc = new ArrayList(); + try + { + for (Enumeration i = ClassLoader.getSystemResources(name); + i.hasMoreElements(); ) + acc.add(i.nextElement()); + } + catch (IOException e) + { + } + return acc; + } + +} + diff --git a/libjava/classpath/javax/activation/ObjectDataContentHandler.java b/libjava/classpath/javax/activation/ObjectDataContentHandler.java new file mode 100644 index 0000000..5105cb4 --- /dev/null +++ b/libjava/classpath/javax/activation/ObjectDataContentHandler.java @@ -0,0 +1,128 @@ +/* ObjectDataContentHandler.java -- Data content handler using an object. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +import java.awt.datatransfer.DataFlavor; +import java.awt.datatransfer.UnsupportedFlavorException; +import java.io.IOException; +import java.io.OutputStream; + +/** + * Data content handler that uses an existing DCH and reified object. + * + * @author Chris Burdess + * @version 1.1 + */ +class ObjectDataContentHandler + implements DataContentHandler +{ + + private DataContentHandler dch; + private Object object; + private String mimeType; + private DataFlavor[] flavors; + + public ObjectDataContentHandler(DataContentHandler dch, Object object, + String mimeType) + { + this.dch = dch; + this.object = object; + this.mimeType = mimeType; + } + + public Object getContent(DataSource ds) + { + return object; + } + + public DataContentHandler getDCH() + { + return dch; + } + + public Object getTransferData(DataFlavor flavor, DataSource ds) + throws UnsupportedFlavorException, IOException + { + if (dch != null) + { + return dch.getTransferData(flavor, ds); + } + if (flavors == null) + { + getTransferDataFlavors(); + } + if (flavor.equals(flavors[0])) + { + return object; + } + throw new UnsupportedFlavorException(flavor); + } + + public DataFlavor[] getTransferDataFlavors() + { + if (flavors == null) + { + if (dch != null) + { + flavors = dch.getTransferDataFlavors(); + } + else + { + flavors = new DataFlavor[1]; + flavors[0] = new ActivationDataFlavor(object.getClass(), + mimeType, mimeType); + } + } + return flavors; + } + + public void writeTo(Object object, String mimeType, OutputStream out) + throws IOException + { + if (dch != null) + { + dch.writeTo(object, mimeType, out); + } + else + { + throw new UnsupportedDataTypeException("no object DCH for MIME type " + mimeType); + } + } + +} + diff --git a/libjava/classpath/javax/activation/URLDataSource.java b/libjava/classpath/javax/activation/URLDataSource.java new file mode 100644 index 0000000..8b77567 --- /dev/null +++ b/libjava/classpath/javax/activation/URLDataSource.java @@ -0,0 +1,138 @@ +/* URLDataSource.java -- Data source for a URL object. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +import java.io.InputStream; +import java.io.IOException; +import java.io.OutputStream; +import java.net.URL; +import java.net.URLConnection; + +/** + * DataSource implementation that retrieves its data from a URL. + * + * @author Chris Burdess + * @version 1.1 + */ +public class URLDataSource + implements DataSource +{ + + private final URL url; + private URLConnection connection; + + /** + * Constructor. + * This will not open the connection to the URL. + */ + public URLDataSource(URL url) + { + this.url = url; + } + + /** + * Returns the Content-Type header for the URL. + * In the case of failure or lack of such a header, + * returns "application/octet-stream". + */ + public String getContentType() + { + try + { + if (connection == null) + { + connection = url.openConnection(); + } + } + catch (IOException e) + { + } + String contentType = null; + if (connection != null) + { + contentType = connection.getContentType(); + } + if (contentType == null) + { + contentType = "application/octet-stream"; + } + return contentType; + } + + /** + * Returns the result of getFile of the underlying URL. + */ + public String getName() + { + return url.getFile(); + } + + public InputStream getInputStream() + throws IOException + { + connection = url.openConnection(); + if (connection != null) + { + connection.setDoInput(true); + return connection.getInputStream(); + } + return null; + } + + public OutputStream getOutputStream() + throws IOException + { + connection = url.openConnection(); + if (connection != null) + { + connection.setDoOutput(true); + return connection.getOutputStream(); + } + return null; + } + + /** + * Returns the underlying URL. + */ + public URL getURL() + { + return url; + } + +} + diff --git a/libjava/classpath/javax/activation/UnsupportedDataTypeException.java b/libjava/classpath/javax/activation/UnsupportedDataTypeException.java new file mode 100644 index 0000000..09460b0 --- /dev/null +++ b/libjava/classpath/javax/activation/UnsupportedDataTypeException.java @@ -0,0 +1,70 @@ +/* UnsupportedDataTypeException.java -- Thrown when a data type is not supported. + Copyright (C) 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.activation; + +import java.io.IOException; + +/** + * Exception indicating that the requested method doesn't support the + * specified data type. + * + * @author Chris Burdess + * @version 1.1 + */ +public class UnsupportedDataTypeException extends IOException +{ + + /** + * Constructs an UnsupportedDataTypeException with no detail message. + */ + public UnsupportedDataTypeException() + { + } + + /** + * Constructs an UnsupportedDataTypeException with the specified detail + * message. + * @param message the message + */ + public UnsupportedDataTypeException(String message) + { + super(message); + } + +} + diff --git a/libjava/classpath/javax/activation/package.html b/libjava/classpath/javax/activation/package.html new file mode 100644 index 0000000..74027ec --- /dev/null +++ b/libjava/classpath/javax/activation/package.html @@ -0,0 +1,44 @@ + + +

+The GNU JavaBeans™ Activation Framework (JAF) provides a +Free implementation of the +JavaBeans™ Activation Framework, version 1.1. +

+ +

+JAF links together beans and internet standards for specifying MIME +types and how MIME types are processed. It provides a means to associate +data of a given MIME type with bean actions operating on that data. +

+ + +

Important files

+ +

+Standard mime.types files are parsed by the JAF MIME +handling classes to work out the MIME types available on the local +system. +

+ +

+Standard mailcap files (defined in RFC1524) are parsed by +mail capability handling classes to work out what beans should be linked +to what MIME types. +

+ +

+Neither the authors nor the Free Software Foundation offer +ANY SUPPORT for this software or imply any warranty.
+Use it at your own risk. + +

+ +

+If you can suggest improvements in either the implementation +code or in the documentation please contact the +GNU Classpath project developers. + +

+ + -- cgit v1.1