pax_global_header00006660000000000000000000000064143513126060014513gustar00rootroot0000000000000052 comment=6c7dd2d757f6a705048c8b4e074c6f741dee110d jaf-api-2.1.1/000077500000000000000000000000001435131260600130235ustar00rootroot00000000000000jaf-api-2.1.1/.github/000077500000000000000000000000001435131260600143635ustar00rootroot00000000000000jaf-api-2.1.1/.github/ISSUE_TEMPLATE/000077500000000000000000000000001435131260600165465ustar00rootroot00000000000000jaf-api-2.1.1/.github/ISSUE_TEMPLATE/bug_report.md000066400000000000000000000015021435131260600212360ustar00rootroot00000000000000--- name: Bug report about: Create a report to help us improve title: '' labels: '' assignees: '' --- **Describe the bug** A clear and concise description of what the bug is. **To Reproduce** Steps to reproduce the behavior: 1. Go to '...' 2. Click on '....' 3. Scroll down to '....' 4. See error **Expected behavior** A clear and concise description of what you expected to happen. **Screenshots** If applicable, add screenshots to help explain your problem. **Desktop (please complete the following information):** - OS: [e.g. iOS] - Browser [e.g. chrome, safari] - Version [e.g. 22] **Smartphone (please complete the following information):** - Device: [e.g. iPhone6] - OS: [e.g. iOS8.1] - Browser [e.g. stock browser, safari] - Version [e.g. 22] **Additional context** Add any other context about the problem here. jaf-api-2.1.1/.github/ISSUE_TEMPLATE/compatibility-certification-request.md000066400000000000000000000021211435131260600262440ustar00rootroot00000000000000--- name: Compatibility certification request about: Request certification of a compatible implementation of Jakarta Mail. title: Compatibility certification request for [product/project name] labels: certification assignees: '' --- - [ ] Organization Name ("Organization") and, if applicable, URL\ // Add here - [ ] Product Name, Version and download URL (if applicable)\ // Add here - [ ] Specification Name, Version and download URL\ // Add here - [ ] TCK Version, digital SHA-256 fingerprint and download URL\ // Add here - [ ] Public URL of TCK Results Summary\ // Add here - [ ] Any Additional Specification Certification Requirements\ // Add here - [ ] Java runtime used to run the implementation\ // Add here - [ ] Summary of the information for the certification environment, operating system, cloud, ...\ // Add here - [ ] By checking this box I acknowledge that the Organization I represent accepts the terms of the [EFTL](https://www.eclipse.org/legal/tck.php). - [ ] By checking this box I attest that all TCK requirements have been met, including any compatibility rules. jaf-api-2.1.1/.github/ISSUE_TEMPLATE/feature_request.md000066400000000000000000000011231435131260600222700ustar00rootroot00000000000000--- name: Feature request about: Suggest an idea for this project title: '' labels: '' assignees: '' --- **Is your feature request related to a problem? Please describe.** A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] **Describe the solution you'd like** A clear and concise description of what you want to happen. **Describe alternatives you've considered** A clear and concise description of any alternative solutions or features you've considered. **Additional context** Add any other context or screenshots about the feature request here. jaf-api-2.1.1/.github/workflows/000077500000000000000000000000001435131260600164205ustar00rootroot00000000000000jaf-api-2.1.1/.github/workflows/maven.yml000066400000000000000000000025141435131260600202530ustar00rootroot00000000000000# # Copyright (c) 2021, 2022 Contributors to the Eclipse Foundation # # This program and the accompanying materials are made available under the # terms of the Eclipse Public License v. 2.0 which is available at # http://www.eclipse.org/legal/epl-2.0, # or the Eclipse Distribution License v. 1.0 which is available at # http://www.eclipse.org/org/documents/edl-v10.php. # # SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause # name: Activation API on: pull_request: paths-ignore: - 'doc/**' - 'www/**' push: paths-ignore: - 'doc/**' - 'www/**' jobs: build: name: Test on JDK ${{ matrix.java_version }} runs-on: ubuntu-latest strategy: matrix: java_version: [ 11, 17-ea ] steps: - name: Checkout for build uses: actions/checkout@v2.3.4 - name: Set up JDK uses: actions/setup-java@v2 with: distribution: 'zulu' java-version: ${{ matrix.java_version }} - name: Cache Maven repository uses: actions/cache@v2 with: path: ~/.m2 key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }} restore-keys: ${{ runner.os }}-m2 - name: Verify run: cd api && mvn -B -V -U -C -Poss-release clean verify org.glassfish.copyright:glassfish-copyright-maven-plugin:check -Dgpg.skip=true -Dcopyright.ignoreyear=true jaf-api-2.1.1/.github/workflows/web.yml000066400000000000000000000043451435131260600177260ustar00rootroot00000000000000# # Copyright (c) 2022 Contributors to the Eclipse Foundation # # This program and the accompanying materials are made available under the # terms of the Eclipse Public License v. 2.0 which is available at # http://www.eclipse.org/legal/epl-2.0, # or the Eclipse Distribution License v. 1.0 which is available at # http://www.eclipse.org/org/documents/edl-v10.php. # # SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause # name: Update web site on: # Runs on pushes targeting the default branch push: branches: ["master"] paths: - 'doc/**' - 'www/**' # Allows you to run this workflow manually from the Actions tab workflow_dispatch: # Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages permissions: contents: read pages: write id-token: write # Allow one concurrent deployment concurrency: group: "pages" cancel-in-progress: true jobs: # Build job build: runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v3 - name: Add static content run: | export VERSION=`curl https://repo1.maven.org/maven2/jakarta/activation/jakarta.activation-api/maven-metadata.xml | tac | grep -o -m 1 "[[:digit:]]\.[[:digit:]]\.[[:digit:]]" | cut -f 1 -d "<"` echo Getting javadoc for version: $VERSION rm -rf ./www/api || true wget -q -O jakarta.activation-api-javadoc.zip https://repo1.maven.org/maven2/jakarta/activation/jakarta.activation-api/$VERSION/jakarta.activation-api-$VERSION-javadoc.jar unzip -q -d ./www/api jakarta.activation-api-javadoc.zip -x "META-INF/*" cp -Rfv CONTRIBUTING.md doc/spec/* ./www/ - name: Setup Pages uses: actions/configure-pages@v2 - name: Build with Jekyll uses: actions/jekyll-build-pages@v1 with: source: ./www/ destination: ./_site - name: Upload artifact uses: actions/upload-pages-artifact@v1 # Deployment job deploy: environment: name: github-pages url: ${{ steps.deployment.outputs.page_url }} runs-on: ubuntu-latest needs: build steps: - name: Deploy to GitHub Pages id: deployment uses: actions/deploy-pages@v1 jaf-api-2.1.1/.gitignore000066400000000000000000000001511435131260600150100ustar00rootroot00000000000000.idea/ target/ *~ *.iml _site www/.sass-cache www/.jekyll-cache www/.jekyll-metadata www/vendor www/api jaf-api-2.1.1/.hgtags000066400000000000000000000000631435131260600143000ustar00rootroot00000000000000dfaec4fe670da9f3554e3639e6907aeccb2bc1bc JAF-1_2_0 jaf-api-2.1.1/CONTRIBUTING.md000066400000000000000000000045471435131260600152660ustar00rootroot00000000000000# Contributing to Jakarta Activation Thanks for your interest in this project. ## Project description Jakarta Activation™ is a standard extension to the Java platform that lets you take advantage of standard services to: determine the type of an arbitrary piece of data; encapsulate access to it; discover the operations available on it; and instantiate the appropriate bean to perform the operation(s). * https://projects.eclipse.org/projects/ee4j.jaf ## Terms of Use This repository is subject to the Terms of Use of the Eclipse Foundation * http://www.eclipse.org/legal/termsofuse.php ## Developer resources Information regarding source code management, builds, coding standards, and more. * https://projects.eclipse.org/projects/ee4j.jaf/developer The project maintains the following source code repositories * https://github.com/jakartaee/jaf-api * https://github.com/jakartaee/jaf-tck ## Eclipse Development Process This Eclipse Foundation open project is governed by the Eclipse Foundation Development Process and operates under the terms of the Eclipse IP Policy. The Jakarta EE Specification Committee has adopted the Jakarta EE Specification Process (JESP) in accordance with the Eclipse Foundation Specification Process v1.2 (EFSP) to ensure that the specification process is complied with by all Jakarta EE specification projects. * https://eclipse.org/projects/dev_process * https://www.eclipse.org/org/documents/Eclipse_IP_Policy.pdf * https://jakarta.ee/about/jesp/ * https://www.eclipse.org/legal/efsp_non_assert.php ## Eclipse Contributor Agreement In order to be able to contribute to Eclipse Foundation projects you must electronically sign the Eclipse Contributor Agreement (ECA). * http://www.eclipse.org/legal/ECA.php The ECA provides the Eclipse Foundation with a permanent record that you agree that each of your contributions will comply with the commitments documented in the Developer Certificate of Origin (DCO). Having an ECA on file associated with the email address matching the "Author" field of your contribution's Git commits fulfills the DCO's requirement that you sign-off on your contributions. For more information, please see the Eclipse Committer Handbook: https://www.eclipse.org/projects/handbook/#resources-commit ## Contact Contact the project developers via the project's "dev" list. * https://accounts.eclipse.org/mailing-list/jaf-dev jaf-api-2.1.1/LICENSE.md000066400000000000000000000031461435131260600144330ustar00rootroot00000000000000 Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - Neither the name of the Eclipse Foundation, Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. jaf-api-2.1.1/NOTICE.md000066400000000000000000000052611435131260600143320ustar00rootroot00000000000000# Notices for Jakarta Activation This content is produced and maintained by the Jakarta Activation project. * Project home: https://projects.eclipse.org/projects/ee4j.jaf ## Trademarks Jakarta Activation is a trademark of the Eclipse Foundation. ## Copyright All content is the property of the respective authors or their employers. For more information regarding authorship of content, please consult the listed source code repository logs. ## Declared Project Licenses This program and the accompanying materials are made available under the terms of the Eclipse Public License v. 2.0 which is available at https://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License v1.0 which is available at https://www.eclipse.org/org/documents/edl-v10.php. This Source Code may also be made available under the following Secondary Licenses when the conditions for such availability set forth in the Eclipse Public License v. 2.0 are satisfied: (secondary) GPL-2.0 with Classpath-exception-2.0 which is available at https://openjdk.java.net/legal/gplv2+ce.html. SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause OR GPL-2.0-only with Classpath-exception-2.0 ## Source Code The project maintains the following source code repositories: * https://github.com/jakartaee/jaf-api * https://github.com/jakartaee/jaf-tck ## Third-party Content This project leverages the following third party content. Apache Ant (1.9.6) * License: Apache License, 2.0, W3C License, Public Domain Apache Ant (1.9.6) * License: Apache License, 2.0, W3C License, Public Domain Apache commons-lang (3.5) * License: Apache-2.0 font-awesome (4.7.0) * License: OFL-1.1 AND MIT jsoup (1.10.2) * License: MIT JTHarness (5.0) * License: (GPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0) * Project: https://wiki.openjdk.java.net/display/CodeTools/JT+Harness * Source: http://hg.openjdk.java.net/code-tools/jtharness/ JUnit (4.12) * License: Eclipse Public License normalize.css (3.0.2) * License: MIT * Project: http://necolas.github.io/normalize.css/ * Source: http://necolas.github.io/normalize.css/ SigTest (4.0) * License: GPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 * Project: https://wiki.openjdk.java.net/display/CodeTools/sigtest * Source: http://hg.openjdk.java.net/code-tools/sigtest/file/c57f97e2ac2f ## Cryptography Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import, possession, or use, and re-export of encryption software, to see if this is permitted.jaf-api-2.1.1/README.md000066400000000000000000000057501435131260600143110ustar00rootroot00000000000000# Jakarta Activation [![Build Status](https://github.com/jakartaee/jaf-api/actions/workflows/maven.yml/badge.svg?branch=master)](https://github.com/jakartaee/jaf-api/actions/workflows/maven.yml?branch=master) [![Jakarta Staging (Snapshots)](https://img.shields.io/nexus/s/https/jakarta.oss.sonatype.org/jakarta.activation/jakarta.activation-api.svg)](https://jakarta.oss.sonatype.org/content/repositories/staging/jakarta/activation/jakarta.activation-api/) Jakarta Activation lets you take advantage of standard services to: determine the type of arbitrary piece of data; encapsulate access to it; discover the operations available on it; and instantiate the appropriate bean to perform the operation(s). **IMPORTANT:** Implementation of the Jakarta Activation API, aka JakartaActivation (formerly JavaActivation), is no longer part of this repository. As part of breaking tight integration between Jakarta Activation API and the implementation, implementation sources were moved to the new project - [Eclipse Angus](https://eclipse-ee4j.github.io/angus-activation/) - and further development continues there. [Eclipse Angus](https://eclipse-ee4j.github.io/angus-activation/) is direct accessor of JavaActivation/JakartaActivation. See the [Jakarta Activation web site](https://jakartaee.github.io/jaf-api/). ## License * Most of the Jakarta Activation project source code is licensed under the [Eclipse Distribution License (EDL) v1.0.](https://www.eclipse.org/org/documents/edl-v10.php); see the license information at the top of each source file. * The source code for the Jakarta Activation Specification project is licensed under the [Eclipse Public License (EPL) v2.0](https://www.eclipse.org/legal/epl-2.0/) and [GNU General Public License (GPL) v2 with Classpath Exception](https://www.gnu.org/software/classpath/license.html); again, the license is in each source file. * The binary jar files published to the Maven repository are licensed under the same licenses as the corresponding source code; see the file `META-INF/LICENSE.*` in each jar file. You'll find the text of the licenses in the workspace in various `LICENSE.txt` or `LICENSE.md` files. Don't let the presence of these license files in the workspace confuse you into thinking that they apply to all files in the workspace. You should always read the license file included with every download, and read the license text included in every source file. ## Contributing We use [contribution policy](CONTRIBUTING.md), which means we can only accept contributions under the terms of [Eclipse Contributor Agreement](http://www.eclipse.org/legal/ECA.php). ## Links * [Jakarta Activation web site](https://jakartaee.github.io/jaf-api/) * [Jakarta Activation TCK project](https://github.com/jakartaee/jaf-api-tck) * [Jakarta Activation API nightly build job](https://ci.eclipse.org/jaf/job/activation-build-snapshot/) * [Mailing list](https://accounts.eclipse.org/mailing-list/jaf-dev) * [Eclipse Angus Activation project](https://eclipse-ee4j.github.io/angus-activation/) jaf-api-2.1.1/api/000077500000000000000000000000001435131260600135745ustar00rootroot00000000000000jaf-api-2.1.1/api/pom.xml000066400000000000000000000437211435131260600151200ustar00rootroot00000000000000 org.eclipse.ee4j project 1.0.7 4.0.0 jakarta.activation jakarta.activation-api 2.1.1 jar Jakarta Activation API ${project.name} ${spec.version} Specification https://github.com/jakartaee/jaf-api 2.1 Jakarta Activation Specification false UTF-8 Jakarta Activation API documentation ${project.basedir}/.. ${project.basedir}/../etc/copyright-exclude false true false false Low ${project.basedir}/../etc/spotbugs-exclude.xml 4.7.3.0 scm:git:ssh://git@github.com/jakartaee/jaf-api.git scm:git:ssh://git@github.com/jakartaee/jaf-api.git https://github.com/jakartaee/jaf-api HEAD github https://github.com/jakartaee/jaf-api/issues/ EDL 1.0 http://www.eclipse.org/org/documents/edl-v10.php repo shannon Bill Shannon bill.shannon@oracle.com Oracle lead oracle.com file:/tmp src/main/resources true META-INF/*.default src/main/resources false META-INF/*.default org.apache.maven.plugins maven-compiler-plugin 3.10.1 org.codehaus.mojo buildnumber-maven-plugin 3.0.0 org.apache.felix maven-bundle-plugin 5.1.8 <_noextraheaders>true org.apache.maven.plugins maven-jar-plugin 3.3.0 org.codehaus.mojo build-helper-maven-plugin 3.2.0 com.github.spotbugs spotbugs-maven-plugin ${spotbugs.version} ${spotbugs.skip} ${spotbugs.threshold} ${spotbugs.exclude} true org.apache.maven.plugins maven-enforcer-plugin 3.1.0 org.apache.maven.plugins maven-source-plugin 3.2.1 org.apache.maven.plugins maven-javadoc-plugin 3.4.1 org.glassfish.copyright glassfish-copyright-maven-plugin 2.4 org.apache.maven.plugins maven-site-plugin 3.9.1 org.apache.maven.plugins maven-enforcer-plugin enforce-version enforce [3.6.3,) [11,) org.apache.maven.plugins maven-compiler-plugin 9 -Xlint:all true true base-compile compile 8 module-info.java org.codehaus.mojo buildnumber-maven-plugin validate validate create true 7 false org.apache.felix maven-bundle-plugin false true <_noextraheaders>true ${project.artifactId} ${spec.title} ${spec.version} ${project.organization.name} ${project.groupId} ${project.name} ${project.organization.name} ${buildNumber} * org.glassfish.hk2.osgiresourcelocator !org.glassfish.hk2.osgiresourcelocator, * =1.0.0)(!(version>=2.0.0)))";resolution:=optional, osgi.serviceloader; filter:="(osgi.serviceloader=jakarta.activation.spi.MailcapRegistryProvider)"; osgi.serviceloader="jakarta.activation.spi.MailcapRegistryProvider"; cardinality:=multiple;resolution:=optional, osgi.serviceloader; filter:="(osgi.serviceloader=jakarta.activation.spi.MimeTypeRegistryProvider)"; osgi.serviceloader="jakarta.activation.spi.MimeTypeRegistryProvider"; cardinality:=multiple;resolution:=optional, osgi.ee;filter:="(&(osgi.ee=JavaSE)(version=1.8)) ]]> bundle-manifest process-classes manifest org.apache.maven.plugins maven-jar-plugin ${project.build.outputDirectory}/META-INF/MANIFEST.MF false org.codehaus.mojo build-helper-maven-plugin currentyear-property timestamp-property validate current.year en,US yyyy add-resource generate-resources add-resource ${legal.doc.source} META-INF LICENSE.md NOTICE.md org.apache.maven.plugins maven-source-plugin false org.apache.maven.plugins maven-javadoc-plugin false false ${javadoc.title} ${javadoc.title} ${javadoc.title} true true true true
Jakarta Activation API v${project.version}]]>
jaf-dev@eclipse.org.
Copyright © 2019, ${current.year} Eclipse Foundation. All rights reserved.
Use is subject to license terms.]]> true false 11 true org.glassfish.copyright glassfish-copyright-maven-plugin ${copyright.exclude} ${copyright.scmonly} ${copyright.update} ${copyright.ignoreyear} false jaf-api-2.1.1/api/src/000077500000000000000000000000001435131260600143635ustar00rootroot00000000000000jaf-api-2.1.1/api/src/main/000077500000000000000000000000001435131260600153075ustar00rootroot00000000000000jaf-api-2.1.1/api/src/main/java/000077500000000000000000000000001435131260600162305ustar00rootroot00000000000000jaf-api-2.1.1/api/src/main/java/jakarta/000077500000000000000000000000001435131260600176455ustar00rootroot00000000000000jaf-api-2.1.1/api/src/main/java/jakarta/activation/000077500000000000000000000000001435131260600220065ustar00rootroot00000000000000jaf-api-2.1.1/api/src/main/java/jakarta/activation/ActivationDataFlavor.java000066400000000000000000000223371435131260600267250ustar00rootroot00000000000000/* * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import java.io.IOException; import jakarta.activation.MimeType; /** * The ActivationDataFlavor class is similar to the JDK's * java.awt.datatransfer.DataFlavor class. It allows * Jakarta Activation to * set all three values stored by the DataFlavor class via a new * constructor. It also contains improved MIME parsing in the equals * method. Except for the improved parsing, its semantics are * identical to that of the JDK's DataFlavor class. */ public class ActivationDataFlavor { /* * Raison d'etre: * * The DataFlavor class included in JDK 1.1 has several limitations * including poor MIME type parsing, and the limitation of * only supporting serialized objects and InputStreams as * representation objects. This class 'fixes' that. */ private String mimeType = null; private MimeType mimeObject = null; private String humanPresentableName = null; private Class representationClass = null; /** * Construct an ActivationDataFlavor that represents an arbitrary * Java object. *

* The returned ActivationDataFlavor will have the following * characteristics: *

* representationClass = representationClass
* mimeType = mimeType
* humanName = humanName * * @param representationClass the class used in this ActivationDataFlavor * @param mimeType the MIME type of the data represented by this class * @param humanPresentableName the human presentable name of the flavor */ public ActivationDataFlavor(Class representationClass, String mimeType, String humanPresentableName) { // init private variables: this.mimeType = mimeType; this.humanPresentableName = humanPresentableName; this.representationClass = representationClass; } /** * Construct an ActivationDataFlavor that represents a MimeType. *

* The returned ActivationDataFlavor will have the following * characteristics: *

* If the mimeType is "application/x-java-serialized-object; * class=", the result is the same as calling new * ActivationDataFlavor(Class.forName()) as above. *

* otherwise: *

* representationClass = InputStream

* mimeType = mimeType * * @param representationClass the class used in this ActivationDataFlavor * @param humanPresentableName the human presentable name of the flavor */ public ActivationDataFlavor(Class representationClass, String humanPresentableName) { this.mimeType = "application/x-java-serialized-object"; this.representationClass = representationClass; this.humanPresentableName = humanPresentableName; } /** * Construct an ActivationDataFlavor that represents a MimeType. *

* The returned ActivationDataFlavor will have the following * characteristics: *

* If the mimeType is "application/x-java-serialized-object; class=", * the result is the same as calling new * ActivationDataFlavor(Class.forName()) as above, otherwise: *

* representationClass = InputStream
* mimeType = mimeType * * @param mimeType the MIME type of the data represented by this class * @param humanPresentableName the human presentable name of the flavor */ public ActivationDataFlavor(String mimeType, String humanPresentableName) { this.mimeType = mimeType; try { this.representationClass = Class.forName("java.io.InputStream"); } catch (ClassNotFoundException ex) { // XXX - should never happen, ignore it } this.humanPresentableName = humanPresentableName; } /** * Return the MIME type for this ActivationDataFlavor. * * @return the MIME type */ public String getMimeType() { return mimeType; } /** * Return the representation class. * * @return the representation class */ public Class getRepresentationClass() { return representationClass; } /** * Return the Human Presentable name. * * @return the human presentable name */ public String getHumanPresentableName() { return humanPresentableName; } /** * Set the human presentable name. * * @param humanPresentableName the name to set */ public void setHumanPresentableName(String humanPresentableName) { this.humanPresentableName = humanPresentableName; } /** * Compares the ActivationDataFlavor passed in with this * ActivationDataFlavor; calls the isMimeTypeEqual method. * * @param dataFlavor the ActivationDataFlavor to compare with * @return true if the MIME type and representation class * are the same */ public boolean equals(ActivationDataFlavor dataFlavor) { return (isMimeTypeEqual(dataFlavor.mimeType) && dataFlavor.getRepresentationClass() == representationClass); } /** * @param o the Object to compare with * @return true if the object is also an ActivationDataFlavor * and is equal to this */ public boolean equals(Object o) { return ((o instanceof ActivationDataFlavor) && equals((ActivationDataFlavor)o)); } /** * Compares only the mimeType against the passed in * String and representationClass is * not considered in the comparison. * * If representationClass needs to be compared, then * equals(new DataFlavor(s)) may be used. * @deprecated As inconsistent with hashCode() contract, * use isMimeTypeEqual(String) instead. * @param s the {@code mimeType} to compare. * @return true if the String (MimeType) is equal; false otherwise or if * {@code s} is {@code null} */ @Deprecated public boolean equals(String s) { if (s == null || mimeType == null) return false; return isMimeTypeEqual(s); } /** * Returns hash code for this ActivationDataFlavor. * For two equal ActivationDataFlavors, hash codes are equal. * For the String * that matches ActivationDataFlavor.equals(String), it is not * guaranteed that ActivationDataFlavor's hash code is equal * to the hash code of the String. * * @return a hash code for this ActivationDataFlavor */ public int hashCode() { int total = 0; if (representationClass != null) { total += representationClass.hashCode(); } // XXX - MIME type equality is too complicated so we don't // include it in the hashCode return total; } /** * Is the string representation of the MIME type passed in equivalent * to the MIME type of this ActivationDataFlavor.

* * ActivationDataFlavor delegates the comparison of MIME types to * the MimeType class included as part of Jakarta Activation. * * @param mimeType the MIME type * @return true if the same MIME type */ public boolean isMimeTypeEqual(String mimeType) { MimeType mt = null; try { if (mimeObject == null) mimeObject = new MimeType(this.mimeType); mt = new MimeType(mimeType); } catch (MimeTypeParseException e) { // something didn't parse, do a crude comparison return this.mimeType.equalsIgnoreCase(mimeType); } return mimeObject.match(mt); } /** * Called on ActivationDataFlavor for every MIME Type parameter to allow * ActivationDataFlavor subclasses to handle special parameters like the * text/plain charset parameters, whose values are case insensitive. * (MIME type parameter values are supposed to be case sensitive). *

* This method is called for each parameter name/value pair and should * return the normalized representation of the parameterValue. * This method is never invoked by this implementation. * * @param parameterName the parameter name * @param parameterValue the parameter value * @return the normalized parameter value * @deprecated */ @Deprecated protected String normalizeMimeTypeParameter(String parameterName, String parameterValue) { return parameterValue; } /** * Called for each MIME type string to give ActivationDataFlavor subtypes * the opportunity to change how the normalization of MIME types is * accomplished. * One possible use would be to add default parameter/value pairs in cases * where none are present in the MIME type string passed in. * This method is never invoked by this implementation. * * @param mimeType the MIME type * @return the normalized MIME type * @deprecated */ @Deprecated protected String normalizeMimeType(String mimeType) { return mimeType; } } jaf-api-2.1.1/api/src/main/java/jakarta/activation/CommandInfo.java000066400000000000000000000157341435131260600250550ustar00rootroot00000000000000/* * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import java.io.*; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.security.AccessController; import java.security.PrivilegedAction; /** * The CommandInfo class is used by CommandMap implementations to * describe the results of command requests. It provides the requestor * with both the verb requested, as well as an instance of the * bean. There is also a method that will return the name of the * class that implements the command but it is not guaranteed to * return a valid value. The reason for this is to allow CommandMap * implmentations that subclass CommandInfo to provide special * behavior. For example a CommandMap could dynamically generate * JavaBeans. In this case, it might not be possible to create an * object with all the correct state information solely from the class * name. */ public class CommandInfo { private String verb; private String className; /** * The Constructor for CommandInfo. * @param verb The command verb this CommandInfo decribes. * @param className The command's fully qualified class name. */ public CommandInfo(String verb, String className) { this.verb = verb; this.className = className; } /** * Return the command verb. * * @return the command verb. */ public String getCommandName() { return verb; } /** * Return the command's class name. This method MAY return null in * cases where a CommandMap subclassed CommandInfo for its * own purposes. In other words, it might not be possible to * create the correct state in the command by merely knowing * its class name. DO NOT DEPEND ON THIS METHOD RETURNING * A VALID VALUE! * * @return The class name of the command, or null */ public String getCommandClass() { return className; } /** * Return the instantiated JavaBean component. *

* If the current runtime environment supports * Beans.instantiate, * use it to instantiate the JavaBeans component. Otherwise, use * {@link java.lang.Class#forName Class.forName}. *

* The component class needs to be public. * On Java SE 9 and newer, if the component class is in a named module, * it needs to be in an exported package. *

* If the bean implements the jakarta.activation.CommandObject * interface, call its setCommandContext method. *

* If the DataHandler parameter is null, then the bean is * instantiated with no data. NOTE: this may be useful * if for some reason the DataHandler that is passed in * throws IOExceptions when this method attempts to * access its InputStream. It will allow the caller to * retrieve a reference to the bean if it can be * instantiated. *

* If the bean does NOT implement the CommandObject interface, * this method will check if it implements the * java.io.Externalizable interface. If it does, the bean's * readExternal method will be called if an InputStream * can be acquired from the DataHandler. * * @param dh The DataHandler that describes the data to be * passed to the command. * @param loader The ClassLoader to be used to instantiate the bean. * @return The bean * @exception IOException for failures reading data * @exception ClassNotFoundException if command object class can't * be found * @see jakarta.activation.CommandObject */ public Object getCommandObject(DataHandler dh, ClassLoader loader) throws IOException, ClassNotFoundException { Object new_bean = null; // try to instantiate the bean new_bean = Beans.instantiate(loader, className); // if we got one and it is a CommandObject if (new_bean != null) { if (new_bean instanceof CommandObject) { ((CommandObject)new_bean).setCommandContext(verb, dh); } else if (new_bean instanceof Externalizable) { if (dh != null) { InputStream is = dh.getInputStream(); if (is != null) { ((Externalizable)new_bean).readExternal( new ObjectInputStream(is)); } } } } return new_bean; } /** * Helper class to invoke Beans.instantiate reflectively or the equivalent * with core reflection when module java.desktop is not readable. */ private static final class Beans { static final Method instantiateMethod; static { Method m; try { Class c = Class.forName("java.beans.Beans"); m = c.getDeclaredMethod("instantiate", ClassLoader.class, String.class); } catch (ClassNotFoundException | NoSuchMethodException e) { m = null; } instantiateMethod = m; } /** * Equivalent to invoking java.beans.Beans.instantiate(loader, cn) */ static Object instantiate(ClassLoader loader, String cn) throws IOException, ClassNotFoundException { Exception exception; if (instantiateMethod != null) { // invoke Beans.instantiate try { return instantiateMethod.invoke(null, loader, cn); } catch (InvocationTargetException | IllegalAccessException e) { exception = e; } } else { SecurityManager security = System.getSecurityManager(); if (security != null) { // if it's ok with the SecurityManager, it's ok with me. String cname = cn.replace('/', '.'); if (cname.startsWith("[")) { int b = cname.lastIndexOf('[') + 2; if (b > 1 && b < cname.length()) { cname = cname.substring(b); } } int i = cname.lastIndexOf('.'); if (i != -1) { security.checkPackageAccess(cname.substring(0, i)); } } // Beans.instantiate specified to use SCL when loader is null if (loader == null) { loader = AccessController.doPrivileged(new PrivilegedAction() { public ClassLoader run() { ClassLoader cl = null; try { cl = ClassLoader.getSystemClassLoader(); } catch (SecurityException ex) { } return cl; } }); } Class beanClass = Class.forName(cn, true, loader); try { return beanClass.getDeclaredConstructor().newInstance(); } catch (Exception ex) { throw new ClassNotFoundException(beanClass + ": " + ex, ex); } } return null; } } } jaf-api-2.1.1/api/src/main/java/jakarta/activation/CommandMap.java000066400000000000000000000173551435131260600247000ustar00rootroot00000000000000/* * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import java.util.Map; import java.util.WeakHashMap; /** * The CommandMap class provides an interface to a registry of * command objects available in the system. * Developers are expected to either use the CommandMap * implementation included with this package (MailcapCommandMap) or * develop their own. Note that some of the methods in this class are * abstract. */ public abstract class CommandMap { private static CommandMap defaultCommandMap = null; private static Map map = new WeakHashMap(); /** * Default (empty) constructor. */ protected CommandMap() { } /** * Get the default CommandMap. * *

* * @return the CommandMap */ public static synchronized CommandMap getDefaultCommandMap() { if (defaultCommandMap != null) return defaultCommandMap; // fetch per-thread-context-class-loader default ClassLoader tccl = SecuritySupport.getContextClassLoader(); CommandMap def = map.get(tccl); if (def == null) { def = new MailcapCommandMap(); map.put(tccl, def); } return def; } /** * Set the default CommandMap. Reset the CommandMap to the default by * calling this method with null. * * @param commandMap The new default CommandMap. * @exception SecurityException if the caller doesn't have permission * to change the default */ public static synchronized void setDefaultCommandMap(CommandMap commandMap) { SecurityManager security = System.getSecurityManager(); if (security != null) { try { // if it's ok with the SecurityManager, it's ok with me... security.checkSetFactory(); } catch (SecurityException ex) { // otherwise, we also allow it if this code and the // factory come from the same (non-system) class loader (e.g., // the JAF classes were loaded with the applet classes). ClassLoader cl = CommandMap.class.getClassLoader(); if (cl == null || cl.getParent() == null || cl != commandMap.getClass().getClassLoader()) { throw ex; } } } // remove any per-thread-context-class-loader CommandMap map.remove(SecuritySupport.getContextClassLoader()); defaultCommandMap = commandMap; } /** * Get the preferred command list from a MIME Type. The actual semantics * are determined by the implementation of the CommandMap. * * @param mimeType the MIME type * @return the CommandInfo classes that represent the command Beans. */ abstract public CommandInfo[] getPreferredCommands(String mimeType); /** * 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. * * @param mimeType the MIME type * @return the CommandInfo objects representing all the commands. */ abstract public CommandInfo[] getAllCommands(String 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. * * @param mimeType the MIME type * @param cmdName the command name * @return the CommandInfo corresponding to the command. */ abstract public CommandInfo getCommand(String mimeType, String cmdName); /** * 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. * * @param mimeType the MIME type * @return the DataContentHandler for the MIME type */ abstract public DataContentHandler createDataContentHandler(String mimeType); /** * 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); } /** * 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; } } jaf-api-2.1.1/api/src/main/java/jakarta/activation/CommandObject.java000066400000000000000000000025521435131260600253620ustar00rootroot00000000000000/* * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import java.io.IOException; /** * JavaBeans components that are Jakarta Activation aware implement * this interface to find out which command verb they're being asked * to perform, and to obtain the DataHandler representing the * data they should operate on. JavaBeans that don't implement * this interface may be used as well. Such commands may obtain * the data using the Externalizable interface, or using an * application-specific method. */ public interface CommandObject { /** * Initialize the Command with the verb it is requested to handle * and the DataHandler that describes the data it will * operate on. NOTE: it is acceptable for the caller * to pass null as the value for DataHandler. * * @param verb The Command Verb this object refers to. * @param dh The DataHandler. * @exception IOException for failures accessing data */ public void setCommandContext(String verb, DataHandler dh) throws IOException; } jaf-api-2.1.1/api/src/main/java/jakarta/activation/DataContentHandler.java000066400000000000000000000063611435131260600263610ustar00rootroot00000000000000/* * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import java.io.InputStream; import java.io.IOException; import java.io.OutputStream; import jakarta.activation.DataSource; /** * The DataContentHandler interface is implemented by objects that can * be used to extend the capabilities of the DataHandler's implementation * of the Transferable interface. Through DataContentHandlers * the framework can be extended to convert streams in to objects, and * to write objects to streams.

* * Applications don't generally call the methods in DataContentHandlers * directly. Instead, an application calls the equivalent methods in * DataHandler. The DataHandler will attempt to find an appropriate * DataContentHandler that corresponds to its MIME type using the * current DataContentHandlerFactory. The DataHandler then calls * through to the methods in the DataContentHandler. */ public interface DataContentHandler { /** * Returns an array of ActivationDataFlavor objects indicating the flavors * the data can be provided in. The array should be ordered according to * preference for providing the data (from most richly descriptive to * least descriptive). * * @return The ActivationDataFlavors. */ public ActivationDataFlavor[] getTransferDataFlavors(); /** * Returns an object which represents the data to be transferred. * The class of the object returned is defined by the representation class * of the flavor. * * @param df The ActivationDataFlavor representing the requested type. * @param ds The DataSource representing the data to be converted. * @return The constructed Object. * @exception IOException if the handler doesn't * support the requested flavor * @exception IOException if the data can't be accessed */ public Object getTransferData(ActivationDataFlavor df, DataSource ds) throws IOException; /** * Return an object representing the data in its most preferred form. * Generally this will be the form described by the first * ActivationDataFlavor returned by the * getTransferDataFlavors method. * * @param ds The DataSource representing the data to be converted. * @return The constructed Object. * @exception IOException if the data can't be accessed */ public Object getContent(DataSource ds) throws IOException; /** * Convert the object to a byte stream of the specified MIME type * and write it to the output stream. * * @param obj The object to be converted. * @param mimeType The requested MIME type of the resulting byte stream. * @param os The output stream into which to write the converted * byte stream. * @exception IOException errors writing to the stream */ public void writeTo(Object obj, String mimeType, OutputStream os) throws IOException; } jaf-api-2.1.1/api/src/main/java/jakarta/activation/DataContentHandlerFactory.java000066400000000000000000000020751435131260600277070ustar00rootroot00000000000000/* * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; /** * This interface defines a factory for DataContentHandlers. An * implementation of this interface should map a MIME type into an * instance of DataContentHandler. The design pattern for classes implementing * this interface is the same as for the ContentHandler mechanism used in * java.net.URL. */ public interface DataContentHandlerFactory { /** * Creates a new DataContentHandler object for the MIME type. * * @param mimeType the MIME type to create the DataContentHandler for. * @return The new DataContentHandler, or null * if none are found. */ public DataContentHandler createDataContentHandler(String mimeType); } jaf-api-2.1.1/api/src/main/java/jakarta/activation/DataHandler.java000066400000000000000000000705121435131260600250250ustar00rootroot00000000000000/* * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import java.io.InputStream; import java.io.IOException; import java.io.OutputStream; import java.io.PipedInputStream; import java.io.PipedOutputStream; import java.io.OutputStreamWriter; import java.net.URL; import java.nio.charset.Charset; /** * The DataHandler class provides a consistent interface to data * available in many different sources and formats. * It manages simple stream to string conversions and related operations * using DataContentHandlers. * It provides access to commands that can operate on the data. * The commands are found using a CommandMap.

* * DataHandler and CommandMaps

* The DataHandler keeps track of the current CommandMap that it uses to * service requests for commands (getCommand, * getAllCommands, getPreferredCommands). * Each instance of a DataHandler may have a CommandMap associated with * it using the setCommandMap method. If a CommandMap was * not set, DataHandler calls the getDefaultCommandMap * method in CommandMap and uses the value it returns. See * CommandMap for more information.

* * DataHandler and URLs

* The current DataHandler implementation creates a private * instance of URLDataSource when it is constructed with a URL. * * @see jakarta.activation.CommandMap * @see jakarta.activation.DataContentHandler * @see jakarta.activation.DataSource * @see jakarta.activation.URLDataSource */ public class DataHandler { // Use the datasource to indicate whether we were started via the // DataSource constructor or the object constructor. private DataSource dataSource = null; private DataSource objDataSource = null; // The Object and mimetype from the constructor (if passed in). // object remains null if it was instantiated with a // DataSource. private Object object = null; private String objectMimeType = null; // Keep track of the CommandMap private CommandMap currentCommandMap = null; // our transfer flavors private static final ActivationDataFlavor emptyFlavors[] = new ActivationDataFlavor[0]; private ActivationDataFlavor transferFlavors[] = emptyFlavors; // our DataContentHandler private DataContentHandler dataContentHandler = null; private DataContentHandler factoryDCH = null; // our DataContentHandlerFactory private static DataContentHandlerFactory factory = null; private DataContentHandlerFactory oldFactory = null; // the short representation of the ContentType (sans params) private String shortType = null; /** * Create a DataHandler instance referencing the * specified DataSource. The data exists in a byte stream form. * The DataSource will provide an InputStream to access the data. * * @param ds the DataSource */ public DataHandler(DataSource ds) { // save a reference to the incoming DS dataSource = ds; oldFactory = factory; // keep track of the factory } /** * Create a DataHandler instance representing an object * of this MIME type. This constructor is * used when the application already has an in-memory representation * of the data in the form of a Java Object. * * @param obj the Java Object * @param mimeType the MIME type of the object */ public DataHandler(Object obj, String mimeType) { object = obj; objectMimeType = mimeType; oldFactory = factory; // keep track of the factory } /** * Create a DataHandler instance referencing a URL. * The DataHandler internally creates a URLDataSource * instance to represent the URL. * * @param url a URL object */ public DataHandler(URL url) { dataSource = new URLDataSource(url); oldFactory = factory; // keep track of the factory } /** * Return the CommandMap for this instance of DataHandler. */ private synchronized CommandMap getCommandMap() { if (currentCommandMap != null) return currentCommandMap; else return CommandMap.getDefaultCommandMap(); } /** * Return the DataSource associated with this instance * of DataHandler. *

* For DataHandlers that have been instantiated with a DataSource, * this method returns the DataSource that was used to create the * DataHandler object. In other cases the DataHandler * constructs a DataSource from the data used to construct * the DataHandler. DataSources created for DataHandlers not * instantiated with a DataSource are cached for performance * reasons. * * @return a valid DataSource object for this DataHandler */ public DataSource getDataSource() { if (dataSource == null) { // create one on the fly if (objDataSource == null) objDataSource = new DataHandlerDataSource(this); return objDataSource; } return dataSource; } /** * Return the name of the data object. If this DataHandler * was created with a DataSource, this method calls through * to the DataSource.getName method, otherwise it * returns null. * * @return the name of the object */ public String getName() { if (dataSource != null) return dataSource.getName(); else return null; } /** * Return the MIME type of this object as retrieved from * the source object. Note that this is the full * type with parameters. * * @return the MIME type */ public String getContentType() { if (dataSource != null) // data source case return dataSource.getContentType(); else return objectMimeType; // obj/type case } /** * Get the InputStream for this object.

* * For DataHandlers instantiated with a DataSource, the DataHandler * calls the DataSource.getInputStream method and * returns the result to the caller. *

* For DataHandlers instantiated with an Object, the DataHandler * first attempts to find a DataContentHandler for the Object. If * the DataHandler can not find a DataContentHandler for this MIME * type, it throws an UnsupportedDataTypeException. If it is * successful, it creates a pipe and a thread. The thread uses the * DataContentHandler's writeTo method to write the * stream data into one end of the pipe. The other end of the pipe * is returned to the caller. Because a thread is created to copy * the data, IOExceptions that may occur during the copy can not be * propagated back to the caller. The result is an empty stream. * * @return the InputStream representing this data * @exception IOException if an I/O error occurs * * @see jakarta.activation.DataContentHandler#writeTo * @see jakarta.activation.UnsupportedDataTypeException */ public InputStream getInputStream() throws IOException { InputStream ins = null; if (dataSource != null) { ins = dataSource.getInputStream(); } else { DataContentHandler dch = getDataContentHandler(); // we won't even try if we can't get a dch if (dch == null) throw new UnsupportedDataTypeException( "no DCH for MIME type " + getBaseType()); if (dch instanceof ObjectDataContentHandler) { if (((ObjectDataContentHandler)dch).getDCH() == null) throw new UnsupportedDataTypeException( "no object DCH for MIME type " + getBaseType()); } // there is none but the default^^^^^^^^^^^^^^^^ final DataContentHandler fdch = dch; // from bill s. // ce n'est pas une pipe! // // NOTE: This block of code needs to throw exceptions, but // can't because it is in another thread!!! ARG! // final PipedOutputStream pos = new PipedOutputStream(); PipedInputStream pin = new PipedInputStream(pos); new Thread( new Runnable() { public void run() { try { fdch.writeTo(object, objectMimeType, pos); } catch (IOException e) { } finally { try { pos.close(); } catch (IOException ie) { } } } }, "DataHandler.getInputStream").start(); ins = pin; } return ins; } /** * Write the data to an OutputStream.

* * If the DataHandler was created with a DataSource, writeTo * retrieves the InputStream and copies the bytes from the * InputStream to the OutputStream passed in. *

* If the DataHandler was created with an object, writeTo * retrieves the DataContentHandler for the object's type. * If the DataContentHandler was found, it calls the * writeTo method on the DataContentHandler. * * @param os the OutputStream to write to * @exception IOException if an I/O error occurs */ public void writeTo(OutputStream os) throws IOException { // for the DataSource case if (dataSource != null) { InputStream is = null; byte data[] = new byte[8*1024]; int bytes_read; is = dataSource.getInputStream(); try { while ((bytes_read = is.read(data)) > 0) { os.write(data, 0, bytes_read); } } finally { is.close(); is = null; } } else { // for the Object case DataContentHandler dch = getDataContentHandler(); dch.writeTo(object, objectMimeType, os); } } /** * Get an OutputStream for this DataHandler to allow overwriting * the underlying data. * If the DataHandler was created with a DataSource, the * DataSource's getOutputStream method is called. * Otherwise, null is returned. * * @return the OutputStream * @exception IOException for failures creating the OutputStream * * @see jakarta.activation.DataSource#getOutputStream * @see jakarta.activation.URLDataSource */ public OutputStream getOutputStream() throws IOException { if (dataSource != null) return dataSource.getOutputStream(); else return null; } /** * Return the ActivationDataFlavors in which this data is available.

* * Returns an array of ActivationDataFlavor objects indicating the flavors * the data can be provided in. The array is usually ordered * according to preference for providing the data, from most * richly descriptive to least richly descriptive.

* * The DataHandler attempts to find a DataContentHandler that * corresponds to the MIME type of the data. If one is located, * the DataHandler calls the DataContentHandler's * getTransferDataFlavors method.

* * If a DataContentHandler can not be located, and if the * DataHandler was created with a DataSource (or URL), one * ActivationDataFlavor is returned that represents this object's MIME type * and the java.io.InputStream class. If the * DataHandler was created with an object and a MIME type, * getTransferDataFlavors returns one ActivationDataFlavor that represents * this object's MIME type and the object's class. * * @return an array of data flavors in which this data can be transferred * @see jakarta.activation.DataContentHandler#getTransferDataFlavors */ public synchronized ActivationDataFlavor[] getTransferDataFlavors() { if (factory != oldFactory) // if the factory has changed, clear cache transferFlavors = emptyFlavors; // if it's not set, set it... if (transferFlavors == emptyFlavors) transferFlavors = getDataContentHandler().getTransferDataFlavors(); if (transferFlavors == emptyFlavors) return transferFlavors; // no need to clone an empty array else return transferFlavors.clone(); } /** * Returns whether the specified data flavor is supported * for this object.

* * This method iterates through the ActivationDataFlavors returned from * getTransferDataFlavors, comparing each with * the specified flavor. * * @param flavor the requested flavor for the data * @return true if the data flavor is supported * @see jakarta.activation.DataHandler#getTransferDataFlavors */ public boolean isDataFlavorSupported(ActivationDataFlavor flavor) { ActivationDataFlavor[] lFlavors = getTransferDataFlavors(); for (int i = 0; i < lFlavors.length; i++) { if (lFlavors[i].equals(flavor)) return true; } return false; } /** * Returns an object that represents the data to be * transferred. The class of the object returned is defined by the * representation class of the data flavor.

* * For DataHandler's created with DataSources or URLs:

* * The DataHandler attempts to locate a DataContentHandler * for this MIME type. If one is found, the passed in ActivationDataFlavor * and the type of the data are passed to its getTransferData * method. If the DataHandler fails to locate a DataContentHandler * and the flavor specifies this object's MIME type and the * java.io.InputStream class, this object's InputStream * is returned. * Otherwise it throws an IOException.

* * For DataHandler's created with Objects:

* * The DataHandler attempts to locate a DataContentHandler * for this MIME type. If one is found, the passed in ActivationDataFlavor * and the type of the data are passed to its getTransferData * method. If the DataHandler fails to locate a DataContentHandler * and the flavor specifies this object's MIME type and its class, * this DataHandler's referenced object is returned. * Otherwise it throws an IOException. * * @param flavor the requested flavor for the data * @return the object * @exception IOException if the data could not be * converted to the requested flavor * @exception IOException if an I/O error occurs * @see jakarta.activation.ActivationDataFlavor */ public Object getTransferData(ActivationDataFlavor flavor) throws IOException { return getDataContentHandler().getTransferData(flavor, dataSource); } /** * Set the CommandMap for use by this DataHandler. * Setting it to null causes the CommandMap to revert * to the CommandMap returned by the * CommandMap.getDefaultCommandMap method. * Changing the CommandMap, or setting it to null, * clears out any data cached from the previous CommandMap. * * @param commandMap the CommandMap to use in this DataHandler * * @see jakarta.activation.CommandMap#setDefaultCommandMap */ public synchronized void setCommandMap(CommandMap commandMap) { if (commandMap != currentCommandMap || commandMap == null) { // clear cached values... transferFlavors = emptyFlavors; dataContentHandler = null; currentCommandMap = commandMap; } } /** * Return the preferred commands for this type of data. * This method calls the getPreferredCommands method * in the CommandMap associated with this instance of DataHandler. * This method returns an array that represents a subset of * available commands. In cases where multiple commands for the * MIME type represented by this DataHandler are present, the * installed CommandMap chooses the appropriate commands. * * @return the CommandInfo objects representing the preferred commands * * @see jakarta.activation.CommandMap#getPreferredCommands */ public CommandInfo[] getPreferredCommands() { if (dataSource != null) return getCommandMap().getPreferredCommands(getBaseType(), dataSource); else return getCommandMap().getPreferredCommands(getBaseType()); } /** * Return all the commands for this type of data. * This method returns an array containing all commands * for the type of data represented by this DataHandler. The * MIME type for the underlying data represented by this DataHandler * is used to call through to the getAllCommands method * of the CommandMap associated with this DataHandler. * * @return the CommandInfo objects representing all the commands * * @see jakarta.activation.CommandMap#getAllCommands */ public CommandInfo[] getAllCommands() { if (dataSource != null) return getCommandMap().getAllCommands(getBaseType(), dataSource); else return getCommandMap().getAllCommands(getBaseType()); } /** * Get the command cmdName. Use the search semantics as * defined by the CommandMap installed in this DataHandler. The * MIME type for the underlying data represented by this DataHandler * is used to call through to the getCommand method * of the CommandMap associated with this DataHandler. * * @param cmdName the command name * @return the CommandInfo corresponding to the command * * @see jakarta.activation.CommandMap#getCommand */ public CommandInfo getCommand(String cmdName) { if (dataSource != null) return getCommandMap().getCommand(getBaseType(), cmdName, dataSource); else return getCommandMap().getCommand(getBaseType(), cmdName); } /** * Return the data in its preferred Object form.

* * If the DataHandler was instantiated with an object, return * the object.

* * If the DataHandler was instantiated with a DataSource, * this method uses a DataContentHandler to return the content * object for the data represented by this DataHandler. If no * DataContentHandler can be found for the * the type of this data, the DataHandler returns an * InputStream for the data. * * @return the content. * @exception IOException if an IOException occurs during * this operation. */ public Object getContent() throws IOException { if (object != null) return object; else return getDataContentHandler().getContent(getDataSource()); } /** * A convenience method that takes a CommandInfo object * and instantiates the corresponding command, usually * a JavaBean component. *

* This method calls the CommandInfo's getCommandObject * method with the ClassLoader used to load * the jakarta.activation.DataHandler class itself. * * @param cmdinfo the CommandInfo corresponding to a command * @return the instantiated command object */ public Object getBean(CommandInfo cmdinfo) { Object bean = null; try { // make the bean ClassLoader cld = null; // First try the "application's" class loader. cld = SecuritySupport.getContextClassLoader(); if (cld == null) cld = this.getClass().getClassLoader(); bean = cmdinfo.getCommandObject(this, cld); } catch (IOException e) { } catch (ClassNotFoundException e) { } return bean; } /** * Get the DataContentHandler for this DataHandler:

* * If a DataContentHandlerFactory is set, use it. * Otherwise look for an object to serve DCH in the * following order:

* * 1) if a factory is set, use it

* 2) if a CommandMap is set, use it

* 3) use the default CommandMap

* * In any case, wrap the real DataContentHandler with one of our own * to handle any missing cases, fill in defaults, and to ensure that * we always have a non-null DataContentHandler. * * @return the requested DataContentHandler */ private synchronized DataContentHandler getDataContentHandler() { // make sure the factory didn't change if (factory != oldFactory) { oldFactory = factory; factoryDCH = null; dataContentHandler = null; transferFlavors = emptyFlavors; } if (dataContentHandler != null) return dataContentHandler; String simpleMT = getBaseType(); if (factoryDCH == null && factory != null) factoryDCH = factory.createDataContentHandler(simpleMT); if (factoryDCH != null) dataContentHandler = factoryDCH; if (dataContentHandler == null) { if (dataSource != null) dataContentHandler = getCommandMap(). createDataContentHandler(simpleMT, dataSource); else dataContentHandler = getCommandMap(). createDataContentHandler(simpleMT); } // getDataContentHandler always uses these 'wrapper' handlers // to make sure it returns SOMETHING meaningful... if (dataSource != null) dataContentHandler = new DataSourceDataContentHandler( dataContentHandler, dataSource); else dataContentHandler = new ObjectDataContentHandler( dataContentHandler, object, objectMimeType); return dataContentHandler; } /** * Use the MimeType class to extract the MIME type/subtype, * ignoring the parameters. The type is cached. */ private synchronized String getBaseType() { if (shortType == null) { String ct = getContentType(); try { MimeType mt = new MimeType(ct); shortType = mt.getBaseType(); } catch (MimeTypeParseException e) { shortType = ct; } } return shortType; } /** * Sets the DataContentHandlerFactory. The DataContentHandlerFactory * is called first to find DataContentHandlers. * The DataContentHandlerFactory can only be set once. *

* If the DataContentHandlerFactory has already been set, * this method throws an Error. * * @param newFactory the DataContentHandlerFactory * @exception Error if the factory has already been defined. * * @see jakarta.activation.DataContentHandlerFactory */ public static synchronized void setDataContentHandlerFactory( DataContentHandlerFactory newFactory) { if (factory != null) throw new Error("DataContentHandlerFactory already defined"); SecurityManager security = System.getSecurityManager(); if (security != null) { try { // if it's ok with the SecurityManager, it's ok with me... security.checkSetFactory(); } catch (SecurityException ex) { // otherwise, we also allow it if this code and the // factory come from the same class loader (e.g., // the JAF classes were loaded with the applet classes). if (DataHandler.class.getClassLoader() != newFactory.getClass().getClassLoader()) throw ex; } } factory = newFactory; } } /** * The DataHanderDataSource class implements the * DataSource interface when the DataHandler is constructed * with an Object and a mimeType string. */ class DataHandlerDataSource implements DataSource { DataHandler dataHandler = null; /** * The constructor. */ public DataHandlerDataSource(DataHandler dh) { this.dataHandler = dh; } /** * Returns an InputStream representing this object. * @return the InputStream */ public InputStream getInputStream() throws IOException { return dataHandler.getInputStream(); } /** * Returns the OutputStream for this object. * @return the OutputStream */ public OutputStream getOutputStream() throws IOException { return dataHandler.getOutputStream(); } /** * Returns the MIME type of the data represented by this object. * @return the MIME type */ public String getContentType() { return dataHandler.getContentType(); } /** * Returns the name of this object. * @return the name of this object */ public String getName() { return dataHandler.getName(); // what else would it be? } } /* * DataSourceDataContentHandler * * This is a private DataContentHandler that wraps the real * DataContentHandler in the case where the DataHandler was instantiated * with a DataSource. */ class DataSourceDataContentHandler implements DataContentHandler { private DataSource ds = null; private ActivationDataFlavor transferFlavors[] = null; private DataContentHandler dch = null; /** * The constructor. */ public DataSourceDataContentHandler(DataContentHandler dch, DataSource ds) { this.ds = ds; this.dch = dch; } /** * Return the ActivationDataFlavors for this * DataContentHandler. * @return the ActivationDataFlavors */ public ActivationDataFlavor[] getTransferDataFlavors() { if (transferFlavors == null) { if (dch != null) { // is there a dch? transferFlavors = dch.getTransferDataFlavors(); } else { transferFlavors = new ActivationDataFlavor[1]; transferFlavors[0] = new ActivationDataFlavor(ds.getContentType(), ds.getContentType()); } } return transferFlavors; } /** * Return the Transfer Data of type ActivationDataFlavor from InputStream. * @param df the ActivationDataFlavor * @param ds the DataSource * @return the constructed Object */ public Object getTransferData(ActivationDataFlavor df, DataSource ds) throws IOException { if (dch != null) return dch.getTransferData(df, ds); else if (df.equals(getTransferDataFlavors()[0])) // only have one now return ds.getInputStream(); else throw new IOException("Unsupported DataFlavor: " + df); } public Object getContent(DataSource ds) throws IOException { if (dch != null) return dch.getContent(ds); else return ds.getInputStream(); } /** * Write the object to the output stream. */ public void writeTo(Object obj, String mimeType, OutputStream os) throws IOException { if (dch != null) dch.writeTo(obj, mimeType, os); else throw new UnsupportedDataTypeException( "no DCH for content type " + ds.getContentType()); } } /* * ObjectDataContentHandler * * This is a private DataContentHandler that wraps the real * DataContentHandler in the case where the DataHandler was instantiated * with an object. */ class ObjectDataContentHandler implements DataContentHandler { private ActivationDataFlavor transferFlavors[] = null; private Object obj; private String mimeType; private DataContentHandler dch = null; /** * The constructor. */ public ObjectDataContentHandler(DataContentHandler dch, Object obj, String mimeType) { this.obj = obj; this.mimeType = mimeType; this.dch = dch; } /** * Return the DataContentHandler for this object. * Used only by the DataHandler class. */ public DataContentHandler getDCH() { return dch; } /** * Return the ActivationDataFlavors for this * DataContentHandler. * @return the ActivationDataFlavors */ public synchronized ActivationDataFlavor[] getTransferDataFlavors() { if (transferFlavors == null) { if (dch != null) { transferFlavors = dch.getTransferDataFlavors(); } else { transferFlavors = new ActivationDataFlavor[1]; transferFlavors[0] = new ActivationDataFlavor(obj.getClass(), mimeType, mimeType); } } return transferFlavors; } /** * Return the Transfer Data of type ActivationDataFlavor from InputStream. * @param df the ActivationDataFlavor * @param ds the DataSource * @return the constructed Object */ public Object getTransferData(ActivationDataFlavor df, DataSource ds) throws IOException { if (dch != null) return dch.getTransferData(df, ds); else if (df.equals(getTransferDataFlavors()[0])) // only have one now return obj; else throw new IOException("Unsupported DataFlavor: " + df); } public Object getContent(DataSource ds) { return obj; } /** * Write the object to the output stream. */ public void writeTo(Object obj, String mimeType, OutputStream os) throws IOException { if (dch != null) dch.writeTo(obj, mimeType, os); else if (obj instanceof byte[]) os.write((byte[])obj); else if (obj instanceof String) { OutputStreamWriter osw = new OutputStreamWriter(os, Charset.defaultCharset()); osw.write((String)obj); osw.flush(); } else throw new UnsupportedDataTypeException( "no object DCH for MIME type " + this.mimeType); } } jaf-api-2.1.1/api/src/main/java/jakarta/activation/DataSource.java000066400000000000000000000050331435131260600247040ustar00rootroot00000000000000/* * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import java.io.InputStream; import java.io.OutputStream; import java.io.IOException; /** * The DataSource interface provides Jakarta Activation * with an abstraction of an arbitrary collection of data. It * provides a type for that data as well as access * to it in the form of InputStreams and * OutputStreams where appropriate. */ public interface DataSource { /** * This method returns an InputStream representing * the data and throws the appropriate exception if it can * not do so. Note that a new InputStream object must be * returned each time this method is called, and the stream must be * positioned at the beginning of the data. * * @return an InputStream * @exception IOException for failures creating the InputStream */ public InputStream getInputStream() throws IOException; /** * This method returns an OutputStream where the * data can be written and throws the appropriate exception if it can * not do so. Note that a new OutputStream object must * be returned each time this method is called, and the stream must * be positioned at the location the data is to be written. * * @return an OutputStream * @exception IOException for failures creating the OutputStream */ public OutputStream getOutputStream() throws IOException; /** * This method returns the MIME type of the data in the form of a * string. It should always return a valid type. It is suggested * that getContentType return "application/octet-stream" if the * DataSource implementation can not determine the data type. * * @return the MIME Type */ public String getContentType(); /** * Return the name of this object where the name of the object * is dependant on the nature of the underlying objects. DataSources * encapsulating files may choose to return the filename of the object. * (Typically this would be the last component of the filename, not an * entire pathname.) * * @return the name of the object. */ public String getName(); } jaf-api-2.1.1/api/src/main/java/jakarta/activation/FactoryFinder.java000066400000000000000000000143451435131260600254170ustar00rootroot00000000000000/* * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import java.lang.reflect.Method; import java.security.AccessController; import java.security.PrivilegedAction; import java.util.Iterator; import java.util.logging.Level; import java.util.logging.Logger; class FactoryFinder { private static final Logger logger = Logger.getLogger("jakarta.activation"); private static final ServiceLoaderUtil.ExceptionHandler EXCEPTION_HANDLER = new ServiceLoaderUtil.ExceptionHandler() { @Override public RuntimeException createException(Throwable throwable, String message) { return new RuntimeException(message, throwable); } }; /** * Finds the implementation {@code Class} object for the given * factory type. If it fails and {@code tryFallback} is {@code true} * finds the {@code Class} object for the given default class name. * The arguments supplied must be used in order * Note the default class name may be needed even if fallback * is not to be attempted in order to check if requested type is fallback. *

* This method is package private so that this code can be shared. * * @return the {@code Class} object of the specified message factory; * may not be {@code null} * * @param factoryClass factory abstract class or interface to be found * @param defaultClassName the implementation class name, which is * to be used only if nothing else * is found; {@code null} to indicate * that there is no default class name * @param tryFallback whether to try the default class as a * fallback * @exception RuntimeException if there is no factory found */ static T find(Class factoryClass, String defaultClassName, boolean tryFallback) throws RuntimeException { ClassLoader tccl = ServiceLoaderUtil.contextClassLoader(EXCEPTION_HANDLER); String factoryId = factoryClass.getName(); // Use the system property first String className = fromSystemProperty(factoryId); if (className != null) { T result = newInstance(className, defaultClassName, tccl); if (result != null) { return result; } // try api loader result = newInstance(className, defaultClassName, FactoryFinder.class.getClassLoader()); if (result != null) { return result; } } // standard services: java.util.ServiceLoader T factory = ServiceLoaderUtil.firstByServiceLoader( factoryClass, logger, EXCEPTION_HANDLER); if (factory != null) { return factory; } // handling Glassfish/OSGi (platform specific default) if (isOsgi()) { T result = lookupUsingOSGiServiceLoader(factoryId); if (result != null) { return result; } } // If not found and fallback should not be tried, throw RuntimeException. if (!tryFallback) { throw new RuntimeException( "Provider for " + factoryId + " cannot be found", null); } // We didn't find the class through the usual means so try the default // (built in) factory if specified. if (defaultClassName == null) { throw new RuntimeException( "Provider for " + factoryId + " cannot be found", null); } return newInstance(defaultClassName, defaultClassName, tccl); } private static T newInstance(String className, String defaultClassName, ClassLoader tccl) throws RuntimeException { return ServiceLoaderUtil.newInstance( className, defaultClassName, tccl, EXCEPTION_HANDLER); } private static String fromSystemProperty(String factoryId) { String systemProp = getSystemProperty(factoryId); return systemProp; } private static String getSystemProperty(final String property) { logger.log(Level.FINE, "Checking system property {0}", property); String value = AccessController.doPrivileged(new PrivilegedAction() { @Override public String run() { return System.getProperty(property); } }); logFound(value); return value; } private static void logFound(String value) { if (value != null) { logger.log(Level.FINE, " found {0}", value); } else { logger.log(Level.FINE, " not found"); } } private static final String OSGI_SERVICE_LOADER_CLASS_NAME = "org.glassfish.hk2.osgiresourcelocator.ServiceLoader"; private static boolean isOsgi() { try { Class.forName(OSGI_SERVICE_LOADER_CLASS_NAME); return true; } catch (ClassNotFoundException ignored) { } return false; } @SuppressWarnings({"unchecked"}) private static T lookupUsingOSGiServiceLoader(String factoryId) { try { // Use reflection to avoid having any dependency on HK2 ServiceLoader class Class serviceClass = Class.forName(factoryId); Class[] args = new Class[]{serviceClass}; Class target = Class.forName(OSGI_SERVICE_LOADER_CLASS_NAME); Method m = target.getMethod("lookupProviderInstances", Class.class); Iterator iter = ((Iterable) m.invoke(null, (Object[]) args)).iterator(); return iter.hasNext() ? (T) iter.next() : null; } catch (Exception ignored) { // log and continue return null; } } } jaf-api-2.1.1/api/src/main/java/jakarta/activation/FileDataSource.java000066400000000000000000000104531435131260600255060ustar00rootroot00000000000000/* * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import java.io.InputStream; import java.io.OutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; /** * The FileDataSource class implements a simple DataSource object * that encapsulates a file. It provides data typing services via * a FileTypeMap object.

* * FileDataSource Typing Semantics

* * The FileDataSource class delegates data typing of files * to an object subclassed from the FileTypeMap class. * The setFileTypeMap method can be used to explicitly * set the FileTypeMap for an instance of FileDataSource. If no * FileTypeMap is set, the FileDataSource will call the FileTypeMap's * getDefaultFileTypeMap method to get the System's default FileTypeMap. * * @see jakarta.activation.DataSource * @see jakarta.activation.FileTypeMap * @see jakarta.activation.MimetypesFileTypeMap */ public class FileDataSource implements DataSource { // keep track of original 'ref' passed in, non-null // one indicated which was passed in: private File _file = null; private FileTypeMap typeMap = null; /** * Creates a FileDataSource from a File object. Note: * The file will not actually be opened until a method is * called that requires the file to be opened. * * @param file the file */ public FileDataSource(File file) { _file = file; // save the file Object... } /** * Creates a FileDataSource from * the specified path name. Note: * The file will not actually be opened until a method is * called that requires the file to be opened. * * @param name the system-dependent file name. */ public FileDataSource(String name) { this(new File(name)); // use the file constructor } /** * This method will return an InputStream representing the * the data and will throw an IOException if it can * not do so. This method will return a new * instance of InputStream with each invocation. * * @return an InputStream */ public InputStream getInputStream() throws IOException { return new FileInputStream(_file); } /** * This method will return an OutputStream representing the * the data and will throw an IOException if it can * not do so. This method will return a new instance of * OutputStream with each invocation. * * @return an OutputStream */ public OutputStream getOutputStream() throws IOException { return new FileOutputStream(_file); } /** * This method returns the MIME type of the data in the form of a * string. This method uses the currently installed FileTypeMap. If * there is no FileTypeMap explictly set, the FileDataSource will * call the getDefaultFileTypeMap method on * FileTypeMap to acquire a default FileTypeMap. Note: By * default, the FileTypeMap used will be a MimetypesFileTypeMap. * * @return the MIME Type * @see jakarta.activation.FileTypeMap#getDefaultFileTypeMap */ public String getContentType() { // check to see if the type map is null? if (typeMap == null) return FileTypeMap.getDefaultFileTypeMap().getContentType(_file); else return typeMap.getContentType(_file); } /** * Return the name of this object. The FileDataSource * will return the file name of the object. * * @return the name of the object. * @see jakarta.activation.DataSource */ public String getName() { return _file.getName(); } /** * Return the File object that corresponds to this FileDataSource. * @return the File object for the file represented by this object. */ public File getFile() { return _file; } /** * Set the FileTypeMap to use with this FileDataSource * * @param map The FileTypeMap for this object. */ public void setFileTypeMap(FileTypeMap map) { typeMap = map; } } jaf-api-2.1.1/api/src/main/java/jakarta/activation/FileTypeMap.java000066400000000000000000000073371435131260600250420ustar00rootroot00000000000000/* * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import java.io.File; import java.util.Map; import java.util.WeakHashMap; /** * The FileTypeMap is an abstract class that provides a data typing * interface for files. Implementations of this class will * implement the getContentType methods which will derive a content * type from a file name or a File object. FileTypeMaps could use any * scheme to determine the data type, from examining the file extension * of a file (like the MimetypesFileTypeMap) to opening the file and * trying to derive its type from the contents of the file. The * FileDataSource class uses the default FileTypeMap (a MimetypesFileTypeMap * unless changed) to determine the content type of files. * * @see jakarta.activation.FileTypeMap * @see jakarta.activation.FileDataSource * @see jakarta.activation.MimetypesFileTypeMap */ public abstract class FileTypeMap { private static FileTypeMap defaultMap = null; private static Map map = new WeakHashMap(); /** * The default constructor. */ public FileTypeMap() { super(); } /** * Return the type of the file object. This method should * always return a valid MIME type. * * @param file A file to be typed. * @return The content type. */ abstract public String getContentType(File file); /** * Return the type of the file passed in. This method should * always return a valid MIME type. * * @param filename the pathname of the file. * @return The content type. */ abstract public String getContentType(String filename); /** * Sets the default FileTypeMap for the system. This instance * will be returned to callers of getDefaultFileTypeMap. * * @param fileTypeMap The FileTypeMap. * @exception SecurityException if the caller doesn't have permission * to change the default */ public static synchronized void setDefaultFileTypeMap(FileTypeMap fileTypeMap) { SecurityManager security = System.getSecurityManager(); if (security != null) { try { // if it's ok with the SecurityManager, it's ok with me... security.checkSetFactory(); } catch (SecurityException ex) { // otherwise, we also allow it if this code and the // factory come from the same (non-system) class loader (e.g., // the JAF classes were loaded with the applet classes). ClassLoader cl = FileTypeMap.class.getClassLoader(); if (cl == null || cl.getParent() == null || cl != fileTypeMap.getClass().getClassLoader()) throw ex; } } // remove any per-thread-context-class-loader FileTypeMap map.remove(SecuritySupport.getContextClassLoader()); defaultMap = fileTypeMap; } /** * Return the default FileTypeMap for the system. * If setDefaultFileTypeMap was called, return * that instance, otherwise return an instance of * MimetypesFileTypeMap. * * @return The default FileTypeMap * @see jakarta.activation.FileTypeMap#setDefaultFileTypeMap */ public static synchronized FileTypeMap getDefaultFileTypeMap() { if (defaultMap != null) return defaultMap; // fetch per-thread-context-class-loader default ClassLoader tccl = SecuritySupport.getContextClassLoader(); FileTypeMap def = map.get(tccl); if (def == null) { def = new MimetypesFileTypeMap(); map.put(tccl, def); } return def; } } jaf-api-2.1.1/api/src/main/java/jakarta/activation/LogSupport.java000066400000000000000000000026011435131260600247660ustar00rootroot00000000000000/* * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import java.util.logging.*; /** * Logging related methods. */ class LogSupport { private static boolean debug = false; private static Logger logger; private static final Level level = Level.FINE; static { try { debug = Boolean.getBoolean("jakarta.activation.debug") || Boolean.getBoolean("javax.activation.debug"); } catch (Throwable t) { // ignore any errors } logger = Logger.getLogger("jakarta.activation"); } /** * Constructor. */ private LogSupport() { // private constructor, can't create instances } public static void log(String msg) { if (debug) System.out.println(msg); logger.log(level, msg); } public static void log(String msg, Throwable t) { if (debug) System.out.println(msg + "; Exception: " + t); logger.log(level, msg, t); } public static boolean isLoggable() { return debug || logger.isLoggable(level); } } jaf-api-2.1.1/api/src/main/java/jakarta/activation/MailcapCommandMap.java000066400000000000000000000616461435131260600261710ustar00rootroot00000000000000/* * Copyright (c) 1997, 2022 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import jakarta.activation.spi.MailcapRegistryProvider; import java.util.*; import java.io.*; import java.net.*; import java.security.AccessController; import java.security.PrivilegedAction; /** * MailcapCommandMap extends the CommandMap * abstract class. It implements a CommandMap whose configuration * is based on mailcap files * (RFC 1524). * The MailcapCommandMap can be configured both programmatically * and via configuration files. *

* Mailcap file search order:

* The MailcapCommandMap looks in various places in the user's * system for mailcap file entries. When requests are made * to search for commands in the MailcapCommandMap, it searches * mailcap files in the following order: *

    *
  1. Programatically added entries to the MailcapCommandMap instance. *
  2. The file .mailcap in the user's home directory. *
  3. The file mailcap in the Java runtime. *
  4. The file or resources named META-INF/mailcap. *
  5. The file or resource named META-INF/mailcap.default * (usually found only in the activation.jar file). *
*

* (The current implementation looks for the mailcap file * in the Java runtime in the directory java.home/conf * if it exists, and otherwise in the directory * java.home/lib, where java.home is the value * of the "java.home" System property. Note that the "conf" directory was * introduced in JDK 9.) *

* Mailcap file format:

* * Mailcap files must conform to the mailcap * file specification (RFC 1524, A User Agent Configuration Mechanism * For Multimedia Mail Format Information). * The file format consists of entries corresponding to * particular MIME types. In general, the specification * specifies applications for clients to use when they * themselves cannot operate on the specified MIME type. The * MailcapCommandMap extends this specification by using a parameter mechanism * in mailcap files that allows JavaBeans(tm) components to be specified as * corresponding to particular commands for a MIME type.

* * When a mailcap file is * parsed, the MailcapCommandMap recognizes certain parameter signatures, * specifically those parameter names that begin with x-java-. * The MailcapCommandMap uses this signature to find * command entries for inclusion into its registries. * Parameter names with the form x-java-<name> * are read by the MailcapCommandMap as identifying a command * with the name name. When the name is * content-handler the MailcapCommandMap recognizes the class * signified by this parameter as a DataContentHandler. * All other commands are handled generically regardless of command * name. The command implementation is specified by a fully qualified * class name of a JavaBean(tm) component. For example; a command for viewing * some data can be specified as: x-java-view=com.foo.ViewBean.

* * When the command name is fallback-entry, the value of * the command may be true or false. An * entry for a MIME type that includes a parameter of * x-java-fallback-entry=true defines fallback commands * for that MIME type that will only be used if no non-fallback entry * can be found. For example, an entry of the form text/*; ; * x-java-fallback-entry=true; x-java-view=com.sun.TextViewer * specifies a view command to be used for any text MIME type. This * view command would only be used if a non-fallback view command for * the MIME type could not be found.

* * MailcapCommandMap aware mailcap files have the * following general form:

* * # Comments begin with a '#' and continue to the end of the line.
* <mime type>; ; <parameter list>
* # Where a parameter list consists of one or more parameters,
* # where parameters look like: x-java-view=com.sun.TextViewer
* # and a parameter list looks like:
* text/plain; ; x-java-view=com.sun.TextViewer; x-java-edit=com.sun.TextEdit *
* # Note that mailcap entries that do not contain 'x-java' parameters
* # and comply to RFC 1524 are simply ignored:
* image/gif; /usr/dt/bin/sdtimage %s
* * * * @author Bart Calder * @author Bill Shannon */ public class MailcapCommandMap extends CommandMap { /* * We manage a collection of databases, searched in order. */ private MailcapRegistry[] DB; private static final int PROG = 0; // programmatically added entries private static final String confDir; static { String dir = null; try { dir = AccessController.doPrivileged( new PrivilegedAction() { public String run() { String home = System.getProperty("java.home"); String newdir = home + File.separator + "conf"; File conf = new File(newdir); if (conf.exists()) return newdir + File.separator; else return home + File.separator + "lib" + File.separator; } }); } catch (Exception ex) { // ignore any exceptions } confDir = dir; } /** * The default Constructor. */ public MailcapCommandMap() { super(); List dbv = new ArrayList<>(5); // usually 5 or less databases MailcapRegistry mf = null; dbv.add(null); // place holder for PROG entry LogSupport.log("MailcapCommandMap: load HOME"); try { String user_home = System.getProperty("user.home"); if (user_home != null) { String path = user_home + File.separator + ".mailcap"; mf = loadFile(path); if (mf != null) dbv.add(mf); } } catch (SecurityException ex) {} LogSupport.log("MailcapCommandMap: load SYS"); try { // check system's home if (confDir != null) { mf = loadFile(confDir + "mailcap"); if (mf != null) dbv.add(mf); } } catch (SecurityException ex) {} LogSupport.log("MailcapCommandMap: load JAR"); // load from the app's jar file loadAllResources(dbv, "META-INF/mailcap"); LogSupport.log("MailcapCommandMap: load DEF"); mf = loadResource("/META-INF/mailcap.default"); if (mf != null) dbv.add(mf); DB = new MailcapRegistry[dbv.size()]; DB = dbv.toArray(DB); } /** * Load from the named resource. */ private MailcapRegistry loadResource(String name) { try (InputStream clis = SecuritySupport.getResourceAsStream(this.getClass(), name)) { if (clis != null) { MailcapRegistry mf = getImplementation().getByInputStream(clis); if (LogSupport.isLoggable()) LogSupport.log("MailcapCommandMap: successfully loaded " + "mailcap file: " + name); return mf; } else { if (LogSupport.isLoggable()) LogSupport.log("MailcapCommandMap: not loading " + "mailcap file: " + name); } } catch (IOException | SecurityException e) { if (LogSupport.isLoggable()) LogSupport.log("MailcapCommandMap: can't load " + name, e); } catch (NoSuchElementException | ServiceConfigurationError e) { if (LogSupport.isLoggable()) { LogSupport.log("Cannot find or load an implementation for MailcapRegistryProvider. " + "MailcapRegistry: can't load " + name, e); } } return null; } /** * Load all of the named resource. */ private void loadAllResources(List v, String name) { boolean anyLoaded = false; try { URL[] urls; ClassLoader cld = null; // First try the "application's" class loader. cld = SecuritySupport.getContextClassLoader(); if (cld == null) cld = this.getClass().getClassLoader(); if (cld != null) urls = SecuritySupport.getResources(cld, name); else urls = SecuritySupport.getSystemResources(name); if (urls != null) { if (LogSupport.isLoggable()) LogSupport.log("MailcapCommandMap: getResources"); for (int i = 0; i < urls.length; i++) { URL url = urls[i]; if (LogSupport.isLoggable()) LogSupport.log("MailcapCommandMap: URL " + url); try (InputStream clis = SecuritySupport.openStream(url)) { if (clis != null) { v.add(getImplementation().getByInputStream(clis)); anyLoaded = true; if (LogSupport.isLoggable()) LogSupport.log("MailcapCommandMap: " + "successfully loaded " + "mailcap file from URL: " + url); } else { if (LogSupport.isLoggable()) LogSupport.log("MailcapCommandMap: " + "not loading mailcap " + "file from URL: " + url); } } catch (IOException | SecurityException ioex) { if (LogSupport.isLoggable()) LogSupport.log("MailcapCommandMap: can't load " + url, ioex); } catch (NoSuchElementException | ServiceConfigurationError e) { if (LogSupport.isLoggable()) { LogSupport.log("Cannot find or load an implementation for MailcapRegistryProvider. " + "MailcapRegistry: can't load " + name, e); } } } } } catch (Exception ex) { if (LogSupport.isLoggable()) LogSupport.log("MailcapCommandMap: can't load " + name, ex); } // if failed to load anything, fall back to old technique, just in case if (!anyLoaded) { if (LogSupport.isLoggable()) LogSupport.log("MailcapCommandMap: !anyLoaded"); MailcapRegistry mf = loadResource("/" + name); if (mf != null) v.add(mf); } } /** * Load from the named file. */ private MailcapRegistry loadFile(String name) { MailcapRegistry mtf = null; try { mtf = getImplementation().getByFileName(name); } catch (IOException e) { if (LogSupport.isLoggable()) { LogSupport.log("MailcapRegistry: can't load from file - " + name, e); } } catch (NoSuchElementException | ServiceConfigurationError e) { if (LogSupport.isLoggable()) { LogSupport.log("Cannot find or load an implementation for MailcapRegistryProvider. " + "MailcapRegistry: can't load " + name, e); } } return mtf; } /** * Constructor that allows the caller to specify the path * of a mailcap file. * * @param fileName The name of the mailcap file to open * @exception IOException if the file can't be accessed */ public MailcapCommandMap(String fileName) throws IOException { this(); if (DB[PROG] == null) { try { DB[PROG] = getImplementation().getByFileName(fileName); } catch (NoSuchElementException | ServiceConfigurationError e) { String message = "Cannot find or load an implementation for MailcapRegistryProvider. " + "MailcapRegistry: can't load " + fileName; if (LogSupport.isLoggable()) { LogSupport.log(message, e); } throw new IOException(message, e); } } if (DB[PROG] != null && LogSupport.isLoggable()) { LogSupport.log("MailcapCommandMap: load PROG from " + fileName); } } /** * Constructor that allows the caller to specify an InputStream * containing a mailcap file. * * @param is InputStream of the mailcap file to open */ public MailcapCommandMap(InputStream is) { this(); if (DB[PROG] == null) { try { DB[PROG] = getImplementation().getByInputStream(is); } catch (IOException ex) { // XXX - should throw it } catch (NoSuchElementException | ServiceConfigurationError e) { if (LogSupport.isLoggable()) { LogSupport.log("Cannot find or load an implementation for MailcapRegistryProvider." + "MailcapRegistry: can't load InputStream", e); } } } if (DB[PROG] != null && LogSupport.isLoggable()) { LogSupport.log("MailcapCommandMap: load PROG"); } } /** * Get the preferred command list for a MIME Type. The MailcapCommandMap * searches the mailcap files as described above under * Mailcap file search order.

* * The result of the search is a proper subset of available * commands in all mailcap files known to this instance of * MailcapCommandMap. The first entry for a particular command * is considered the preferred command. * * @param mimeType the MIME type * @return the CommandInfo objects representing the preferred commands. */ public synchronized CommandInfo[] getPreferredCommands(String mimeType) { List cmdList = new ArrayList<>(); if (mimeType != null) mimeType = mimeType.toLowerCase(Locale.ENGLISH); for (int i = 0; i < DB.length; i++) { if (DB[i] == null) continue; Map> cmdMap = DB[i].getMailcapList(mimeType); if (cmdMap != null) appendPrefCmdsToList(cmdMap, cmdList); } // now add the fallback commands for (int i = 0; i < DB.length; i++) { if (DB[i] == null) continue; Map> cmdMap = DB[i].getMailcapFallbackList(mimeType); if (cmdMap != null) appendPrefCmdsToList(cmdMap, cmdList); } CommandInfo[] cmdInfos = new CommandInfo[cmdList.size()]; cmdInfos = cmdList.toArray(cmdInfos); return cmdInfos; } /** * Put the commands that are in the hash table, into the list. */ private void appendPrefCmdsToList(Map> cmdHash, List cmdList) { Iterator verb_enum = cmdHash.keySet().iterator(); while (verb_enum.hasNext()) { String verb = verb_enum.next(); if (!checkForVerb(cmdList, verb)) { List cmdList2 = cmdHash.get(verb); // get the list String className = cmdList2.get(0); cmdList.add(new CommandInfo(verb, className)); } } } /** * Check the cmdList to see if this command exists, return * true if the verb is there. */ private boolean checkForVerb(List cmdList, String verb) { Iterator ee = cmdList.iterator(); while (ee.hasNext()) { String enum_verb = (ee.next()).getCommandName(); if (enum_verb.equals(verb)) return true; } return false; } /** * Get all the available commands in all mailcap files known to * this instance of MailcapCommandMap for this MIME type. * * @param mimeType the MIME type * @return the CommandInfo objects representing all the commands. */ public synchronized CommandInfo[] getAllCommands(String mimeType) { List cmdList = new ArrayList<>(); if (mimeType != null) mimeType = mimeType.toLowerCase(Locale.ENGLISH); for (int i = 0; i < DB.length; i++) { if (DB[i] == null) continue; Map> cmdMap = DB[i].getMailcapList(mimeType); if (cmdMap != null) appendCmdsToList(cmdMap, cmdList); } // now add the fallback commands for (int i = 0; i < DB.length; i++) { if (DB[i] == null) continue; Map> cmdMap = DB[i].getMailcapFallbackList(mimeType); if (cmdMap != null) appendCmdsToList(cmdMap, cmdList); } CommandInfo[] cmdInfos = new CommandInfo[cmdList.size()]; cmdInfos = cmdList.toArray(cmdInfos); return cmdInfos; } /** * Put the commands that are in the hash table, into the list. */ private void appendCmdsToList(Map> typeHash, List cmdList) { Iterator verb_enum = typeHash.keySet().iterator(); while (verb_enum.hasNext()) { String verb = verb_enum.next(); List cmdList2 = typeHash.get(verb); Iterator cmd_enum = cmdList2.iterator(); while (cmd_enum.hasNext()) { String cmd = cmd_enum.next(); cmdList.add(new CommandInfo(verb, cmd)); // cmdList.add(0, new CommandInfo(verb, cmd)); } } } /** * Get the command corresponding to cmdName for the MIME type. * * @param mimeType the MIME type * @param cmdName the command name * @return the CommandInfo object corresponding to the command. */ public synchronized CommandInfo getCommand(String mimeType, String cmdName) { if (mimeType != null) mimeType = mimeType.toLowerCase(Locale.ENGLISH); for (int i = 0; i < DB.length; i++) { if (DB[i] == null) continue; Map> cmdMap = DB[i].getMailcapList(mimeType); if (cmdMap != null) { // get the cmd list for the cmd List v = cmdMap.get(cmdName); if (v != null) { String cmdClassName = v.get(0); if (cmdClassName != null) return new CommandInfo(cmdName, cmdClassName); } } } // now try the fallback list for (int i = 0; i < DB.length; i++) { if (DB[i] == null) continue; Map> cmdMap = DB[i].getMailcapFallbackList(mimeType); if (cmdMap != null) { // get the cmd list for the cmd List v = cmdMap.get(cmdName); if (v != null) { String cmdClassName = v.get(0); if (cmdClassName != null) return new CommandInfo(cmdName, cmdClassName); } } } return null; } /** * Add entries to the registry. Programmatically * added entries are searched before other entries.

* * The string that is passed in should be in mailcap * format. * * @param mail_cap a correctly formatted mailcap string */ public synchronized void addMailcap(String mail_cap) { // check to see if one exists LogSupport.log("MailcapCommandMap: add to PROG"); try { if (DB[PROG] == null) { DB[PROG] = getImplementation().getInMemory(); } DB[PROG].appendToMailcap(mail_cap); } catch (NoSuchElementException | ServiceConfigurationError e) { if (LogSupport.isLoggable()) { LogSupport.log("Cannot find or load an implementation for MailcapRegistryProvider. " + "MailcapRegistry: can't load", e); } throw e; } } /** * Return the DataContentHandler for the specified MIME type. * * @param mimeType the MIME type * @return the DataContentHandler */ public synchronized DataContentHandler createDataContentHandler( String mimeType) { if (LogSupport.isLoggable()) LogSupport.log( "MailcapCommandMap: createDataContentHandler for " + mimeType); if (mimeType != null) mimeType = mimeType.toLowerCase(Locale.ENGLISH); for (int i = 0; i < DB.length; i++) { if (DB[i] == null) continue; if (LogSupport.isLoggable()) LogSupport.log(" search DB #" + i); Map> cmdMap = DB[i].getMailcapList(mimeType); if (cmdMap != null) { List v = cmdMap.get("content-handler"); if (v != null) { String name = v.get(0); DataContentHandler dch = getDataContentHandler(name); if (dch != null) return dch; } } } // now try the fallback entries for (int i = 0; i < DB.length; i++) { if (DB[i] == null) continue; if (LogSupport.isLoggable()) LogSupport.log(" search fallback DB #" + i); Map> cmdMap = DB[i].getMailcapFallbackList(mimeType); if (cmdMap != null) { List v = cmdMap.get("content-handler"); if (v != null) { String name = v.get(0); DataContentHandler dch = getDataContentHandler(name); if (dch != null) return dch; } } } return null; } private DataContentHandler getDataContentHandler(String name) { if (LogSupport.isLoggable()) LogSupport.log(" got content-handler"); if (LogSupport.isLoggable()) LogSupport.log(" class " + name); try { ClassLoader cld = null; // First try the "application's" class loader. cld = SecuritySupport.getContextClassLoader(); if (cld == null) cld = this.getClass().getClassLoader(); Class cl = null; try { cl = cld.loadClass(name); } catch (Exception ex) { // if anything goes wrong, do it the old way cl = Class.forName(name); } if (cl != null) // XXX - always true? return (DataContentHandler) cl.getConstructor().newInstance(); } catch (ReflectiveOperationException e) { if (LogSupport.isLoggable()) LogSupport.log("Can't load DCH " + name, e); } return null; } /** * Get all the MIME types known to this command map. * * @return array of MIME types as strings * @since JAF 1.1 */ public synchronized String[] getMimeTypes() { List mtList = new ArrayList<>(); for (int i = 0; i < DB.length; i++) { if (DB[i] == null) continue; String[] ts = DB[i].getMimeTypes(); if (ts != null) { for (int j = 0; j < ts.length; j++) { // eliminate duplicates if (!mtList.contains(ts[j])) mtList.add(ts[j]); } } } String[] mts = new String[mtList.size()]; mts = mtList.toArray(mts); return mts; } /** * 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. * * @param mimeType the MIME type * @return array of native command entries * @since JAF 1.1 */ public synchronized String[] getNativeCommands(String mimeType) { List cmdList = new ArrayList<>(); if (mimeType != null) mimeType = mimeType.toLowerCase(Locale.ENGLISH); for (int i = 0; i < DB.length; i++) { if (DB[i] == null) continue; String[] cmds = DB[i].getNativeCommands(mimeType); if (cmds != null) { for (int j = 0; j < cmds.length; j++) { // eliminate duplicates if (!cmdList.contains(cmds[j])) cmdList.add(cmds[j]); } } } String[] cmds = new String[cmdList.size()]; cmds = cmdList.toArray(cmds); return cmds; } private MailcapRegistryProvider getImplementation() { if (System.getSecurityManager() != null) { return AccessController.doPrivileged(new PrivilegedAction() { public MailcapRegistryProvider run() { return FactoryFinder.find(MailcapRegistryProvider.class, null, false); } }); } else { return FactoryFinder.find(MailcapRegistryProvider.class, null, false); } } /* * for debugging... * public static void main(String[] argv) throws Exception { MailcapCommandMap map = new MailcapCommandMap(); CommandInfo[] cmdInfo; cmdInfo = map.getPreferredCommands(argv[0]); System.out.println("Preferred Commands:"); for (int i = 0; i < cmdInfo.length; i++) System.out.println("Command " + cmdInfo[i].getCommandName() + " [" + cmdInfo[i].getCommandClass() + "]"); cmdInfo = map.getAllCommands(argv[0]); System.out.println(); System.out.println("All Commands:"); for (int i = 0; i < cmdInfo.length; i++) System.out.println("Command " + cmdInfo[i].getCommandName() + " [" + cmdInfo[i].getCommandClass() + "]"); DataContentHandler dch = map.createDataContentHandler(argv[0]); if (dch != null) System.out.println("DataContentHandler " + dch.getClass().toString()); System.exit(0); } */ } jaf-api-2.1.1/api/src/main/java/jakarta/activation/MailcapRegistry.java000066400000000000000000000051421435131260600257520ustar00rootroot00000000000000/* * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import java.util.List; import java.util.Map; /** * The MailcapRegistry interface is implemented by objects that can * be used to store and retrieve MailcapEntries. *

* Application must implement {@link jakarta.activation.spi.MailcapRegistryProvider} * to create new instances of the MailcapRegistry. Implementation of the MailcapRegistry * can store MailcapEntries in different ways and that storage must be accessible through the * {@link jakarta.activation.spi.MailcapRegistryProvider} methods. * Implementation of the MailcapRegistry must contain in-memory storage for MailcapEntries. */ public interface MailcapRegistry { /** * Get the Map of MailcapEntries based on the MIME type. * *

* Semantics: First check for the literal mime type, * if that fails looks for wildcard <type>/\* and return that. * Return the list of all that hit. * * @param mime_type the MIME type * @return the map of MailcapEntries */ Map> getMailcapList(String mime_type); /** * Get the Map of fallback MailcapEntries based on the MIME type. * *

* Semantics: First check for the literal mime type, * if that fails looks for wildcard <type>/\* and return that. * Return the list of all that hit. * * @param mime_type the MIME type * @return the map of fallback MailcapEntries */ Map> getMailcapFallbackList(String mime_type); /** * Return all the MIME types known to this mailcap file. * * @return a String array of the MIME types */ String[] getMimeTypes(); /** * Return all the native comands for the given MIME type. * * @param mime_type the MIME type * @return a String array of the commands */ String[] getNativeCommands(String mime_type); /** * appendToMailcap: Append to this Mailcap DB, use the mailcap * format: * Comment == "# comment string" * Entry == "mimetype; javabeanclass" * * Example: * # this is a comment * image/gif jaf.viewers.ImageViewer * * @param mail_cap the mailcap string */ void appendToMailcap(String mail_cap); } jaf-api-2.1.1/api/src/main/java/jakarta/activation/MimeType.java000066400000000000000000000246641435131260600244160ustar00rootroot00000000000000/* * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import java.io.*; import java.util.Locale; /** * A Multipurpose Internet Mail Extension (MIME) type, as defined * in RFC 2045 and 2046. */ public class MimeType implements Externalizable { private String primaryType; private String subType; private MimeTypeParameterList parameters; private static final long serialVersionUID = 7548163901563814301L; /** * A string that holds all the special chars. */ private static final String TSPECIALS = "()<>@,;:/[]?=\\\""; /** * Default constructor. */ public MimeType() { primaryType = "application"; subType = "*"; parameters = new MimeTypeParameterList(); } /** * Constructor that builds a MimeType from a String. * * @param rawdata the MIME type string * @exception MimeTypeParseException if the MIME type can't be parsed */ public MimeType(String rawdata) throws MimeTypeParseException { parse(rawdata); } /** * Constructor that builds a MimeType with the given primary and sub type * but has an empty parameter list. * * @param primary the primary MIME type * @param sub the MIME sub-type * @exception MimeTypeParseException if the primary type or subtype * is not a valid token */ public MimeType(String primary, String sub) throws MimeTypeParseException { // check to see if primary is valid if (isValidToken(primary)) { primaryType = primary.toLowerCase(Locale.ENGLISH); } else { throw new MimeTypeParseException("Primary type is invalid."); } // check to see if sub is valid if (isValidToken(sub)) { subType = sub.toLowerCase(Locale.ENGLISH); } else { throw new MimeTypeParseException("Sub type is invalid."); } parameters = new MimeTypeParameterList(); } /** * A routine for parsing the MIME type out of a String. */ private void parse(String rawdata) throws MimeTypeParseException { int slashIndex = rawdata.indexOf('/'); int semIndex = rawdata.indexOf(';'); if ((slashIndex < 0) && (semIndex < 0)) { // neither character is present, so treat it // as an error throw new MimeTypeParseException("Unable to find a sub type."); } else if ((slashIndex < 0) && (semIndex >= 0)) { // we have a ';' (and therefore a parameter list), // but no '/' indicating a sub type is present throw new MimeTypeParseException("Unable to find a sub type."); } else if ((slashIndex >= 0) && (semIndex < 0)) { // we have a primary and sub type but no parameter list primaryType = rawdata.substring(0, slashIndex).trim(). toLowerCase(Locale.ENGLISH); subType = rawdata.substring(slashIndex + 1).trim(). toLowerCase(Locale.ENGLISH); parameters = new MimeTypeParameterList(); } else if (slashIndex < semIndex) { // we have all three items in the proper sequence primaryType = rawdata.substring(0, slashIndex).trim(). toLowerCase(Locale.ENGLISH); subType = rawdata.substring(slashIndex + 1, semIndex).trim(). toLowerCase(Locale.ENGLISH); parameters = new MimeTypeParameterList(rawdata.substring(semIndex)); } else { // we have a ';' lexically before a '/' which means we // have a primary type and a parameter list but no sub type throw new MimeTypeParseException("Unable to find a sub type."); } // now validate the primary and sub types // check to see if primary is valid if (!isValidToken(primaryType)) throw new MimeTypeParseException("Primary type is invalid."); // check to see if sub is valid if (!isValidToken(subType)) throw new MimeTypeParseException("Sub type is invalid."); } /** * Retrieve the primary type of this object. * * @return the primary MIME type */ public String getPrimaryType() { return primaryType; } /** * Set the primary type for this object to the given String. * * @param primary the primary MIME type * @exception MimeTypeParseException if the primary type * is not a valid token */ public void setPrimaryType(String primary) throws MimeTypeParseException { // check to see if primary is valid if (!isValidToken(primaryType)) throw new MimeTypeParseException("Primary type is invalid."); primaryType = primary.toLowerCase(Locale.ENGLISH); } /** * Retrieve the subtype of this object. * * @return the MIME subtype */ public String getSubType() { return subType; } /** * Set the subtype for this object to the given String. * * @param sub the MIME subtype * @exception MimeTypeParseException if the subtype * is not a valid token */ public void setSubType(String sub) throws MimeTypeParseException { // check to see if sub is valid if (!isValidToken(subType)) throw new MimeTypeParseException("Sub type is invalid."); subType = sub.toLowerCase(Locale.ENGLISH); } /** * Retrieve this object's parameter list. * * @return a MimeTypeParameterList object representing the parameters */ public MimeTypeParameterList getParameters() { return parameters; } /** * Retrieve the value associated with the given name, or null if there * is no current association. * * @param name the parameter name * @return the paramter's value */ public String getParameter(String name) { return parameters.get(name); } /** * Set the value to be associated with the given name, replacing * any previous association. * * @param name the parameter name * @param value the paramter's value */ public void setParameter(String name, String value) { parameters.set(name, value); } /** * Remove any value associated with the given name. * * @param name the parameter name */ public void removeParameter(String name) { parameters.remove(name); } /** * Return the String representation of this object. */ public String toString() { return getBaseType() + parameters.toString(); } /** * Return a String representation of this object * without the parameter list. * * @return the MIME type and sub-type */ public String getBaseType() { return primaryType + "/" + subType; } /** * Determine if the primary and sub type of this object is * the same as what is in the given type. * * @param type the MimeType object to compare with * @return true if they match */ public boolean match(MimeType type) { return primaryType.equals(type.getPrimaryType()) && (subType.equals("*") || type.getSubType().equals("*") || (subType.equals(type.getSubType()))); } /** * Determine if the primary and sub type of this object is * the same as the content type described in rawdata. * * @param rawdata the MIME type string to compare with * @return true if they match * @exception MimeTypeParseException if the MIME type can't be parsed */ public boolean match(String rawdata) throws MimeTypeParseException { return match(new MimeType(rawdata)); } /** * The object implements the writeExternal method to save its contents * by calling the methods of DataOutput for its primitive values or * calling the writeObject method of ObjectOutput for objects, strings * and arrays. * * @param out the ObjectOutput object to write to * @exception IOException Includes any I/O exceptions that may occur */ public void writeExternal(ObjectOutput out) throws IOException { out.writeUTF(toString()); out.flush(); } /** * The object implements the readExternal method to restore its * contents by calling the methods of DataInput for primitive * types and readObject for objects, strings and arrays. The * readExternal method must read the values in the same sequence * and with the same types as were written by writeExternal. * * @param in the ObjectInput object to read from * @exception ClassNotFoundException If the class for an object being * restored cannot be found. */ public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { try { parse(in.readUTF()); } catch (MimeTypeParseException e) { throw new IOException(e.toString()); } } // below here be scary parsing related things /** * Determine whether or not a given character belongs to a legal token. */ private static boolean isTokenChar(char c) { return ((c > 040) && (c < 0177)) && (TSPECIALS.indexOf(c) < 0); } /** * Determine whether or not a given string is a legal token. */ private boolean isValidToken(String s) { int len = s.length(); if (len > 0) { for (int i = 0; i < len; ++i) { char c = s.charAt(i); if (!isTokenChar(c)) { return false; } } return true; } else { return false; } } /** * A simple parser test, * for debugging... * public static void main(String[] args) throws MimeTypeParseException, IOException { for (int i = 0; i < args.length; ++i) { System.out.println("Original: " + args[i]); MimeType type = new MimeType(args[i]); System.out.println("Short: " + type.getBaseType()); System.out.println("Parsed: " + type.toString()); System.out.println(); } } */ } jaf-api-2.1.1/api/src/main/java/jakarta/activation/MimeTypeEntry.java000066400000000000000000000022071435131260600254250ustar00rootroot00000000000000/* * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; /** * Represents mapping between the file extension and the MIME type string. */ public class MimeTypeEntry { private String type; private String extension; /** * Create new {@code MimeTypeEntry} * * @param mime_type the MIME type string * @param file_ext the file extension */ public MimeTypeEntry(String mime_type, String file_ext) { type = mime_type; extension = file_ext; } /** * @return the MIME type string */ public String getMIMEType() { return type; } /** * @return the file extension */ public String getFileExtension() { return extension; } @Override public String toString() { return "MIMETypeEntry: " + type + ", " + extension; } } jaf-api-2.1.1/api/src/main/java/jakarta/activation/MimeTypeParameterList.java000066400000000000000000000214051435131260600271010ustar00rootroot00000000000000/* * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import java.util.Hashtable; import java.util.Enumeration; import java.util.Locale; /** * A parameter list of a MimeType * as defined in RFC 2045 and 2046. The Primary type of the * object must already be stripped off. * * @see jakarta.activation.MimeType */ public class MimeTypeParameterList { private Hashtable parameters; /** * A string that holds all the special chars. */ private static final String TSPECIALS = "()<>@,;:/[]?=\\\""; /** * Default constructor. */ public MimeTypeParameterList() { parameters = new Hashtable<>(); } /** * Constructs a new MimeTypeParameterList with the passed in data. * * @param parameterList an RFC 2045, 2046 compliant parameter list. * @exception MimeTypeParseException if the MIME type can't be parsed */ public MimeTypeParameterList(String parameterList) throws MimeTypeParseException { parameters = new Hashtable<>(); // now parse rawdata parse(parameterList); } /** * A routine for parsing the parameter list out of a String. * * @param parameterList an RFC 2045, 2046 compliant parameter list. * @exception MimeTypeParseException if the MIME type can't be parsed */ protected void parse(String parameterList) throws MimeTypeParseException { if (parameterList == null) return; int length = parameterList.length(); if (length <= 0) return; int i; char c; for (i = skipWhiteSpace(parameterList, 0); i < length && (c = parameterList.charAt(i)) == ';'; i = skipWhiteSpace(parameterList, i)) { int lastIndex; String name; String value; // eat the ';' i++; // now parse the parameter name // skip whitespace i = skipWhiteSpace(parameterList, i); // tolerate trailing semicolon, even though it violates the spec if (i >= length) return; // find the end of the token char run lastIndex = i; while ((i < length) && isTokenChar(parameterList.charAt(i))) i++; name = parameterList.substring(lastIndex, i). toLowerCase(Locale.ENGLISH); // now parse the '=' that separates the name from the value i = skipWhiteSpace(parameterList, i); if (i >= length || parameterList.charAt(i) != '=') throw new MimeTypeParseException( "Couldn't find the '=' that separates a " + "parameter name from its value."); // eat it and parse the parameter value i++; i = skipWhiteSpace(parameterList, i); if (i >= length) throw new MimeTypeParseException( "Couldn't find a value for parameter named " + name); // now find out whether or not we have a quoted value c = parameterList.charAt(i); if (c == '"') { // yup it's quoted so eat it and capture the quoted string i++; if (i >= length) throw new MimeTypeParseException( "Encountered unterminated quoted parameter value."); lastIndex = i; // find the next unescaped quote while (i < length) { c = parameterList.charAt(i); if (c == '"') break; if (c == '\\') { // found an escape sequence // so skip this and the // next character i++; } i++; } if (c != '"') throw new MimeTypeParseException( "Encountered unterminated quoted parameter value."); value = unquote(parameterList.substring(lastIndex, i)); // eat the quote i++; } else if (isTokenChar(c)) { // nope it's an ordinary token so it // ends with a non-token char lastIndex = i; while (i < length && isTokenChar(parameterList.charAt(i))) i++; value = parameterList.substring(lastIndex, i); } else { // it ain't a value throw new MimeTypeParseException( "Unexpected character encountered at index " + i); } // now put the data into the hashtable parameters.put(name, value); } if (i < length) { throw new MimeTypeParseException( "More characters encountered in input than expected."); } } /** * Return the number of name-value pairs in this list. * * @return the number of parameters */ public int size() { return parameters.size(); } /** * Determine whether or not this list is empty. * * @return true if there are no parameters */ public boolean isEmpty() { return parameters.isEmpty(); } /** * Retrieve the value associated with the given name, or null if there * is no current association. * * @param name the parameter name * @return the parameter's value */ public String get(String name) { return parameters.get(name.trim().toLowerCase(Locale.ENGLISH)); } /** * Set the value to be associated with the given name, replacing * any previous association. * * @param name the parameter name * @param value the parameter's value */ public void set(String name, String value) { parameters.put(name.trim().toLowerCase(Locale.ENGLISH), value); } /** * Remove any value associated with the given name. * * @param name the parameter name */ public void remove(String name) { parameters.remove(name.trim().toLowerCase(Locale.ENGLISH)); } /** * Retrieve an enumeration of all the names in this list. * * @return an enumeration of all parameter names */ public Enumeration getNames() { return parameters.keys(); } /** * Return a string representation of this object. */ public String toString() { StringBuffer buffer = new StringBuffer(); buffer.ensureCapacity(parameters.size() * 16); // heuristic: 8 characters per field Enumeration keys = parameters.keys(); while (keys.hasMoreElements()) { String key = keys.nextElement(); buffer.append("; "); buffer.append(key); buffer.append('='); buffer.append(quote(parameters.get(key))); } return buffer.toString(); } // below here be scary parsing related things /** * Determine whether or not a given character belongs to a legal token. */ private static boolean isTokenChar(char c) { return ((c > 040) && (c < 0177)) && (TSPECIALS.indexOf(c) < 0); } /** * return the index of the first non white space character in * rawdata at or after index i. */ private static int skipWhiteSpace(String rawdata, int i) { int length = rawdata.length(); while ((i < length) && Character.isWhitespace(rawdata.charAt(i))) i++; return i; } /** * A routine that knows how and when to quote and escape the given value. */ private static String quote(String value) { boolean needsQuotes = false; // check to see if we actually have to quote this thing int length = value.length(); for (int i = 0; (i < length) && !needsQuotes; i++) { needsQuotes = !isTokenChar(value.charAt(i)); } if (needsQuotes) { StringBuffer buffer = new StringBuffer(); buffer.ensureCapacity((int)(length * 1.5)); // add the initial quote buffer.append('"'); // add the properly escaped text for (int i = 0; i < length; ++i) { char c = value.charAt(i); if ((c == '\\') || (c == '"')) buffer.append('\\'); buffer.append(c); } // add the closing quote buffer.append('"'); return buffer.toString(); } else { return value; } } /** * A routine that knows how to strip the quotes and * escape sequences from the given value. */ private static String unquote(String value) { int valueLength = value.length(); StringBuffer buffer = new StringBuffer(); buffer.ensureCapacity(valueLength); boolean escaped = false; for (int i = 0; i < valueLength; ++i) { char currentChar = value.charAt(i); if (!escaped && (currentChar != '\\')) { buffer.append(currentChar); } else if (escaped) { buffer.append(currentChar); escaped = false; } else { escaped = true; } } return buffer.toString(); } } jaf-api-2.1.1/api/src/main/java/jakarta/activation/MimeTypeParseException.java000066400000000000000000000016331435131260600272570ustar00rootroot00000000000000/* * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; /** * A class to encapsulate MimeType parsing related exceptions. */ public class MimeTypeParseException extends Exception { private static final long serialVersionUID = 1855296571002626216L; /** * Constructs a MimeTypeParseException with no specified detail message. */ public MimeTypeParseException() { super(); } /** * Constructs a MimeTypeParseException with the specified detail message. * * @param s the detail message. */ public MimeTypeParseException(String s) { super(s); } } jaf-api-2.1.1/api/src/main/java/jakarta/activation/MimeTypeRegistry.java000066400000000000000000000033201435131260600261310ustar00rootroot00000000000000/* * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; /** * The MimeTypeRegistry interface is implemented by objects that can * be used to store and retrieve MimeTypeEntries. *

* Application must implement {@link jakarta.activation.spi.MimeTypeRegistryProvider} * to create new instances of the MimeTypeRegistry. Implementation of the MimeTypeRegistry * can store MimeTypeEntries in different ways and that storage must be accessible through the * {@link jakarta.activation.spi.MimeTypeRegistryProvider} methods. * Implementation of the MimeTypeRegistry must contain in-memory storage for MimeTypeEntries. */ public interface MimeTypeRegistry { /** * get the MimeTypeEntry based on the file extension * * @param file_ext the file extension * @return the MimeTypeEntry */ MimeTypeEntry getMimeTypeEntry(String file_ext); /** * Get the MIME type string corresponding to the file extension. * * @param file_ext the file extension * @return the MIME type string */ default String getMIMETypeString(String file_ext) { MimeTypeEntry entry = this.getMimeTypeEntry(file_ext); if (entry != null) { return entry.getMIMEType(); } return null; } /** * Appends string of entries to the types registry * * @param mime_types the mime.types string */ void appendToRegistry(String mime_types); }jaf-api-2.1.1/api/src/main/java/jakarta/activation/MimetypesFileTypeMap.java000066400000000000000000000367261435131260600267430ustar00rootroot00000000000000/* * Copyright (c) 1997, 2022 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import jakarta.activation.spi.MimeTypeRegistryProvider; import java.io.*; import java.net.*; import java.util.*; import java.security.AccessController; import java.security.PrivilegedAction; /** * This class extends FileTypeMap and provides data typing of files * via their file extension. It uses the .mime.types format.

* * MIME types file search order:

* The MimetypesFileTypeMap looks in various places in the user's * system for MIME types file entries. When requests are made * to search for MIME types in the MimetypesFileTypeMap, it searches * MIME types files in the following order: *

    *
  1. Programmatically added entries to the MimetypesFileTypeMap instance. *
  2. The file .mime.types in the user's home directory. *
  3. The file mime.types in the Java runtime. *
  4. The file or resources named META-INF/mime.types. *
  5. The file or resource named META-INF/mimetypes.default * (usually found only in the activation.jar file). *
*

* (The current implementation looks for the mime.types file * in the Java runtime in the directory java.home/conf * if it exists, and otherwise in the directory * java.home/lib, where java.home is the value * of the "java.home" System property. Note that the "conf" directory was * introduced in JDK 9.) *

* MIME types file format:

* * * # comments begin with a '#'
* # the format is <mime type> <space separated file extensions>
* # for example:
* text/plain txt text TXT
* # this would map file.txt, file.text, and file.TXT to
* # the mime type "text/plain"
* * * @author Bart Calder * @author Bill Shannon */ public class MimetypesFileTypeMap extends FileTypeMap { /* * We manage a collection of databases, searched in order. */ private MimeTypeRegistry[] DB; private static final int PROG = 0; // programmatically added entries private static final String defaultType = "application/octet-stream"; private static final String confDir; static { String dir = null; try { dir = AccessController.doPrivileged( new PrivilegedAction() { public String run() { String home = System.getProperty("java.home"); String newdir = home + File.separator + "conf"; File conf = new File(newdir); if (conf.exists()) return newdir + File.separator; else return home + File.separator + "lib" + File.separator; } }); } catch (Exception ex) { if (LogSupport.isLoggable()) LogSupport.log("Exception during MimetypesFileTypeMap class loading", ex); } confDir = dir; } /** * The default constructor. */ public MimetypesFileTypeMap() { Vector dbv = new Vector<>(5); // usually 5 or less databases MimeTypeRegistry mf = null; dbv.addElement(null); // place holder for PROG entry LogSupport.log("MimetypesFileTypeMap: load HOME"); try { String user_home = System.getProperty("user.home"); if (user_home != null) { String path = user_home + File.separator + ".mime.types"; mf = loadFile(path); if (mf != null) dbv.addElement(mf); } } catch (SecurityException ex) { if (LogSupport.isLoggable()) LogSupport.log("Exception during MimetypesFileTypeMap class instantiation", ex); } LogSupport.log("MimetypesFileTypeMap: load SYS"); try { // check system's home if (confDir != null) { mf = loadFile(confDir + "mime.types"); if (mf != null) dbv.addElement(mf); } } catch (SecurityException ex) { if (LogSupport.isLoggable()) LogSupport.log("Exception during MimetypesFileTypeMap class instantiation", ex); } LogSupport.log("MimetypesFileTypeMap: load JAR"); // load from the app's jar file loadAllResources(dbv, "META-INF/mime.types"); LogSupport.log("MimetypesFileTypeMap: load DEF"); mf = loadResource("/META-INF/mimetypes.default"); if (mf != null) dbv.addElement(mf); DB = new MimeTypeRegistry[dbv.size()]; dbv.copyInto(DB); } /** * Load from the named resource. */ private MimeTypeRegistry loadResource(String name) { InputStream clis = null; try { clis = SecuritySupport.getResourceAsStream(this.getClass(), name); if (clis != null) { MimeTypeRegistry mf = getImplementation().getByInputStream(clis); if (LogSupport.isLoggable()) LogSupport.log("MimetypesFileTypeMap: successfully " + "loaded mime types file: " + name); return mf; } else { if (LogSupport.isLoggable()) LogSupport.log("MimetypesFileTypeMap: not loading " + "mime types file: " + name); } } catch (IOException e) { if (LogSupport.isLoggable()) LogSupport.log("MimetypesFileTypeMap: can't load " + name, e); } catch (SecurityException sex) { if (LogSupport.isLoggable()) LogSupport.log("MimetypesFileTypeMap: can't load " + name, sex); } catch (NoSuchElementException | ServiceConfigurationError e) { if (LogSupport.isLoggable()) { LogSupport.log("Cannot find or load an implementation for MimeTypeRegistryProvider." + "MimeTypeRegistry: can't load " + name, e); } } finally { try { if (clis != null) clis.close(); } catch (IOException ex) { if (LogSupport.isLoggable()) LogSupport.log("InputStream cannot be close for " + name, ex); } } return null; } /** * Load all of the named resource. */ private void loadAllResources(Vector v, String name) { boolean anyLoaded = false; try { URL[] urls; ClassLoader cld = null; // First try the "application's" class loader. cld = SecuritySupport.getContextClassLoader(); if (cld == null) cld = this.getClass().getClassLoader(); if (cld != null) urls = SecuritySupport.getResources(cld, name); else urls = SecuritySupport.getSystemResources(name); if (urls != null) { if (LogSupport.isLoggable()) LogSupport.log("MimetypesFileTypeMap: getResources"); for (int i = 0; i < urls.length; i++) { URL url = urls[i]; InputStream clis = null; if (LogSupport.isLoggable()) LogSupport.log("MimetypesFileTypeMap: URL " + url); try { clis = SecuritySupport.openStream(url); if (clis != null) { v.addElement( getImplementation().getByInputStream(clis) ); anyLoaded = true; if (LogSupport.isLoggable()) LogSupport.log("MimetypesFileTypeMap: " + "successfully loaded " + "mime types from URL: " + url); } else { if (LogSupport.isLoggable()) LogSupport.log("MimetypesFileTypeMap: " + "not loading " + "mime types from URL: " + url); } } catch (IOException ioex) { if (LogSupport.isLoggable()) LogSupport.log("MimetypesFileTypeMap: can't load " + url, ioex); } catch (SecurityException sex) { if (LogSupport.isLoggable()) LogSupport.log("MimetypesFileTypeMap: can't load " + url, sex); } catch (NoSuchElementException | ServiceConfigurationError e) { if (LogSupport.isLoggable()) { LogSupport.log("Cannot find or load an implementation for MimeTypeRegistryProvider." + "MimeTypeRegistry: can't load " + url, e); } } finally { try { if (clis != null) clis.close(); } catch (IOException cex) { if (LogSupport.isLoggable()) LogSupport.log("InputStream cannot be close for " + name, cex); } } } } } catch (Exception ex) { if (LogSupport.isLoggable()) LogSupport.log("MimetypesFileTypeMap: can't load " + name, ex); } // if failed to load anything, fall back to old technique, just in case if (!anyLoaded) { LogSupport.log("MimetypesFileTypeMap: !anyLoaded"); MimeTypeRegistry mf = loadResource("/" + name); if (mf != null) v.addElement(mf); } } /** * Load the named file. */ private MimeTypeRegistry loadFile(String name) { MimeTypeRegistry mtf = null; try { mtf = getImplementation().getByFileName(name); } catch (IOException e) { if (LogSupport.isLoggable()) { LogSupport.log("MimeTypeRegistry: can't load from file - " + name, e); } } catch (NoSuchElementException | ServiceConfigurationError e) { if (LogSupport.isLoggable()) { LogSupport.log("Cannot find or load an implementation for MimeTypeRegistryProvider." + "MimeTypeRegistry: can't load " + name, e); } } return mtf; } /** * Construct a MimetypesFileTypeMap with programmatic entries * added from the named file. * * @param mimeTypeFileName the file name * @exception IOException for errors reading the file */ public MimetypesFileTypeMap(String mimeTypeFileName) throws IOException { this(); try { DB[PROG] = getImplementation().getByFileName(mimeTypeFileName); } catch (NoSuchElementException | ServiceConfigurationError e) { String errorMessage = "Cannot find or load an implementation for MimeTypeRegistryProvider." + "MimeTypeRegistry: can't load " + mimeTypeFileName; if (LogSupport.isLoggable()) { LogSupport.log(errorMessage, e); } throw new IOException(errorMessage, e); } } /** * Construct a MimetypesFileTypeMap with programmatic entries * added from the InputStream. * * @param is the input stream to read from */ public MimetypesFileTypeMap(InputStream is) { this(); try { DB[PROG] = getImplementation().getByInputStream(is); } catch (IOException ex) { // XXX - really should throw it } catch (NoSuchElementException | ServiceConfigurationError e) { if (LogSupport.isLoggable()) { LogSupport.log("Cannot find or load an implementation for MimeTypeRegistryProvider." + "MimeTypeRegistry: can't load InputStream", e); } } } /** * Prepend the MIME type values to the registry. * * @param mime_types A .mime.types formatted string of entries. */ public synchronized void addMimeTypes(String mime_types) { try { // check to see if we have created the registry if (DB[PROG] == null) { DB[PROG] = getImplementation().getInMemory(); } DB[PROG].appendToRegistry(mime_types); } catch (NoSuchElementException | ServiceConfigurationError e) { if (LogSupport.isLoggable()) { LogSupport.log("Cannot find or load an implementation for MimeTypeRegistryProvider." + "MimeTypeRegistry: can't add " + mime_types, e); } throw e; } } /** * Return the MIME type of the file object. * The implementation in this class calls * getContentType(f.getName()). * * @param f the file * @return the file's MIME type */ public String getContentType(File f) { return this.getContentType(f.getName()); } /** * Return the MIME type based on the specified file name. * The MIME type entries are searched as described above under * MIME types file search order. * If no entry is found, the type "application/octet-stream" is returned. * * @param filename the file name * @return the file's MIME type */ public synchronized String getContentType(String filename) { int dot_pos = filename.lastIndexOf("."); // period index if (dot_pos < 0) return defaultType; String file_ext = filename.substring(dot_pos + 1); if (file_ext.length() == 0) return defaultType; for (int i = 0; i < DB.length; i++) { if (DB[i] == null) continue; String result = DB[i].getMIMETypeString(file_ext); if (result != null) return result; } return defaultType; } private MimeTypeRegistryProvider getImplementation() { if (System.getSecurityManager() != null) { return AccessController.doPrivileged(new PrivilegedAction() { public MimeTypeRegistryProvider run() { return FactoryFinder.find(MimeTypeRegistryProvider.class, null, false); } }); } else { return FactoryFinder.find(MimeTypeRegistryProvider.class, null, false); } } /* * for debugging... * public static void main(String[] argv) throws Exception { MimetypesFileTypeMap map = new MimetypesFileTypeMap(); System.out.println("File " + argv[0] + " has MIME type " + map.getContentType(argv[0])); System.exit(0); } */ } jaf-api-2.1.1/api/src/main/java/jakarta/activation/SecuritySupport.java000066400000000000000000000055761435131260600260720ustar00rootroot00000000000000/* * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import java.security.*; import java.net.*; import java.io.*; import java.util.*; /** * Security related methods that only work on J2SE 1.2 and newer. */ class SecuritySupport { private SecuritySupport() { // private constructor, can't create an instance } public static ClassLoader getContextClassLoader() { return AccessController.doPrivileged(new PrivilegedAction() { public ClassLoader run() { ClassLoader cl = null; try { cl = Thread.currentThread().getContextClassLoader(); } catch (SecurityException ex) { } return cl; } }); } public static InputStream getResourceAsStream(final Class c, final String name) throws IOException { try { return AccessController.doPrivileged(new PrivilegedExceptionAction() { public InputStream run() throws IOException { return c.getResourceAsStream(name); } }); } catch (PrivilegedActionException e) { throw (IOException)e.getException(); } } public static URL[] getResources(final ClassLoader cl, final String name) { return AccessController.doPrivileged(new PrivilegedAction() { public URL[] run() { URL[] ret = null; try { List v = new ArrayList<>(); Enumeration e = cl.getResources(name); while (e != null && e.hasMoreElements()) { URL url = e.nextElement(); if (url != null) v.add(url); } if (v.size() > 0) { ret = new URL[v.size()]; ret = v.toArray(ret); } } catch (IOException ioex) { } catch (SecurityException ex) { } return ret; } }); } public static URL[] getSystemResources(final String name) { return AccessController.doPrivileged(new PrivilegedAction() { public URL[] run() { URL[] ret = null; try { List v = new ArrayList<>(); Enumeration e = ClassLoader.getSystemResources(name); while (e != null && e.hasMoreElements()) { URL url = e.nextElement(); if (url != null) v.add(url); } if (v.size() > 0) { ret = new URL[v.size()]; ret = v.toArray(ret); } } catch (IOException ioex) { } catch (SecurityException ex) { } return ret; } }); } public static InputStream openStream(final URL url) throws IOException { try { return AccessController.doPrivileged(new PrivilegedExceptionAction() { public InputStream run() throws IOException { return url.openStream(); } }); } catch (PrivilegedActionException e) { throw (IOException)e.getException(); } } } jaf-api-2.1.1/api/src/main/java/jakarta/activation/ServiceLoaderUtil.java000066400000000000000000000105561435131260600262450ustar00rootroot00000000000000/* * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import java.util.ServiceLoader; import java.util.logging.Level; import java.util.logging.Logger; /** * Shared ServiceLoader/FactoryFinder Utils shared among JAF, MAIL, SAAJ, JAXB and JAXWS * Class duplicated to all those projects. * * @author Miroslav.Kos@oracle.com */ class ServiceLoaderUtil { static P firstByServiceLoader(Class

spiClass, Logger logger, ExceptionHandler handler) throws T { logger.log(Level.FINE, "Using java.util.ServiceLoader to find {0}", spiClass.getName()); // service discovery try { ServiceLoader

serviceLoader = ServiceLoader.load(spiClass); for (P impl : serviceLoader) { logger.log(Level.FINE, "ServiceProvider loading Facility used; returning object [{0}]", impl.getClass().getName()); return impl; } } catch (Throwable t) { throw handler.createException(t, "Error while searching for service [" + spiClass.getName() + "]"); } return null; } static void checkPackageAccess(String className) { // make sure that the current thread has an access to the package of the given name. SecurityManager s = System.getSecurityManager(); if (s != null) { int i = className.lastIndexOf('.'); if (i != -1) { s.checkPackageAccess(className.substring(0, i)); } } } @SuppressWarnings({"unchecked"}) static

Class

nullSafeLoadClass(String className, ClassLoader classLoader) throws ClassNotFoundException { if (classLoader == null) { return (Class

) Class.forName(className); } else { return (Class

) classLoader.loadClass(className); } } // Returns instance of required class. It checks package access (security) // unless it is defaultClassname. It means if you are trying to instantiate // default implementation (fallback), pass the class name to both first and second parameter. static P newInstance(String className, String defaultImplClassName, ClassLoader classLoader, final ExceptionHandler handler) throws T { try { Class

cls = safeLoadClass(className, defaultImplClassName, classLoader); return cls.getConstructor().newInstance(); } catch (ClassNotFoundException x) { throw handler.createException(x, "Provider " + className + " not found"); } catch (Exception x) { throw handler.createException(x, "Provider " + className + " could not be instantiated: " + x); } } @SuppressWarnings({"unchecked"}) static

Class

safeLoadClass(String className, String defaultImplClassName, ClassLoader classLoader) throws ClassNotFoundException { try { checkPackageAccess(className); } catch (SecurityException se) { // anyone can access the platform default factory class without permission if (defaultImplClassName != null && defaultImplClassName.equals(className)) { return (Class

) Class.forName(className); } // not platform default implementation ... throw se; } return nullSafeLoadClass(className, classLoader); } static ClassLoader contextClassLoader(ExceptionHandler exceptionHandler) throws T { try { return Thread.currentThread().getContextClassLoader(); } catch (Exception x) { throw exceptionHandler.createException(x, x.toString()); } } static abstract class ExceptionHandler { public abstract T createException(Throwable throwable, String message); } } jaf-api-2.1.1/api/src/main/java/jakarta/activation/URLDataSource.java000066400000000000000000000065271435131260600253000ustar00rootroot00000000000000/* * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import java.net.URL; import java.net.URLConnection; import java.io.InputStream; import java.io.OutputStream; import java.io.IOException; /** * The URLDataSource class provides an object that wraps a URL * object in a DataSource interface. URLDataSource simplifies the handling * of data described by URLs within Jakarta Activation * because this class can be used to create new DataHandlers. NOTE: The * DataHandler object creates a URLDataSource internally, * when it is constructed with a URL. * * @see jakarta.activation.DataSource * @see jakarta.activation.DataHandler */ public class URLDataSource implements DataSource { private URL url = null; private URLConnection url_conn = null; /** * URLDataSource constructor. The URLDataSource class will * not open a connection to the URL until a method requiring it * to do so is called. * * @param url The URL to be encapsulated in this object. */ public URLDataSource(URL url) { this.url = url; } /** * Returns the value of the URL content-type header field. * It calls the URL's URLConnection.getContentType method * after retrieving a URLConnection object. * Note: this method attempts to call the openConnection * method on the URL. If this method fails, or if a content type is not * returned from the URLConnection, getContentType returns * "application/octet-stream" as the content type. * * @return the content type. */ public String getContentType() { String type = null; try { if (url_conn == null) url_conn = url.openConnection(); } catch (IOException e) { } if (url_conn != null) type = url_conn.getContentType(); if (type == null) type = "application/octet-stream"; return type; } /** * Calls the getFile method on the URL used to * instantiate the object. * * @return the result of calling the URL's getFile method. */ public String getName() { return url.getFile(); } /** * The getInputStream method from the URL. Calls the * openStream method on the URL. * * @return the InputStream. */ public InputStream getInputStream() throws IOException { return url.openStream(); } /** * The getOutputStream method from the URL. First an attempt is * made to get the URLConnection object for the URL. If that * succeeds, the getOutputStream method on the URLConnection * is returned. * * @return the OutputStream. */ public OutputStream getOutputStream() throws IOException { // get the url connection if it is available url_conn = url.openConnection(); if (url_conn != null) { url_conn.setDoOutput(true); return url_conn.getOutputStream(); } else return null; } /** * Return the URL used to create this DataSource. * * @return The URL. */ public URL getURL() { return url; } } jaf-api-2.1.1/api/src/main/java/jakarta/activation/UnsupportedDataTypeException.java000066400000000000000000000020251435131260600305130ustar00rootroot00000000000000/* * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation; import java.io.IOException; /** * Signals that the requested operation does not support the * requested data type. * * @see jakarta.activation.DataHandler */ public class UnsupportedDataTypeException extends IOException { private static final long serialVersionUID = -3584600599376858820L; /** * Constructs an UnsupportedDataTypeException with no detail * message. */ public UnsupportedDataTypeException() { super(); } /** * Constructs an UnsupportedDataTypeException with the specified * message. * * @param s The detail message. */ public UnsupportedDataTypeException(String s) { super(s); } } jaf-api-2.1.1/api/src/main/java/jakarta/activation/package-info.java000066400000000000000000000006621435131260600252010ustar00rootroot00000000000000/* * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ /** * Jakarta Activation is used by Jakarta Mail to manage MIME data. */ package jakarta.activation;jaf-api-2.1.1/api/src/main/java/jakarta/activation/spi/000077500000000000000000000000001435131260600226015ustar00rootroot00000000000000jaf-api-2.1.1/api/src/main/java/jakarta/activation/spi/MailcapRegistryProvider.java000066400000000000000000000044471435131260600302670ustar00rootroot00000000000000/* * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation.spi; import jakarta.activation.MailcapRegistry; import java.io.IOException; import java.io.InputStream; import java.util.NoSuchElementException; import java.util.ServiceConfigurationError; /** * This interface defines a factory for MailcapRegistry. An * implementation of this interface should provide instances of the MailcapRegistry * based on the way how to access the storage for MailcapEntries. *

* Jakarta Activation uses Service Provider Interface and ServiceLoader * to obtain an instance of the implementation of the MailcapRegistryProvider. */ public interface MailcapRegistryProvider { /** * Retrieve an instance of the MailcapRegistry based on the name of the file where the MailcapEntries are stored. * @param name The name of the file that stores MailcapEntries. * @return The instance of the MailcapRegistry, or null if none are found. * @throws IOException If an instance of the MailcapRegistry class cannot be found or loaded. */ MailcapRegistry getByFileName(String name) throws IOException; /** * Retrieve an instance of the MailcapRegistry based on the InputStream * that is used to read data from some named resource. * @param inputStream InputStream for some resource that contains MailcapEntries. * @return The instance of the MailcapRegistry, or null if none are found. * @throws IOException If an instance of the MailcapRegistry class cannot be found or loaded. */ MailcapRegistry getByInputStream(InputStream inputStream) throws IOException; /** * Retrieve an instance of the in-memory implementation of the MailcapRegistry. * @return In-memory implementation of the MailcapRegistry. * @throws NoSuchElementException If no implementations were found. * @throws ServiceConfigurationError If no implementations were loaded. */ MailcapRegistry getInMemory(); } jaf-api-2.1.1/api/src/main/java/jakarta/activation/spi/MimeTypeRegistryProvider.java000066400000000000000000000047251435131260600304510ustar00rootroot00000000000000/* * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ package jakarta.activation.spi; import jakarta.activation.MimeTypeRegistry; import java.io.IOException; import java.io.InputStream; import java.util.NoSuchElementException; import java.util.ServiceConfigurationError; /** * This interface defines a factory for MimeTypeRegistry. An * implementation of this interface should provide instances of the MimeTypeRegistry * based on the way how to access the storage for MimeTypeEntries. *

* Jakarta Activation uses Service Provider Interface and ServiceLoader * to obtain an instance of the implementation of the MimeTypeRegistryProvider. */ public interface MimeTypeRegistryProvider { /** * Retrieve an instance of the MimeTypeRegistry based on the name of the file where the MimeTypeEntries are stored. * @param name The name of the file that stores MimeTypeEntries. * @return The instance of the MimeTypeRegistry, or null if none are found. * @throws IOException If an instance of the MailcapRegistry class cannot be found or loaded. */ MimeTypeRegistry getByFileName(String name) throws IOException; /** * Retrieve an instance of the MimeTypeRegistry based on the InputStream * that is used to read data from some named resource. * @param inputStream InputStream for some resource that contains MimeTypeEntries. * @return The instance of the MimeTypeRegistry, or null if none are found. * @throws IOException If an instance of the MailcapRegistry class cannot be found or loaded. */ MimeTypeRegistry getByInputStream(InputStream inputStream) throws IOException; /** * Retrieve an instance of the in-memory implementation of the MimeTypeRegistry. * Jakarta Activation can throw NoSuchElementException or ServiceConfigurationError * if no implementations were found. * @return In-memory implementation of the MimeTypeRegistry. * @throws NoSuchElementException If no implementations were found. * @throws ServiceConfigurationError If no implementations were loaded. */ MimeTypeRegistry getInMemory(); }jaf-api-2.1.1/api/src/main/java/jakarta/activation/spi/package-info.java000066400000000000000000000014231435131260600257700ustar00rootroot00000000000000/* * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ /** *

Provides interfaces which implementations will be used as service providers for other services * that used by Jakarta Activation.

*

Implementation of Jakarta Activation must implement interfaces declared in this package. * Jakarta Activation uses {@link java.util.ServiceLoader} class to discover * and load implementations of the interfaces from this package using standard Java SPI mechanism.

*/ package jakarta.activation.spi;jaf-api-2.1.1/api/src/main/java/module-info.java000066400000000000000000000012741435131260600213150ustar00rootroot00000000000000/* * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Distribution License v. 1.0, which is available at * http://www.eclipse.org/org/documents/edl-v10.php. * * SPDX-License-Identifier: BSD-3-Clause */ /** * Jakarta Activation API */ module jakarta.activation { uses jakarta.activation.spi.MailcapRegistryProvider; uses jakarta.activation.spi.MimeTypeRegistryProvider; exports jakarta.activation; exports jakarta.activation.spi; requires java.logging; //reflective call to java.beans.Beans.instantiate requires static java.desktop; } jaf-api-2.1.1/api/src/main/javadoc/000077500000000000000000000000001435131260600167165ustar00rootroot00000000000000jaf-api-2.1.1/api/src/main/javadoc/doc-files/000077500000000000000000000000001435131260600205635ustar00rootroot00000000000000jaf-api-2.1.1/api/src/main/javadoc/doc-files/speclicense.html000066400000000000000000000062621435131260600237540ustar00rootroot00000000000000 Eclipse Foundation Specification License - v1.0

Eclipse Foundation Specification License - v1.0

By using and/or copying this document, or the Eclipse Foundation document from which this statement is linked, you (the licensee) agree that you have read, understood, and will comply with the following terms and conditions:

Permission to copy, and distribute the contents of this document, or the Eclipse Foundation document from which this statement is linked, in any medium for any purpose and without fee or royalty is hereby granted, provided that you include the following on ALL copies of the document, or portions thereof, that you use:

Inclusion of the full text of this NOTICE must be provided. We request that authorship attribution be provided in any software, documents, or other items or products that you create pursuant to the implementation of the contents of this document, or any portion thereof.

No right to create modifications or derivatives of Eclipse Foundation documents is granted pursuant to this license, except anyone may prepare and distribute derivative works and portions of this document in software that implements the specification, in supporting materials accompanying such software, and in documentation of such software, PROVIDED that all such works include the notice below. HOWEVER, the publication of derivative works of this document for use as a technical specification is expressly prohibited.

The notice is:

"Copyright © 2018 Eclipse Foundation. This software or document includes material copied from or derived from [title and URI of the Eclipse Foundation specification document]."

Disclaimers

THIS DOCUMENT IS PROVIDED "AS IS," AND THE COPYRIGHT HOLDERS AND THE ECLIPSE FOUNDATION MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, OR TITLE; THAT THE CONTENTS OF THE DOCUMENT ARE SUITABLE FOR ANY PURPOSE; NOR THAT THE IMPLEMENTATION OF SUCH CONTENTS WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS.

THE COPYRIGHT HOLDERS AND THE ECLIPSE FOUNDATION WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE DOCUMENT OR THE PERFORMANCE OR IMPLEMENTATION OF THE CONTENTS THEREOF.

The name and trademarks of the copyright holders or the Eclipse Foundation may NOT be used in advertising or publicity pertaining to this document or its contents without specific, written prior permission. Title to copyright in this document will at all times remain with copyright holders.

jaf-api-2.1.1/api/src/main/resources/000077500000000000000000000000001435131260600173215ustar00rootroot00000000000000jaf-api-2.1.1/api/src/main/resources/META-INF/000077500000000000000000000000001435131260600204615ustar00rootroot00000000000000jaf-api-2.1.1/api/src/main/resources/META-INF/mailcap.default000066400000000000000000000013351435131260600234370ustar00rootroot00000000000000# # Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved. # # This program and the accompanying materials are made available under the # terms of the Eclipse Distribution License v. 1.0, which is available at # http://www.eclipse.org/org/documents/edl-v10.php. # # SPDX-License-Identifier: BSD-3-Clause # # This is a very simple 'mailcap' file as an example. # Example JavaBean viewers and editors are no longer # provided as they conflicted with applications. # #image/gif;; x-java-view=com.sun.activation.viewers.ImageViewer #image/jpeg;; x-java-view=com.sun.activation.viewers.ImageViewer #text/*;; x-java-view=com.sun.activation.viewers.TextViewer #text/*;; x-java-edit=com.sun.activation.viewers.TextEditor jaf-api-2.1.1/api/src/main/resources/META-INF/mimetypes.default000066400000000000000000000016071435131260600240470ustar00rootroot00000000000000# # Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved. # # This program and the accompanying materials are made available under the # terms of the Eclipse Distribution License v. 1.0, which is available at # http://www.eclipse.org/org/documents/edl-v10.php. # # SPDX-License-Identifier: BSD-3-Clause # # # A simple, old format, mime.types file # text/html html htm HTML HTM text/plain txt text TXT TEXT image/gif gif GIF image/ief ief image/jpeg jpeg jpg jpe JPG image/tiff tiff tif image/png png PNG image/x-xwindowdump xwd application/postscript ai eps ps application/rtf rtf application/x-tex tex application/x-texinfo texinfo texi application/x-troff t tr roff audio/basic au audio/midi midi mid audio/x-aifc aifc audio/x-aiff aif aiff audio/x-mpeg mpeg mpg audio/x-wav wav video/mpeg mpeg mpg mpe video/quicktime qt mov video/x-msvideo avi jaf-api-2.1.1/doc/000077500000000000000000000000001435131260600135705ustar00rootroot00000000000000jaf-api-2.1.1/doc/spec/000077500000000000000000000000001435131260600145225ustar00rootroot00000000000000jaf-api-2.1.1/doc/spec/JAF-1.1-changes.txt000066400000000000000000000173171435131260600175770ustar00rootroot00000000000000 JavaBeans Activation Framework 1.1 ================================== Please send comments and feedback to activation-comments@sun.com. The JavaBeans Activation Framework (JAF) 1.0 has been in use for eight years. In that time it has served its original purpose quite well, with only a few enhancements being requested. JAF 1.1 proposes a few minor changes to the JAF APIs to address the most commonly requested enhancements. Following is a description of the new APIs that are being introduced in JAF 1.1. The numbers in parentheses are bug numbers; you can find more information about the bug reports at: http://bugs.sun.com The JAF 1.1 RI will require J2SE 1.4 or later. (The JAF 1.0.2 RI requires only JDK 1.1.6.) JAF 1.1 will be included in J2EE 5.0 and J2SE 6.0. The JAF 1.1 RI and TCK will be available under the same terms as the JAF 1.0 RI and TCK. =================================================================== 1. Need way to find all known MIME types (4134676) --------------------------------------------------- To support this we add a new method to CommandMap: /** * 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() The default implementation of this method returns null for compatibility with applications that have provided a CommandMap implementation based on JAF 1.0. The JAF 1.1 implementation of MailcapCommandMap will return all the MIME types known to the command map. =================================================================== 2. CommandMap needs file name to choose proper command on Windows (5090200) ---------------------------------------------------------------------------- This RFE requests additional CommandMap methods that allow the CommandMap implementation to determine the file name, to better support systems such as Windows that use the file name extension to choose between the commands available to support a given MIME type. We add the following methods to CommandMap: /** * 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) /** * 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) /** * 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) /** * 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) As described, the default implementations of these methods simply call the existing CommandMap methods that don't require a DataSource object. The DataHandler implementation is changed to call these new methods if created with a DataSource. The JAF 1.1 Reference Implementation would not provide a CommandMap implementation that uses these new methods. =================================================================== 3. MailcapCommandMap needs support for "fallback" entries (6252930) -------------------------------------------------------------------- This RFE describes a problem with wildcard matching and providing fallbacks for JAF commands, in particular DataContentHandlers used by JavaMail. To support the scenario described in that bug report, we add a special "command" entry that can be added to a mailcap entry to indicate that the mailcap entry defines fallback commands that should only be used if no regular entry is available. An attribute of the form x-java-fallback-entry=true in the mailcap entry indicates a fallback entry. For example: text/*;; x-java-fallback-entry=true; x-java-view=com.sun.TextViewer The MailcapCommandMap implementation supports this attribute. Methods that return an array of commands will include commands from fallback entries after commands from regular entries. Methods that use or return only a single command will search fallback entries after regular entries. This two level hierarchy, in combination with the existing search rules for mailcap files, is sufficient to handle the common use cases. =================================================================== 4. MailcapCommandMap should store *ALL* mailcap entries (4848096) ------------------------------------------------------------------ This RFE requests the ability to retrieve the native command line associated with a mailcap entry. To support this we add a method to MailcapCommandMap: /** * 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) An application can choose to use these native "view" commands using (e.g.) the Runtime.exec method. jaf-api-2.1.1/doc/spec/JAF-1.2-changes.txt000066400000000000000000000100701435131260600175650ustar00rootroot00000000000000 JavaBeans Activation Framework 1.2 ================================== JAF 1.2 proposes a few minor changes to the JAF specification to align with other changes in JDK 9. Following is a description of the changes that are being introduced in JAF 1.2. The numbers in parentheses are bug numbers; you can find more information about the bug reports at: http://bugs.openjdk.java.net The JAF 1.2 RI will require Java SE 7 or later. JAF 1.2 will be included in Java SE 9. The JAF 1.2 RI and TCK will be available under the same terms as the JAF 1.1 RI and TCK. =================================================================== 1. JDK 9 moves config files to /conf (JDK-8049379) ---------------------------------------------------------------- The specification for MailcapCommandMap is changed as follows: * Mailcap file search order:

* The MailcapCommandMap looks in various places in the user's * system for mailcap file entries. When requests are made * to search for commands in the MailcapCommandMap, it searches * mailcap files in the following order: *

*

    *
  1. Programatically added entries to the MailcapCommandMap instance. *
  2. The file .mailcap in the user's home directory. *
  3. The file mailcap in the Java runtime. *
  4. The file or resources named META-INF/mailcap. *
  5. The file or resource named META-INF/mailcap.default * (usually found only in the activation.jar file). *
*

* (The current implementation looks for the mailcap file * in the Java runtime in the directory java.home/conf * if it exists, and otherwise in the directory * java.home/lib, where java.home is the value * of the "java.home" System property. Note that the "conf" directory was * introduced in JDK 9.) The specification for MimetypesFileTypeMap is changed as follows: * MIME types file search order:

* The MimetypesFileTypeMap looks in various places in the user's * system for MIME types file entries. When requests are made * to search for MIME types in the MimetypesFileTypeMap, it searches * MIME types files in the following order: *

    *
  1. Programmatically added entries to the MimetypesFileTypeMap instance. *
  2. The file .mime.types in the user's home directory. *
  3. The file mime.types in the Java runtime. *
  4. The file or resources named META-INF/mime.types. *
  5. The file or resource named META-INF/mimetypes.default * (usually found only in the activation.jar file). *
*

* (The current implementation looks for the mime.types file * in the Java runtime in the directory java.home/conf * if it exists, and otherwise in the directory * java.home/lib, where java.home is the value * of the "java.home" System property. Note that the "conf" directory was * introduced in JDK 9.) =================================================================== 2. Remove JAF's API dependency on java.beans.Beans.instantiate (JDK-804773) ---------------------------------------------------------------------------- To allow custom runtimes to be created without the java.desktop module, the getCommandObject method of CommandInfo is changed to make the use of java.beans.Beans.instantiate conditional: /** * Return the instantiated JavaBean component. *

* If the current runtime environment supports * {@link java.beans.Beans#instantiate Beans.instantiate}, * use it to instantiate the JavaBeans component. Otherwise, use * {@link java.lang.Class#forName Class.forName}. *

* The component class needs to be public. * On Java SE 9 and newer, if the component class is in a named module, * it needs to be in an exported package. ... jaf-api-2.1.1/doc/spec/JAF-2.0-changes.txt000066400000000000000000000024711435131260600175720ustar00rootroot00000000000000 Jakarta Activation Framework 2.0 ================================== Jakarta Activation 2.0 introduces incompatible changes to the Jakarta Activation specification in order to comply with Jakarta EE 9 requirements. Following is a description of the changes that are being introduced in Jakarta Activation 2.0. The numbers in parentheses are bug numbers; you can find more information about the bug reports at: https://github.com/eclipse-ee4j/jaf/issues The Jakarta Activation 2.0 will require Java SE 8 or later. Jakarta Activation 2.0 will be part of Jakarta EE 9. =================================================================== 1. Package name is changed from javax.activation to jakarta.activation ---------------------------------------------------------------- A specification move the API package names from the top level javax package to the top level jakarta package. =================================================================== 2. Remove Jakarta Activation's API dependency on java.awt.datatransfer ---------------------------------------------------------------------------- Those who write their own DataContentHandlers will need to change any references to the DataFlavor class to instead reference the ActivationDataFlavor class, and to remove any references to the Transferrable interface. jaf-api-2.1.1/doc/spec/JAF-2.1-changes.txt000066400000000000000000000023551435131260600175740ustar00rootroot00000000000000 Jakarta Activation Framework 2.1 ================================== Jakarta Activation 2.1 breaks the tight integration between the Jakarta Activation specification API and Jakarta Activation implementation Following is a description of the changes that are being introduced in Jakarta Activation 2.1. The numbers in parentheses are bug numbers; you can find more information about the bug reports at: https://github.com/eclipse-ee4j/jaf/issues The Jakarta Activation 2.1 requires Java SE 8 or later. Jakarta Activation 2.1 is part of Jakarta EE 10. =================================================================== 1. Add provider SPI ---------------------------------------------------------------- Add jakarta.activation.spi package with interfaces for the provider of the compatible implementation of the Jakarta Activation Specification runtime to implement. =================================================================== 2. Remove the implementation ---------------------------------------------------------------------------- The implementation of the specification was moved to the new project - Eclipse Angus - and further development continues there. Eclipse Angus is direct accessor of JavaActivation/JakartaActivation. jaf-api-2.1.1/doc/spec/RELNOTES.txt000066400000000000000000000044141435131260600165210ustar00rootroot00000000000000 JavaBeans(tm) Activation Framework 1.2 Release Notes Welcome to the JavaBeans(tm) Activation Framework! System Requirements: -------------------- The JavaBeans(tm) Activation Framework (JAF) was developed and tested against JDK 1.5. JAF is written in Java (with no native code). It will run on any JDK 1.5 (or newer) compatible virtual machine. Note that JAF is included in Java SE 6 and later releases. Installation: ------------- There is effectively *no* installation of the JAF. The classes that make up the JAF are contained in the included Java(tm) Archive (JAR) file, "jakarta.activation.jar". This file can be placed anywhere accessible to the Java virtual machine running on your system. The only requirement is that the jakarta.activation.jar be included in your system's class path so Java can find the JAF classes. Related Web Sites: ------------------ There are a number of web sites you might find useful if you haven't already run across them: https://github.com/eclipse-ee4j/javamail -- The JavaMail(tm) API provides a set of abstract classes that model a mail system. Its implementation is dependent on the JAF. Bugs fixed in the 1.2 Release: ------------------------------ JDK-8047773 Remove JAF's API dependency on java.beans.Beans.instantiate JDK-8049379 JDK 1.9 moves config files to /conf Bugs fixed in the 1.1.1 Release: -------------------------------- 6456395 DataHandler.writeTo should have built-in support for byte arrays and Strings 6538484 JAF fails in Turkish locale Bugs fixed in the 1.1 Release: ------------------------------ use context class loader to load data content handlers guard against possible NPE when parsing mailcap file really make sure input stream gets closed in DataHandler.writeTo 4134676 need way to find all known MIME types 4786035 API doc: some bugs in javax/activation/MimeType.cmnt 4848096 MailcapCommandMap should store *ALL* mailcap entries 5090200 CommandMap needs file name to choose proper command on Windows 6245613 fix ActivationDataFlavor normalize methods to match DataFlavor 6252930 MailcapCommandMap needs support for "fallback" entries in mailcap file 6357487 DataHandler.getBean should load class using application's class loaderjaf-api-2.1.1/etc/000077500000000000000000000000001435131260600135765ustar00rootroot00000000000000jaf-api-2.1.1/etc/copyright-exclude000066400000000000000000000002001435131260600171500ustar00rootroot00000000000000copyright-exclude LICENSE CONTRIBUTING.md README NOTICE.md /speclicense.html doc/spec/ spec/src/main/asciidoc/license-efsl.adoc jaf-api-2.1.1/etc/spotbugs-exclude.xml000066400000000000000000000014621435131260600176200ustar00rootroot00000000000000 jaf-api-2.1.1/spec/000077500000000000000000000000001435131260600137555ustar00rootroot00000000000000jaf-api-2.1.1/spec/LICENSE.md000066400000000000000000001044141435131260600153650ustar00rootroot00000000000000# Eclipse Public License - v 2.0 THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. 1. DEFINITIONS "Contribution" means: a) in the case of the initial Contributor, the initial content Distributed under this Agreement, and b) in the case of each subsequent Contributor: i) changes to the Program, and ii) additions to the Program; where such changes and/or additions to the Program originate from and are Distributed by that particular Contributor. A Contribution "originates" from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf. Contributions do not include changes or additions to the Program that are not Modified Works. "Contributor" means any person or entity that Distributes the Program. "Licensed Patents" mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program. "Program" means the Contributions Distributed in accordance with this Agreement. "Recipient" means anyone who receives the Program under this Agreement or any Secondary License (as applicable), including Contributors. "Derivative Works" shall mean any work, whether in Source Code or other form, that is based on (or derived from) the Program and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. "Modified Works" shall mean any work in Source Code or other form that results from an addition to, deletion from, or modification of the contents of the Program, including, for purposes of clarity any new file in Source Code form that contains any contents of the Program. Modified Works shall not include works that contain only declarations, interfaces, types, classes, structures, or files of the Program solely in each case in order to link to, bind by name, or subclass the Program or Modified Works thereof. "Distribute" means the acts of a) distributing or b) making available in any manner that enables the transfer of a copy. "Source Code" means the form of a Program preferred for making modifications, including but not limited to software source code, documentation source, and configuration files. "Secondary License" means either the GNU General Public License, Version 2.0, or any later versions of that license, including any exceptions or additional permissions as identified by the initial Contributor. 2. GRANT OF RIGHTS a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, Distribute and sublicense the Contribution of such Contributor, if any, and such Derivative Works. b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in Source Code or other form. This patent license shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder. c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to Distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program. d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement. e) Notwithstanding the terms of any Secondary License, no Contributor makes additional grants to any Recipient (other than those set forth in this Agreement) as a result of such Recipient's receipt of the Program under the terms of a Secondary License (if permitted under the terms of Section 3). 3. REQUIREMENTS 3.1 If a Contributor Distributes the Program in any form, then: a) the Program must also be made available as Source Code, in accordance with section 3.2, and the Contributor must accompany the Program with a statement that the Source Code for the Program is available under this Agreement, and informs Recipients how to obtain it in a reasonable manner on or through a medium customarily used for software exchange; and b) the Contributor may Distribute the Program under a license different than this Agreement, provided that such license: i) effectively disclaims on behalf of all other Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose; ii) effectively excludes on behalf of all other Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits; iii) does not attempt to limit or alter the recipients' rights in the Source Code under section 3.2; and iv) requires any subsequent distribution of the Program by any party to be under a license that satisfies the requirements of this section 3. 3.2 When the Program is Distributed as Source Code: a) it must be made available under this Agreement, or if the Program (i) is combined with other material in a separate file or files made available under a Secondary License, and (ii) the initial Contributor attached to the Source Code the notice described in Exhibit A of this Agreement, then the Program may be made available under the terms of such Secondary Licenses, and b) a copy of this Agreement must be included with each copy of the Program. 3.3 Contributors may not remove or alter any copyright, patent, trademark, attribution notices, disclaimers of warranty, or limitations of liability ("notices") contained within the Program from any copy of the Program which they Distribute, provided that Contributors may add their own appropriate notices. 4. COMMERCIAL DISTRIBUTION Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor ("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor") against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense. For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone. Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result, the Commercial Contributor must pay those damages. 5. NO WARRANTY EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations. 6. DISCLAIMER OF LIABILITY EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 7. GENERAL If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable. If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed. All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive. Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be Distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to Distribute the Program (including its Contributions) under the new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved. Nothing in this Agreement is intended to be enforceable by any entity that is not a Contributor or Recipient. No third-party beneficiary rights are created under this Agreement. Exhibit A - Form of Secondary Licenses Notice "This Source Code may also be made available under the following Secondary Licenses when the conditions for such availability set forth in the Eclipse Public License, v. 2.0 are satisfied: {name license(s), version(s), and exceptions or additional permissions here}." Simply including a copy of this Agreement, including this Exhibit A is not sufficient to license the Source Code under Secondary Licenses. If it is not possible or desirable to put the notice in a particular file, then You may include the notice in a location (such as a LICENSE file in a relevant directory) where a recipient would be likely to look for such a notice. You may add additional accurate notices of copyright ownership. --- ## The GNU General Public License (GPL) Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor Boston, MA 02110-1335 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. One line to give the program's name and a brief idea of what it does. Copyright (C) This program 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 of the License, or (at your option) any later version. This program 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 this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. signature of Ty Coon, 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. --- ## CLASSPATH EXCEPTION 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 version 2 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. jaf-api-2.1.1/spec/README.md000066400000000000000000000005771435131260600152450ustar00rootroot00000000000000Jakarta Activation Specification ================================ This project generates the Jakarta Activation Specification. Building -------- Prerequisites: * JDK8+ * Maven 3.0.5+ Run the full build: `mvn install` Locate the html files: - `target/generated-docs/activation-spec-.html` Locate the PDF files: - `target/generated-docs/activation-spec-.pdf` jaf-api-2.1.1/spec/assembly.xml000066400000000000000000000020521435131260600163150ustar00rootroot00000000000000 spec zip activation-spec target/generated-docs jaf-api-2.1.1/spec/pom.xml000066400000000000000000000233121435131260600152730ustar00rootroot00000000000000 4.0.0 org.eclipse.ee4j project 1.0.7 activation-spec 2.1-SNAPSHOT pom Jakarta Activation Specification ${project.build.directory}/staging true 1.5.7.1 1.6.2 1.5.0-alpha.16 9.2.6.0 jakarta-${project.artifactId}-${project.version} DRAFT MMMM dd, yyyy ${maven.build.timestamp} package org.apache.maven.plugins maven-enforcer-plugin 1.4.1 org.asciidoctor asciidoctor-maven-plugin ${asciidoctor.maven.plugin.version} org.jruby jruby-complete ${jruby.version} org.asciidoctor asciidoctorj ${asciidoctorj.version} org.asciidoctor asciidoctorj-pdf ${asciidoctorj.pdf.version} org.apache.maven.plugins maven-release-plugin 2.5.2 org.apache.maven.scm maven-scm-provider-gitexe 1.9.4 org.apache.maven.plugins maven-assembly-plugin 3.3.0 org.apache.maven.plugins maven-enforcer-plugin enforce-versions enforce [11,) You need JDK 11 or higher org.asciidoctor asciidoctor-maven-plugin asciidoc-to-html generate-resources process-asciidoc html5 ${project.build.directory}/generated-docs/${spec.name}.html book ${status} font left font true - true asciidoc-to-pdf generate-resources process-asciidoc pdf ${project.build.directory}/generated-docs/${spec.name}.pdf ${project.basedir}/src/theme jakartaee book ${status} font font true - true true activation-spec.adoc coderay ${project.version} ${status} ${revisiondate} org.apache.maven.plugins maven-release-plugin forked-path false ${release.arguments} org.apache.maven.plugins maven-assembly-plugin false package single false assembly.xml jaf-api-2.1.1/spec/src/000077500000000000000000000000001435131260600145445ustar00rootroot00000000000000jaf-api-2.1.1/spec/src/main/000077500000000000000000000000001435131260600154705ustar00rootroot00000000000000jaf-api-2.1.1/spec/src/main/asciidoc/000077500000000000000000000000001435131260600172465ustar00rootroot00000000000000jaf-api-2.1.1/spec/src/main/asciidoc/activation-spec.adoc000066400000000000000000000012441435131260600231700ustar00rootroot00000000000000// // Copyright (c) 2017, 2020 Contributors to the Eclipse Foundation // = Jakarta Activation 2.1 :authors: Jakarta Activation Team, https://projects.eclipse.org/projects/ee4j.jaf :email: https://dev.eclipse.org/mailman/listinfo/jaf-dev :version-label!: :doctype: book :license: Eclipse Foundation Specification License v1.0 :source-highlighter: coderay :toc: left :toclevels: 4 :sectnumlevels: 4 :sectanchors: ifdef::backend-pdf[] :pagenums: :numbered: :title-logo-image: image:jakarta_ee_logo_schooner_color_stacked_default.png[pdfwidth=4.25in,align=right] endif::[] // == License :sectnums!: include::license-efsl.adoc[] // == Spec :sectnums: include::activation.adoc[] jaf-api-2.1.1/spec/src/main/asciidoc/activation.adoc000066400000000000000000001073401435131260600222440ustar00rootroot00000000000000== Overview JavaBeans™ is proving to be a popular technology. As more people embrace JavaBeans™ and the Java™ platform, some of the environment’s shortcomings are brought to light. JavaBeans™ was meant to satisfy needs in builder and development environments but its capabilities fall short of those needed to deploy stand alone components as content editing and creating entities. Neither JavaBeans™ nor the Java™ platform define a consistent strategy for typing data, a method for determining the supported data types of a software component, a method for binding typed data to a component, or an architecture and implementation that supports these features. Presumably with these pieces in place, a developer can write a JavaBeans™ based component that provides helper application like functionality in a web browser, added functionality to an office suite, or a content viewer in a Java™ application. == Goals This document describes Jakarta Activation. Jakarta Activation implements the following services: * It determines the type of arbitrary data. * It encapsulates access to data. * It discovers the operations available on a particular type of data. * It instantiates the software component that corresponds to the desired operation on a particular piece of data. Jakarta Activation is packaged as a Standard Extension to the Java™ platform. == Architectural Overview The Java™ platform (including JavaBeans™) already provides some support for a modest activation framework. Jakarta Activation leverages as much of that existing technology as possible. Jakarta Activation integrates these mechanisms. image:activation.png[image] This diagram shows the major elements comprising the Jakarta Activation architecture. Note that the framework shown here is not bound to a particular application. === The DataHandler Class The DataHandler class (shown in the diagram above) provides a consistent interface between Activation-aware clients and other subsystems. === The DataSource Interface The DataSource interface encapsulates an object that contains data, and that can return both a stream providing data access, and a string defining the MIME type describing the data. Classes can be implemented for common data sources (web, file system, IMAP, ftp, etc.). The DataSource interface can also be extended to allow per data source user customizations. Once the DataSource is set in the DataHandler, the client can determine the operations available on that data. Jakarta Activation includes two DataSource class implementations for convenience: * FileDataSource accesses data held in a file. * URLDataSource accesses data held at a URL. === The CommandMap Interface The CommandMap provides a service that allows consumers of its interfaces to determine the ‘commands’ available on a particular MIME type as well as an interface to retrieve an object that can operate on an object of a particular MIME type (effectively a component registry). The Command Map can generate and maintain a list of available capabilities on a particular data type by a mechanism defined by the implementation of the particular instance of the CommandMap. The JavaBeans™ package provides the programming model for the software components that implement the commands. Each JavaBeans™ component can use externalization, or can implement the CommandObject interface to allow the typed data to be passed to it. Jakarta Activation defines the CommandMap interface, which provides a flexible and extensible framework for the CommandMap. The CommandMap interface allows developers to develop their own solutions for discovering which commands are available on the system. A possible implementation can access the ‘types registry’ on the platform or use a server-based solution. Jakarta Activation provides a simple default solution based on RFC 1524 (.mailcap) like functionality. See “Deliverables” below. === The Command Object Interface Beans extend the CommandObject interface in order to interact with Activation services. Activation-aware JavaBeans™ components can directly access their DataSource and DataHandler objects in order to retrieve the data type and to act on the data. == Using The Framework We intend to make this infrastructure widely available for any Java™ Application that needs this functionality. The ‘canonical’ consumer of this framework accesses it through the DataHandler (although the major subsystems are designed to also operate independently). An underlying DataSource object is associated with the DataHandler when the DataHandler class is constructed. * The DataHandler retrieves the data typing information from the DataSource or gets the data type directly from the constructor. * Once this initialization step is complete, a list of commands that can be performed on the data item can be accessed from the DataHandler. When an application issues a request for this list, the DataHandler uses the MIME data type specifier returned to request a list of available commands from the CommandMap object. The CommandMap has knowledge of available commands (implemented as Beans) and their supported data types. The CommandMap returns a subset of the full list of all commands based on the requested MIME type and the semantics of the CommandMap implementation, to the DataHandler. When the application wishes to apply a command to some data, it is accomplished through the appropriate DataHandler interface, which uses the CommandMap to retrieve the appropriate Bean that is used to operate on the data. The container (user of the framework) makes the association between the data and the Bean. Application must use Jakarta Activation implementation that provides MimeTypeRegistry, MailcapRegistry, MailcapRegistryProvider and MimeTypeRegistryProvider implementations when the application wishes to get access to the available MIME types and CommandMap whose configuration is based on mailcap storage like mailcap files (RFC 1524). == Usage Scenarios This scenario uses the example of a hypothetical file viewer application in order to illustrate the normal flow of tasks involved when implementing Jakarta Activation. The file viewer is similar to the Windows Explorer utility. When launched, it presents the user with a display of available files. It includes a function like Explorer’s ‘right mouse’ menu, where all operations that can be performed on a selected data item are listed in a popup menu for that item. A typical user launches this application to view a directory of files. When the user specifies a file by clicking on it, the application displays a popup menu that lists the available operations on that file. File system viewer utilities normally include ‘edit,’ ‘view,’ and ‘print’ commands as available operations. For instance selecting ‘view’ causes the utility to open the selected file in a viewer that can display data of the data type held in that file. === Scenario Architecture Description of tasks performed by the application is broken down into three discrete steps, for clarity: * Initialization: The application constructs a view of the file system. * Getting the Command List: The application presents the command list for a selected data item. * Performing the Command: The application performs a command on the selected data object. === Initialization One of the interfaces mentioned below is the ‘DataSource’ object. Recall that the DataSource object encapsulates the underlying data object in a class that abstracts the underlying data storage mechanism, and presents its consumers with a common data access and typing interface. The file viewer application queries the file system for its contents. The viewer instantiates a DataSource object for each file in the directory. Then it instantiates a a DataHandler with the DataSource as its constructor argument. The DataHandler object provides the client application with access to the CommandMap, which provides a service that enables access to commands that can operate on the data. The application maintains a list of the DataHandler objects, queries them for their names to generate its display. [source, java] ---- // for each file in the directory: File file = new File(file_name); DataSource ds = new FileDataSource(file); DataHandler dh = new DataHandler(ds); ---- === Getting the Command List Once the application has been initialized and has presented a list of files to the user, the user can select a file on the list. When the user selects a file, the application displays a popup menu that lists the available operations on that file. The application implements this functionality by requesting the list of available commands from the DataHandler object associated with a file. The DataHandler retrieves the MIME type of the data from the DataSource object and queries the CommandMap for operations that are available on that type. The application interprets the list and presents it to the user on a popup menu. The user then selects one of the operations from that list. Application can use CommandMap implementation that is provided by the Jakarta Activation implementation or use the implementation that is included in Jakarta Activation (MailcapCommandMap). When the second option is used MimeTypeRegistry, MailcapRegistry, MailcapRegistryProvider and MimeTypeRegistryProvider must be implemented by the Jakarta Activation implementation. [source, java] ---- // get the command list for an object CommandInfo cmdInfo[] = dh.getPreferredCommands(); PopupMenu popup = new PopupMenu(“Item Menu”); // populate the popup with available commands for (i = 0; i < cmdInfo.length; i++) popup.add(cmdInfo[i].getCommandName()); // add and show popup add(popup); popup.show(x_pos, y_pos); ---- === Performing a Command After the user has selected a command from the popup menu, the application uses the appropriate CommandInfo class to retrieve the Bean that corresponds to the selected command, and associates the data with that Bean using the appropriate mechanism (DataHandler, Externalization etc.). Some CommandObjects (viewers for instance) are subclassed from java.awt.Component and require that they are given a parent container. Others (like a default print Command) might not present a user interface. This allows them to be flexible enough to function as stand alone viewer/editors, or perhaps as components in a compound document system. The ‘application’ is responsible for providing the proper environment (containment, life cycle, etc.) for the CommandObject to execute in. We expect that the requirements will be lightweight (not much beyond JavaBeans™ containers and AWT containment for visible components). [source, java] ---- // get the command object Object cmdBean = cmdInfo[cmd_id].getCommandObject(dh, this.getClassLoader()); ... // use serialization/externalization where appropriate my_awt_container.add((Component)cmdBean); ---- === An Alternative Scenario The first scenario was the ‘canonical’ case. There are also circumstances where the application has already created objects to represent its data. In this case creating an in-memory instance of a DataSource that converted an existing object into an InputStream is an inefficient use of system resources and can result in a loss of data fidelity. In these cases, the application can instantiate a DataHandler, using the DataHandler(Object obj, String mimeType) constructor. DataHandler implements the Transferable interface, so the consuming Bean can request representations other than InputStreams. The DataHandler also constructs a DataSource for consumers that request it. The DataContentHandler mechanism is extended to also allow conversion from Objects to InputStreams. The following code is an example of a database front end using Jakarta Activation, which provides query results in terms of objects. [source, java] ---- /** * Get the viewer to view my query results: */ Component getQueryViewer(QueryObject qo) throws Exception { String mime_type = qo.getType(); Object q_result = qo.getResultObject(); DataHandler my_dh = new DataHandler(q_result, mime_type); return (Component)my_dh.getCommand(“view”). getCommandObject(my_dh, null)); } ---- == Primary Framework Interfaces This section describes interfaces required to implement the Jakarta Activation architecture introduced in Section Three. === The DataSource Interface The DataSource interface is used by the DataHandler (and possibly other classes elsewhere) to access the underlying data. The DataSource object encapsulates the underlying data object in a class that abstracts the underlying data storage and typing mechanism, and presents its consumers with a common data access interface. Jakarta Activation provides DataSource implementations that support file systems and URLs. Application system vendors can use the DataSource interface to implement their own specialized DataSource classes to support IMAP servers, object databases, or other sources. There is a one-to-one correspondence between underlying data items (files for instance) and DataSource objects. Also note that the class that implements the DataSource interface is responsible for typing the data. To manage a file system, a DataSource can use a simple mechanism such as a file extension to type data, while a DataSource that supports incoming web-based data can actually examine the data stream to determine its type. === The DataHandler Class The DataHandler class encapsulates a Data object, and provides methods which act on that data. DataHandler encapsulates the type-to-command object binding service of the CommandMap interface for applications. It provides a handle to the operations and data available on a data element. DataHandler also implements the Transferable interface. This allows applications and applets to retrieve alternative representations of the underlying data, in the form of objects. The DataHandler encapsulates the interface to the component repository and data source. Let’s examine these groups of features in more detail: ==== Data Encapsulation A DataHandler object can only be instantiated with data. The data can be in the form of an object implementing the DataSource interface (the preferred way) or as an object with an associated content type. Once instantiated, the DataHandler tries to provide its data in a flexible way. The DataHandler implements the Transferable interface which allows an object to provide alternative representations of the data. The Transferable interface’s functionality can be extended via objects implementing the DataContentHandler interface, and then made available to the DataHandler either by a DataContentHandlerFactory object, or via a CommandMap. ==== Command Binding The DataHandler provides wrappers around commonly used functions for command discovery. DataHandler has methods that call into the current CommandMap associated with the DataHandler. By default the DataHandler calls CommandMap’s getDefaultCommandMap method if no CommandMap was explicitly set. As a convenience, DataHandler uses the content type of its data when calls are made to the CommandMap. === The DataContentHandler Interface The DataContentHandler interface is implemented by classes that are used by the DataHandler to convert InputStreams into objects and vice versa. In effect, the DataHandler object uses a DataContentHandler object to implement the Transferable interface. DataContentHandlers are discovered via the current CommandMap. A DataContentHandler uses DataFlavors to represent the data types it can access. The DataContentHandler also converts data from objects into InputStreams. For instance, if an application needs to access a .gif file, it passes the file to the image/gif DataContentHandler. The image/gif DataContentHandler converts the image object into a gif-formatted byte stream. Applications will typically need to provide DataContentHandlers for all the MIME types they intend to support. (Note that the Jakarta Mail implementation provides DataContentHandlers for many of the MIME types used in mail messages.) === The CommandMap Interface Once the DataHandler has a MIME type describing the content, it can query the CommandMap for the operations, or commands that are available for that data type. The application requests commands available through the DataHandler and specifies a command on that list. The DataHandler uses the CommandMap to retrieve the Bean associated with that command. Some or all of the command map is stored in some ‘common’ place, like a .mailcap (RFC 1524) file. Other more complex implementations can be distributed, or can provide licensing or authentication features. === The CommandInfo Class The CommandInfo class is used to represent commands in an underlying registry. From a CommandInfo object, an application can instantiate the Bean or request the verb (command) it describes. === The CommandObject Interface Beans designed specifically for use with Jakarta Activation should implement the CommandObject interface. This interface provides direct access to DataHandler methods and notifies an Activation-aware Bean which verb was used to call it. Upon instantiation, the Bean takes a string specifying a user-selected command verb, and the DataHandler object managing the target data. The DataHandler takes a DataSource object, which provides an input stream linked to that data, and a string specifying the data type. === The DataContentHandlerFactory Like the ContentHandler factory in the java.net package, the DataContentHandlerFactory is an interface that allows developers to write objects that map MIME types to DataContentHandlers. The interface is extremely simple, in order to allow developers as much design and implementation freedom as possible. == Writing Beans for the Framework === Overview This section describes the specification of well-behaved Activation-aware Bean viewers. Note that this proposal assumes the reader is comfortable with the JavaBeans™ Specification. Developers intending to implement viewer Beans for Jakarta Activation should be familiar with JavaBeans™ concepts and architecture. === Viewer Goals . Make the implementation of viewers and editors as simple as implementing Beans. That is, require low cost of entry to be a good citizen. . Allow developers to have a certain amount of flexibility in their implementations. === General We are attempting to limit the amount of extra baggage that needs to be implemented beyond ‘generic’ Beans. In many cases, JavaBeans™ components that weren’t developed with knowledge of the framework can be used. Jakarta Activation exploits the existing features of JavaBeans™ and the JDK™, and defines as few additional interfaces and policies as possible. We expect that viewers/editors will be bound to data via a simple registry mechanism similar in function to a .mailcap file. In addition, mailcap format files may be bundled with components, allowing additional packages to be added at runtime. Our viewers/editors and related classes and files are encapsulated into JAR files, as is the preferred method for JavaBeans™. Jakarta Activation does not restrict the choice of classes used to implement Activaiton-aware ‘viewer’ Beans, beyond those expected of well-behaved Beans. === Interfaces A viewer Bean that communicates directly with a Jakarta Activation DataHandler should implement the CommandObject interface. This interface is small and easy to implement. However, Beans can still use standard Serialization and Externalization methods available in the JDK. === Storage Jakarta Activation expects applications and viewer Beans to implement storage tasks via the DataSource object. However; it is possible to use Externalization. An Activation-aware application can implement the following storage mechanism: [source, java] ---- ObjectOutputStream oos = new ObjectOutputStream( data_handler.getOutputStream()); my_externalizable_bean.writeExternal(oos); ---- === Packaging The basic format for packaging of the Viewer/Editors is the JAR file as described in the JavaBeans™ Specification. This format allows the convenient packaging of collections of files that are related to a particular Bean or applet. For more information concerning integration points, see Section 8. === Container Support Jakarta Activation is designed to be flexible enough to support the needs of a variety of applications. Jakarta Activation expects these applications to provide the appropriate containers and life cycle support for these Beans. Beans written for the framework should be compatible with the guidelines in the JavaBeans™ documentation and should be tested against the BDK BeanBox (and the JDK Appletviewer if they are subclassed from Applet). === Lifecycle In general Jakarta Activation expects that its viewer bean life cycle semantics are the same as those for all Beans. In the case of Beans that implement the CommandObject interface we encourage application developers to not parent Beans subclassed from java.awt.Component to an AWT container until after they have called the jakarta.activation.CommandObject.setCommandContext method. === Command Verbs The MailcapCommandMap implementation provides a mechanism that allows for an extensible set of command verbs. Applications using Jakarta Activation can query the system for commands available for a particular MIME type, and retrieve the Bean associated with that MIME type. == Framework Integration Points This section presents several examples that clarify how JavaBeans™ developers can write Beans that are integrated with Jakarta Activation. First, let’s review the pluggable components of the Jakarta Activation framework: * A mechanism that accesses target data where it is stored: DataSource * A mechanism to convert data objects to and from an external byte stream format: DataContentHandler * A mechanism to locate visual components that operate on data objects: CommandMap * The visual components that operate on data objects: Activation-aware Beans As a JavaBeans™ developer, you may build visual Beans. You can also develop DataContentHandlers to supply data to those Beans. You might also need to develop a new DataSource or CommandMap class to access data and specify a data type. === Bean Suppose you’re building a new Wombat Editor product, with its corresponding Wombat file format. You’ve built the Wombat Editor as one big Bean. Your WombatBean can do anything and everything that you might want to do with a Wombat. It can edit, it can print, it can view, it can save Wombats to files, and it can read Wombats in from files. You’ve defined a language-independent Wombat file format. You consider the Wombat data and file formats to be proprietary so you have no need to offer programmatic interfaces to Wombats beyond what your WombatBean supports. You’ve chosen the MIME type “application/x-wombat” to describe your Wombat file format, and you’ve chosen the filename extension “.wom” to be used by files containing Wombats. To integrate with the framework, you’ll need some simple wrappers for your WombatBean for each command you want to implement. For example, for a Print command wrapper you can write the following code: [source, java] ---- public class WombatPrintBean extends WombatBean { public WombatPrintBean() { super(); initPrinting(); } } ---- You will need to create a mailcap file that lists the MIME type “application/x-wombat” and user visible commands that are supported by your WombatBean. Your WombatBean wrappers will be listed as the objects supporting each of these commands. [source] ---- application/x-wombat; ; x-java-view=com.foo.WombatViewBean; \ x-java-edit=com.foo.WombatEditBean; \ x-java-print=com.foo.WombatPrintBean ---- You’ll also need to create a mime.types file with an entry: [source] ---- type=application/x-wombat desc=”Wombat” exts=wom ---- All of these components are packaged in a JAR file: [source] ---- META-INF/mailcap META-INF/mime.types com/foo/WombatBean.class com/foo/WombatEditBean.class com/foo/WombatViewBean.class ---- Because everything is built into one Bean, and because no third party programmatic access to your Wombat objects is required, there’s no need for a DataContentHandler. Your WombatBean can therefore implement the Externalizable interface instead; and use its methods to read and write your Wombat files. The DataHandler can call the Externalizable methods when appropriate. === Beans Your Wombat Editor product has really taken off, and you’re now adding significant new functionality and flexibility to your Wombat Editor. It’s no longer feasible to put everything into one giant Bean. Instead, you’ve broken the product into a number of Beans and other components: * A WombatViewer Bean that can be used to quickly view a Wombat in read-only mode. * A WombatEditor Bean that is heavier than the WombatViewer, but also allows editing. * A WombatPrinter Bean that simply prints a Wombat. * A component that reads and writes Wombat files. * A Wombat class that encapsulates the Wombat data and is used by your other Beans and components. In addition, customers have demanded to be able to programmatically manipulate Wombats, independently from the visual viewer or editor Beans. You’ll need to create a DataContentHandler that can convert a byte stream to and from a Wombat object. When reading, the WombatDataContentHandler reads a byte stream and returns a new Wombat object. When writing, the WombatDataContentHandler takes a Wombat object and produces a corresponding byte stream. You’ll need to publish the API to the Wombat class. The WombatDataContentHandler is delivered as a class and is designated as a DataContentHandler that can operate on Wombats in the mailcap file included in your JAR file. Your mailcap file changes to list the appropriate Wombat Beans, which implement user commands: [source] ---- application/x-wombat; ; x-java-View=com.foo.WombatViewBean; \ x-java-edit=com.foo.WombatEditBean; \ x-java-print=com.foo.WombatPrintBean; \ x-java-content-handler=com.foo.WombatDataContentHandler ---- Your Wombat Beans can continue to implement the Externalizable interface, and thus read and write Wombat byte streams. They are more likely to simply operate on Wombat objects directly. To find the Wombat object they’re being invoked to operate on, they implement the CommandObject interface. The setCommandContext method refers them to the corresponding DataHandler, from which they can invoke the getContent method, which will return a Wombat object (produced by the WombatDataContentHandler). All components are packaged in a JAR file. === Viewer Only The Wombat product has been wildly successful. The ViewAll Company has decided that it can produce a Wombat viewer that’s much faster than the WombatViewer Bean. Since they don’t want to depend on the presence of any Wombat components, their viewer must parse the Wombat file format, which they reverse engineered. The ViewAll WombatViewerBean implements the Externalizable interface to read the Wombat data format. ViewAll delivers an appropriate mailcap file: [source] ---- application/x-wombat; ; x-java-view=com.viewall.WombatViewer ---- and mime.types file: [source] ---- type=application/x-wombat desc=”Wombat” exts=wom ---- All components are packaged in a JAR file. === ContentHandler Bean Only Now that everyone is using Wombats, you’ve decided that it would be nice if you could notify people by email when new Wombats are created. You have designed a new WombatNotification class and a corresponding data format to be sent by email using the MIME type “application/x-wombat-notification”. Your server detects the presence of new Wombats, constructs a WombatNotification object, and constructs and sends an email message with the Wombat notification data as an attachment. Your customers run a program that scans their email INBOX for messages with Wombat notification attachments and use the WombatNotification class to notify their users of the new Wombats. In addition to the server application and user application described, you’ll need a DataContentHandler to plug into the DataHandler infrastructure and construct the WombatNotification objects. The WombatNotification DataContentHandler is delivered as a class named WombatNotificationDataContentHandler and is delivered in a JAR file with the following mailcap file: [source] ---- application/x-wombat-notification; \ WombatNotificationDataContentHandler ---- The server application creates DataHandlers for its WombatNotification objects. The email system uses the DataHandler to fetch a byte stream corresponding to the WombatNotification object. (The DataHandler uses the DataContentHandler to do this.) The client application retrieves a DataHandler for the email attachment and uses the getContent method to get the corresponding WombatNotification object, which will then notify the user. == Framework Deliverables === Packaging Details Jakarta Activation is implemented as a Standard Extension to the Java™ Platform. The following are some more details about the package: * The package name is jakarta.activation. * The Jakarta Activation implementation does not include DataContentHandlers for any MIME data types; applications must include the DataContentHandlers they need. Note that the Jakarta Mail implementation includes DataContentHandlers for some basic data types used in mail messages. * The Jakarta Activation does not include the implementation for the following interfaces : MimeTypeRegistry, MailcapRegistry, MailcapRegistryProvider and MimeTypeRegistryProvider. === Framework Core Classes **interface DataSource:** The DataSource interface provides Jakarta Activation with an abstraction of some arbitrary collection of data. It provides a type for that data as well as access to it in the form of InputStreams and OutputStreams where appropriate. **class DataHandler:** The DataHandler class provides a consistent interface to data available in many different sources and formats. It manages simple stream to string conversions and related operations using DataContentHandlers. It provides access to commands that can operate on the data. The commands are found using a CommandMap. **interface DataContentHandler:** The DataContentHandler interface is implemented by objects that can be used to extend the capabilities of the DataHandler’s implementation of the Transferable interface. Through DataContentHandlers the framework can be extended to convert streams in to objects, and to write objects to streams. **interface DataContentHandlerFactory:** This interface defines a factory for DataContentHandlers. An implementation of this interface should map a MIME type into an instance of DataContentHandler. The design pattern for classes implementing this interface is the same as for the ContentHandler mechanism used in java.net.URL. **class CommandMap:** The CommandMap class provides an interface to the registry of viewer, editor, print, etc. objects available in the system. Developers are expected to either use the CommandMap implementation included with this package (MailcapCommandMap) or develop their own. Note that some of the methods in this class are abstract. **interface CommandObject:** Beans that are Activation aware implement this interface to find out which command verb they’re being asked to perform, and to obtain the DataHandler representing the data they should operate on. Beans that don’t implement this interface may be used as well. Such commands may obtain the data using the Externalizable interface, or using an application-specific method. **class CommandInfo:** The CommandInfo class is used by CommandMap implementations to describe the results of command requests. It provides the requestor with both the verb requested, as well as an instance of the bean. There is also a method that will return the name of the class that implements the command but it is not guaranteed to return a valid value. The reason for this is to allow CommandMap implementations that subclass CommandInfo to provide special behavior. For example a CommandMap could dynamically generate Beans. In this case, it might not be possible to create an object with all the correct state information solely from the class name. === Framework Auxiliary Classes **class FileDataSource:** The FileDataSource class implements a simple DataSource object that encapsulates a file. It provides data typing services via a FileTypeMap object. **class FileTypeMap:** The FileTypeMap is an abstract class that provides a data typing interface for files. Implementations of this class will implement the getContentType methods which will derive a content type from a file name or a File object. FileTypeMaps could use any scheme to determine the data type, from examining the file extension of a file (like the MimetypesFileTypeMap) to opening the file and trying to derive its type from the contents of the file. The FileDataSource class uses the default FileTypeMap (a MimetypesFileTypeMap unless changed) to determine the content type of files. **class MimetypesFileTypeMap:** This class extends FileTypeMap and provides data typing of files via their file extension. It uses the .mime.types format. **class URLDataSource:** The URLDataSource class provides an object that wraps a URL object in a DataSource interface. URLDataSource simplifies the handling of data described by URLs within Jakarta Activation because this class can be used to create new DataHandlers. **class MailcapCommandMap:** MailcapCommandMap extends the CommandMap abstract class. It implements a CommandMap whose configuration is based on mailcap files (RFC 1524). The MailcapCommandMap can be configured both programmatically and via configuration files. **class ActivationDataFlavor:** The ActivationDataFlavor is a special subclass of java.awt.datatransfer.DataFlavor. It allows Jakarta Activation to set all three values stored by the DataFlavor class via a new constructor as well as improved MIME parsing in the equals method. Except for the improved parsing, its semantics are identical to that of the JDK’s DataFlavor class. **class UnsupportedDataTypeException:** Signals that requested operation does not support the requested data type. **class MimeType:** A Multipurpose Internet Extension (MIME) type, as defined in RFC 2045 and 2046. == Provider Requirements Jakarta Activation provider has to implement following interfaces : **interface MailcapRegistry:** The MailcapRegistry is used to store and retrieve MailcapEntries. Provider must implement MailcapRegistryProvider to create new instances of the MailcapRegistry. Implementation of the MailcapRegistry can store MailcapEntries in different ways and that storage must be accessible through the methods of the MailcapRegistryProvider. Implementation of the MailcapRegistry must contain in-memory storage for MailcapEntries. **interface MailcapRegistryProvider:** This interface defines a factory for MailcapRegistry. Jakarta Activation uses Service Provider Interface and ServiceLoader to obtain an instance of the implementation of the MailcapRegistryProvider. **interface MimeTypeRegistry:** The MimeTypeRegistry interface is used to store and retrieve MimeTypeEntries. Provider must implement MimeTypeRegistryProvider to create new instances of the MimeTypeRegistry. Implementation of the MimeTypeRegistry can store MimeTypeEntries in different ways and that storage must be accessible through the methods of the MimeTypeRegistryProvider. Implementation of the MimeTypeRegistry must contain in-memory storage for MimeTypeEntries. **interface MimeTypeRegistryProvider:** This interface defines a factory for MimeTypeRegistry. Jakarta Activation uses Service Provider Interface and ServiceLoader to obtain an instance of the implementation of the MimeTypeRegistryProvider. == Document Change History === Changes in version 2.1 * Jul 09, 2021: Jakarta Activation is splitted into the API module and the implementation of the API module. === Changes in version 2.0 * Apr 15, 2020: Jakarta EE 9 version. Package namespace changed to jakarta.*. === Changes in version 1.2 * Oct 21, 2019: First complete Jakarta EE version. jaf-api-2.1.1/spec/src/main/asciidoc/images/000077500000000000000000000000001435131260600205135ustar00rootroot00000000000000jaf-api-2.1.1/spec/src/main/asciidoc/images/activation.png000066400000000000000000000051351435131260600233660ustar00rootroot00000000000000PNG  IHDRGgAMA a cHRMz&u0`:pQ<PLTEߗ?gߗ??ߗ?gg?g?g?g???ߗ??ffgg??gg????g7g?g??߷ggggg?g??gg?gߗ??ߗ?//'g?OO?/gg?g?ggggߗg??g߷?ffkbKGDHtIME+#7IDATx흋6Ǒhjpǘ&NK>{ov: 0l>}⾜t<bX,bT%ˏ[-TC{k5`&ԁu1!bBń Q.&D]'0uC22 \iy;ݗ2BTRrS 1r =%r` AL½6t+:œ\rLgFo5.'5;Cٙ$$c(iPKIbK+0!oC(!uP큑ɶ\bD 7^cuyg-,f.]8_ǸT$(i7t?*hi?P QW )"+&D^3΄:Tݺ}NОu uZ9\wrXwPugB{cB{sBY[wvpu2};qISEDw!nܰWc@{vuN;1ԹGp+iIS(jG"C^V 3j*#jCμʹqKrGDvm;L%;a@-!wSE+S=2䖐= kĐ#B('SyKsrQPc8 !{ O<9C{RBnL59Jq:+Jĵ{O9O(NiэL@LuvhGDF;.&D]L T֔z2BhPwJ ~A/7|݊U4_.zȷ uЉovܿ]ǰ=jCt GB zO u<~(Hg/l ·71#'DKRAVw# φ=$TŠ F&٭/[[<)z0㞑I!%4~G4^DR࿾Cfr#!rq| ɍTn:SPM#-炣ZbT0pNV*5|}s/CC*g"pQ+R4@atV<Ȯ ȫXr:ڄpt848ި2򃂢AB)cXsH(?WKm"3"i pH[  loWˡ2BXAJLjjNd N]1ntVFH * uƘK ߈n2^ڼZu1'%^nOޕ5 fUBV?C[ r!!== jE:("R݅qR{"/gH/_ړwmw6c fݎ(ԝ;B;, $$W"Jv$UXVt[,Zw=IhlOU2dN[@nGI.7$14_r.bKv1EQw5IΞȀ@>C )40@N ;ʧcURØBC]KE㡑,ZN5 o4!pO.tln`XPA11P\S%S$yکLQ.gH'r#l1M/̩J3v+S3ǥRdȗzJr?EUt3ܘZ6=1tHf1Ąv7m /Rd B!8,1&mBȱW7Jct:E>Ws‰q8  @=#G&]^[8:ÍiW$CϏzG->$~#JSS_ u1!bBń Q.&D]GDh_= QZԡAQbBń Q.&D]Lu1!bBń Q.&D]Lu1!bBńX,bX,bq|dL%tEXtdate:create2019-04-29T15:43:35-07:00x%tEXtdate:modify2019-04-29T15:43:35-07:00 _LIENDB`jaf-api-2.1.1/spec/src/main/asciidoc/images/jakarta_ee_logo_schooner_color_stacked_default.png000066400000000000000000001336211435131260600326350ustar00rootroot00000000000000PNG  IHDRX@ pHYs.#.#x?v IDATxMrWS26@N;@;w`Z9 ;螙 i0tťr(TyH:m˘}T9 p_s&1,GSh-#qZwX.!0r/aϻ(ayX.CYo @]ic+H M]!aKxG<0sv(_{?=0R<;o` !\??Q`N(4aFH9hcFy'aNˍ7'02<Bo:aN4Q>0><@w0+M]^aP_3#"14uB؞cq(ߞ2 0"<(mZ?Ȕ0GȀԥS0<CS[![ 0#![,)ʷA7hrcIQ>81!ktQgUM]~(ay8D3q<0.$0# Qu.`yF˵v(RS.ʷ'e2 vFQ>0|<V 0p0:]h杽 >N0:M]~qNð JS!272 Fo:1&0 M]$aM`(ӣy˵ ><v(ʯ{:5%0XݩFX.aA|{RJO0P<s(_wayhQ>xK`P !wrjH`0`ayˍE >0g<Eܤl`yz^ClOo yM]gF(BX]g#;M]^I蕦.B#yaEgHOG_BqdF)aD kM]~=(yal5uBʆya,uQt%̉0@v!Y7`ye{m˶l` yEª>pB<Yhr;)/ʿ0<uQ~#o%@$u(_Zf0@j[95 LSmLHLXyakrC?=+yMD3XQtjzN`)lG4Sy;!U>=0z< ]"Ϗs< Za[+azN`!(ߞfs>$(bv?zJ`ʩy1a-S](azL`nZ_ B ES!Ls)8.6ɥqbzLT!/ݕ}_ak경ReC<'Eª &6 plM]u'Et< =%p,]qyr<0L-9W@O ǖ(c04uFL+`zF(ˤy!ajrCձH(ۄ%C ( 7>#ah경|dW!a?Nadwm>]SWE~v0KM]עl#Cw\K<0@{MF-Q>a`ĺ(˯^[oyjrSc00BM]nazB.߶Aq<00"M]ɉya`$lOUo 91="@wB=HW>a`ງAEaGyGCPfǃwe>kK.6f"COE[::<00 M]~)ʏ0=! DS!osy a`(.GMz¦=0=!XwB8zW> aN(VfGJ`$"&= ula~,SS[U)\^!;]ͫ|PazFWkbrAmQ>~dF7(Ӄ+ XS[GyCQy aE_yb:#$嗢<=o@yEm5'e7co@yu({dd(0@6;鹦.EyzB~yl׹(39{yIo2lY,MȦ#2E>8 ord /<KEy2(H aU>'LD`(?G63 w(ʏaz@`abU8ʓmQ6dF`!(3&.DIr#0wvJ;.{pUꐱGyjKQнdB`n(ߞb̈́%j}p3?5dD`.Ey׷D]0YMQ\aSUM-V 2"p*;ޡ(ax3jAFyN,Vņ(OJM]EyDD(>o|{R-'<&}8=8 GyȈ0Īh)4#cScqo|{R-0v<v(^-VE{5ئ($.=8 (VUQ>/*n;z<ĪhI QsJ <tQ#$Ey"ʓTSv<@ĪI-K&.{p@X_pc_˫<0c*G6CRi}px[z$.{pz.@b<@Ū!ʓQG =b:irKz$.{pNHXk<5u(#(?7%l*&dPw7tQރ0<@a`ɺ(>o颼 a`bUlUQ$VE{M*M]o0]&tQރa`bUɀ((Vzwu$($.{p͚I@z<ĪXI˯Ey s&ʓ. ȏ00GIL Mj(y$VE?3ORi경;z o<tQ#$Eyo@KQ\Nʋ<)Īh II+ P=I2GyUiv$%@EylTSmycA=8 =%QQd߄y#袼G6IF')QCxX[<)5uپmi 0 <[tQ}$EyobS'%QX  !.Dy`΄yȀ0.{dd(a(aXd@:*ֻC .Dy6a(Mꢼ`y`bU( &ʓ. aCQ}$Eym QGF)VEu'.׻##EylLm#%KQ00FolTDy XtQ#a@/Vź(Oj< CE&ٽGq:_K0 ١(>oi|r{ż-%@z<0H*G6DyRj~ykrg0 N=IRçlx0 (O^F[:<04<)~IMy`0bUw߲QRi݇KD!VŦ(OJ+lދUB&Ifք??ykLXy("Ifքo܍#/ @oŪ\'?w}ə, }KybUlf)ba2 Eªޣf(0J5Qf?Ay0¡(H[p<ۢ<)5{/}(? 0Au"8LN/ @ֺ(˖HwNCl يU(OR< @bUli?Y0O<.߶|?l @VbUvOO:x0d;6BJ{vty0ty J国!<\¶(OJ/~e(ߞb<}>=|`)y CQ-('+S ~#)maQïgh7<D-'6}$;0&m K'ʓQ>ƅȈ0U!ʓԬ ~"tQ̬ >YG8?`)bU|.ʓQ?⇍UB2iR=x$d aX.VMTf6{/Dy`Vn!<0*6{I(?Y9aXXk!mQϧ}5&ka.ʷ'寙.Q~y r#-ʓRߢ<8 <0W*BMTt?2?3ȇ0Mo(Qi1]SU(OR_zLȅ0ZW&I2m9KxSmS$.˖F=|z/ \c#9寙τy6EyR ߍ!b+pˤHwNɥ\$rΞ-@>yDyR=C97U!ʓԬ Q "EۦC2m0kV{3Nɹ_2#sQ(.} 3@NyObULf"0;!~_B=m^*Ȍ0(OjCsc~ahZa['"i1 IDAT0r]oO_,Hnə >O2#ۢ<)5{/=(vՏ24; 7<LWN2&̾iwQMy.߶s5wQ,̙ >0r>ȑ0#(Ojd4Q >0r 0*CvMJ{vtKNNaծIދќi2S~!a,VZwR^'OF./| W@y.ʷ'14OOG{~0p0t(__Ri]3| dHaI)Nè|{͙22߭ &tQ~'{5=7Ypb2'䠍 'a?Vnqb2'ŪX !l<}>c"=ȟ0 E53&6<>oKG@8-= $%/de1}_yXX[<)~I%W ;`κ(\IwNC,ay&g;wNG9U)ʓR?-ʻf&>2/ ʉya$VF $Yf+'l`(,Ifքo܍-!.kYyljyaN)V QD 81y8X!m3$ٽG|bs\&y8.ʷ]| I Q>35=[~8Xk<~}&arf3<0$ʓihϯ\Gdy aPfnFك- > ,81=!l5 |Ξ<ܷa(VE?3/Rp?O- ?a;<0GE[fE*/݇죱?CwU(OR&|3Q>O; ,xzDUBƌHfͪ%i0ï#<AotQ>\Gdya^#VzalHGODM.^h3c <n]B2{v㿦@=7 ypbzDCDyrFf=1 ܼya:*B[<)5OOE;gdgy#ʷ'寙Q~y 3s57 aQUqC'._zf#<0hĪX!l8)=br{xzH`(BXqRi|BK}@Xk<<~"scazH`Dyr<}>m>Ly +70`lT(?{ > ϬI`ȶDyRQ~]i ~ )VE?]Rp?O-`&/|0Y桧ylT^F!FjcBO J/Ey5mU8ypbzJ`0bUlQi?Uہ@y)aAm$.˖0ls <ܼgO<b]'=Gr_7ZwlfM?qgdïc<u(ʯ"Q{L>t3 C R–(OJ/~Gï@A1a|kG*ç LVaȃc<"ʓQ1>g ,<[yGMQt?$ZH]\=3Y5@ FN[6F*m?pb` 49s<bS'CQ6#6x飱Ȃklyb#M̬ ~"36YpbzN k]mK$3k?O,a;?c azN [*>I- rΞM@ d)VzavHiv(&?lLȀayEªJ国<\iر?aĪXImQpL81  Q4OO=_LΞ3 ~¡(FH[;9XyGŶ(OJ_ FWX 0@r*BmTt?S M&zsȁ0<IuQ-(4ɴQwC,#2!@,]o7w\oJ@~Xyg"`y*Vź(OjD&^4, NÀ,MwLf'QM.^Ȱ 0 <Kq(ʯ8Q{2H ~8X!-$كǢā _NObUEyRj~y(O KkZ]?^1Ri>>&Gd‰y8aEk&B*/-&>:0x Vnay~)ʓRQ&> ȁ(# О !2 Ri݇S G~00<ȉ{Q%tr@ya`bUl$5k6'dU6{ۍ:}?$:X-R,G2etzwVojv@ >=V@ պ) HP`IFC.Y./vU͍rhER1fr+?ǀhпzgb9` @E>Qc$!;pM p 400EBXwbܾ/ʓ༅)p 40 U/Ob; n7$#۷mpbBh:)5QdoZ [y{"y(: <1 < <+zVDrU/Oʟkb)}@7 @(OLÍG_$=aM6@yha`JvL,Eo+ n1R<Է y*ha`JUQKBQ8-OG޵ ,EBEuV'b/S/$560<):3!+ ap޺(OffkO@ yha`TQ`W[Ö@겿ʒ0 #LZ剭ޚ(O]d, @坴"%tR!-)540Psۢ]K>/]@5VtZ! <1 oԍ偄81 $Tr! < W7|cq<+ya<<@ mX(?}ԒD8- %ӊ(OLEo+ԖtP<@V?7b)|ݞPW"CC 5REvF,FpZr<C 5QtZgDy CMQs<yy"2_9K/C']勭aˠ/$DVtZK!svDLEyD\r<40*ʗ'\B4ÍGD3)$ܡ5 <-a`(_~{߼eaoC4Jv+\ l[?eRF,}56w"S <ƞl^R;y1*:2lRF= 3$`3owy;y1i%o|Q8-O#eGq<Q <Qп~oS 00bU?oDSFw`8g 4U5<y剮Ved١#p%owoZ4a`DNk)p<5QB:z8-<00U/?x:h7V׋z?e{6~ @/<0N(Olenq ^Q\̐X(?}e$56s N'*QRv$‰yไyWPtZ+<10rc)7mxa`(܈kw{([|W6wO)pZx!a`N(OLVIioY5 +0CEu&"0 [3F$`3ow/["<TQY`W[Öϖ}])` /QtZ&Kdy/_x)aNkɩ'bX%Ckf$׎K QEӜKDyxf$RnX2<3ּ(Ol{뛢v@N(OLۢ+l 9Rb @tEu&k 0 ~5Qs [y{2q(f0 w֋3 Nc%'j0,7<+jg ݋L0Ei !MYEA²- N%#WE&K4U/-D a(aZ剭5QҗZ 36v)owo0I<02Uw7'Q n_/?z5 pZ8amQ~DÍGNC);{h@ty+'櫓F< (~{`]@.X0*ʗ'O$ < >kPٻ;.-1+I(>ˀycZҀekbqN'_{M+ny ax%EU~9mzRFP-%m?@]+:s<1mL6֗afڀ> [b]):3!_ a?PO'H@T<cU?obD3;V%@ );8os@lv-1 ')pZEK֒06}_ˎC |b n7Pcف_f{Z!y{؄y๊Nk^'k<_1oC)pZH0<(O yPwYˏg@d壯,H0mQK y0#j0,7 `c M \nX<P/̕X(?xuZ ( cg|yRK`f>\ <ѭ=iND5x(@ZNkE'7Y0*"+O˯X)U?m.RFPN#<`:+S偑O,:-xn0پ7W nyhmQK^1] M x>aY剩Dy`"t< 4FiQc'<ٹݰh*ʟmby텢pZ,y^ij0 6Ey`ܜ"iyjU?oDSFw`8g 89-Dv+owW,`gy(OtU/-7< <S贖oIl߯$d9-Dt)ow/X L*_ !:h7V׋zGl0TIA&";td5X>݋;<Sʟ_iaO&)brZL*ʗ'uN(Q~p> &i={y{vO`ZD%18-DB8gFNkE'_LR~C偈(|( kw{(&'{}afЁnIxuNP[EuN'b/QDy 3zyj= uQ,ߛ3x Ky{^0@TQ`W[ÖLZ~b1sZiyH'6Qfvv3?v‹@,ݛyj贖Bl7VEy D " !5|*ʗwYSh(?x$qg-?z̻@,gvwF#+(HZi͇n49\{få [y{FljyVEy'jaOb*y`Ąy-ʟ%b)}WGQ" `yR"SU/@l١#<$(K C<ov0@r(fqviy {ٞp+pc\!- ˟˻/k߹ن5E(OTa_c@\Yˏ" y(dEQ-$haq e΍(!S+.єQby ׏L`|y只w"%3mDy偔nX~M`|yU/Oo&SkET ?֊zGlHA^~w.~\MC YC8?_LpB}Vcݦρ($kfg!۳ׂI'M arYyrIb[i-UOcs n7@m'>$?R _-#ט(O Dy iyO~70i_'0\ y&R~di]YX\&zB}zFLe9-İ>$Bv-m^DWUB^( teyo~σ@ݳaxe5E Q{RxTh+ydiVm^D0 Epn9ow/<@Zy`$mLI\ xPpa_^l7}@< D##T]osj&ԉz>AB}@df>\:bgvw#ciu~Zd[~zZUOҗe_Ϝ7n˼ݽ`i恱㰻%׀P?7Vׇj@$_'.a3MP*׀P_?pP|"q @ D-,.RzB$ԧMO}MP|"q @M9=\B}8Dyv< QR4 @4NϿP8~V_u( LK3|z恨>qBhUQiy>< q)ow?2{$8=J< UߨTꗪ?(ԕ_\aPC< _PӚDP,a_Vl=Jv;L+ljHῢz?ܯ E7?ff $WԔ0$iaqdaC##'Nn@-ﵾɏk{Ƅy i ˟Ֆb{|gOLBp(ϞK?0i1aHRuz5uB}b9ԋ@!Ir @ @m,,.A~mc#'nZBჇzj)ZL+l0r/x6 >qu {%Kؽ٥y_ԛ0|uǶPC(-/v?aaسN' MHjR Wп ek3. ya'aؤm>u^OLP_B^( zʲgNl^ &y{0^uY&OO$B(L7<0I2<05?Nϻڦč<?oBQY@}gm6$WF.`TYX\>BjZZ~0 w֋ᆎ3?iN`9ow/8t恩|6SҶPHbvEy`JO|'I]~jGmP0 7֊Gᡦ ٥ͅY&J5+l0L5WL=>a V?{B=P+3.༥u#FpMc ꁺ>Cۼ=kK6tiۃ̏'Dj!ϿKyL7ahW4ޕmPH-R4p&\ƿjӶxB}„z ̇K&y{04*лچ' D/vshahj> IOPS^~>C&Vu7Bڦh,x'rl6 IDAT$s^4q* gC1vS'+ɲgNl^&y{ִEfaqqŽ">aB={oc'Ty`R.G <tHХmCĸ%0{/z !.Wc0OV{%0yT= B,!>QB=+lr<$GaOB*ֻ5B=+l r<%GaBW"ef>\r 0)ไy(,SNOP/{̬I^y^H*ίx%woX p</%I(Eq%d&Ƚ00f LC]ylo3q 0忩`'y XX\>BYSdL L¯vwŤ a`BτΛ7|P(i}l-&=c00Aգe3wx&>QB=ƞٿ#&Ju{1a`ª8!K Ȉ~ W_+<@ Uhl`ܮ)0*<@xʎ )B}ڳw}vg>`7jNzQ&C-< XC{ȲgNlަO?0r<@8.pڮ<9Q/ԧC>{c>`< X5"C- -;86ґ;06<@0$ԇy;MUtK? 3 0f{`yYX\.O휷7B}`_B׳B!id !,yqjHvCUi iȏ`sj{c0PS<4ƭN '/`mG?u<0n{`"y[X\.cЅӃB}1ofwy!0 <@-,./UNf$ԏ̇K!;8?MI@zOI8l=_s3w&P_ǿ*򷏭68]+#L qxͧN (:'gٳw}vgSwr)ow%L*W9D O̩{_goR,`8ow[ SFvIOTCWyb L!qx B}+LvS a`J< P`0޽}31 SLҶB}""ԻW+ߓya$L*Ηwg~l cw<0fO-M 6a!8ھ zw<0fIyoaAy >AIz]1gR!48$ғdXD _v9ay 1WDz> =cFh(qHPq{1A Ky"ay&nXO= ˕Wf$ay*7?03BXݛ @yyn=ꅘ(ԇzl© e e<-7' ?o 2ow/$8L)&z5*owW :qh&z`~u!yawn|^D s|g :x&qhͧN •]2FyDŽqvwaP_B=Lⓢ<u%R< 5!جNq`ǞUhtiꡖDy0ҶB}z_UPw<"P_B=$G`j80rB} ov0-y^80VB} 01`2q`b< U00<SI,,._&N^ە]2F0kYX\P_B=JGy30k#׀P%0yFBHP΍nZWzzxl3pR` 8P:Q/'H6-i'0R<@- 5 3DyE`3g$׀PhaP_B=5]@D`ly$_BS  QF+q6:Q/'H'A<%0v ˟ͤCDyM`"τΛ6@# 5 3A &qP_B=cy1\N`yaCUhHQ*<\'zxKB}ڄzvImy%>qB=/ Syx B}z*<<0@T ˗}P` $sD<_+OB}7L7-By>qBT)}s$aaqy%s6kKH8@DB}Z`yRVl{|g7-$-B}rDya,,.rB}bDy%a$$NOP?1<ad-,. !چ>qBXyB8mKԌP8y|!MPce-_̴"kH|2|@`Zl>u^OP\<0@-L9>qBc<0@m,,./UbrB} ?o\QFHVyJ)_Έ0:<Il-_l0R4%=0@--,.|KO\ C(c"P[ BAx&>qzQHWBm^JO\B^1S6 riۃÞEya[X\8ʶPQOB("0OBs6 #!'nġy{v KU<`ĽFU4rh0TYX\$o c''n^yry7qd9{h+ 7,p@ 4<'`zD-XZD@'!HXq2}UYUQG ;'w=[o+;M0@6O&Z~5 c3kB0@6OƪtjJ57Ӈ׫ܙ`_O^ܴ`%tms({QS˘USUJvн퓳a`f}w% pJ?`~p`(}|< p~9X;\#+6O<ʗO~5'G)ߝLwX`n}rR:tnV/-6O 64S N.y"oU@a*'r/  b=l e~(lnL)\|kG">yRs_ m gWx8gU mS1`3X`ž\ jwN0O0}RypuVA<tJ0K,@*,7К_`y6Foc',t}޿ŅXyx"B4]r)6漝xiU fmxUVf0/0^U<PyX!BxoTtb6Pln~rn+-j.\ <:PƟDgWXn9ǰgE0 Fy3?cX)mV`f'G)ߝgX0h` >CCl*Z<qR8p+]P1ln7po_N <}R9&?s*퓗)w:4nz>@Pزc׹6qP~4U"|K<T},OCx<T}rR5`ƾ\iU΅`*>C=ׁyR:ř 8z@}G)x˵ :FOboT`>+w=bRu<j  퓱"51CO^|v!VOy84q](UnWsy& ׆5՜@^B~1+@yJyM䵫HyKyValWzUT@`c\!ىC07#]x 7́1yRsݺ29;=`~RJRJ[] R135K 0<̔~Mt@03}rRu gO =`SJSJ, :bfnsyJ鿮:&lnL)Z'@0>yRqA-R Ў;yb}2!I) N0>9K)ռ 8<u+_wXyhɳҟm_r {`Ÿ \ڵ_RJ? x а퓱krryhz@SJcx:]x2и1u~kY1oR>τV6Ї))ޤ`մNln 3'c%WJscQz@RJRJ5b:}Rk?9@gЩ퓳aMXV6Яq#)Ne_8:]|S7[JPmn}n,}]cΏNcgV6@-m4r&ަDbjsd O^8`EJiwgm%1~pz+SJc1Jcۧ/>~s0V?07Z>yR zfT0k*Uό*yfO<p):;>}xqR-yR<24VT:I}%Zw>yRY}hV6>}x.K&o*I*>y6_RJǟ>8sEhyࡎx*y<S1<ɸ+>c6x+yQ6O+8k_]z XG9T)H<h'c_oV9DɊCn#SpuX\N!}JI3WXy@X,٭r;XB^2ksv=h{8\2hqDRi뿇qX5/׆~` .alXMKl 'y?`}v}A6/К.3\9ӄ0pS-mv_ OM`h.1knK?'^,fhqCpSO+f_H}~?Ψu86.fΛݨ9oU\{ @p9~8тnjOGo<Bߌy ~x<4͵֜pn/ Z5|uL)YGF|ΆUm~]`tϻnZmr+8A7Cl +ntJl0kyzW66ҁЮݬR^ Ƥ:8cpV DK8x<+l5ml&a-9_sfK0O*-|jZml[7 K_Ф_}םU٘0[yzVJ66ҁV~HK a87Q5:kA/b(P66-,ϯ*QqK {ȳQ:fb >0\B00WyTicnRKкe)A7{=k|B8腍+٘0KyzU:yhI@h#? ^g$:8,XEmc3њ@0Ow/R<m_B(S+|hq?fo!fG0Oj,\ a~h a88x\nޞq|Jx66Jl<`v(zIJ7+fX3qX;ZVąO );669y2_Uj NA7{ݷ|Lðr?:|Vzevyz3*U/;A7{C*eiXyoiEGTjg%"7ofmc3Pnmù#Lyd}ml&ZstcfK?W/C w7{]zr%xqx66Jl 4'W _X?t `̭JЭp<՘,"(,pbXZiC'A΃h lLlD5!M/nn|x,0>$^^qR;eEm-t!WްrU7nf"Om5J[ॗ?D;xJD<-0ysfA0O/ZYF~A*ͱ fmvw=8 hEPqwy.3Zy`4/WiVx+jT;7{ t~6TXPaZUޏAq_z{UԸ , A`c%t&fojrwjٕÕJm&ta`{Cx @xyz0 $7 aZwG;ojyZ\F;9O0O Q uf?W5"b|3w`~?nc3o( i] ml&5p>DfM1)^8\͎q9O|gaf_-_ｋp&u5RS;)fTR6X`^W^U VVp$s"Ӭipױڹj%+khm*0+aoVWyˬsuhgc.@XyZL+jL2Cp6dxpv68kR=3wTo%a iYkj6fbP53^.hVlg74)WkBI^ ډ|봳!_yi%,\fml&52$U5RY5FuUG[Zl'Uv68,X ٌ_<\5'! iN^yX}ɬF0߈NmJˡBך '?=P[4ZQ딃guUӊ7NVx}Dďx9+rsϧ`f䥟5̎!bq„w>ozi#XJO*Rw!BUtX \V;N0O zn0QIjdیiCP!u,op0VcfR;5' 晵\A[=Dic3u^ﲗ7%\]8 7i?A3r EB7^ ;Uu(j/R_E|<&*f+;a:^FFK83wU$l!jX =ZV}t66Z2T#gϭ D ԙ\^RuS P%L< Ӥ\&b(e`9SyE6 [! 6]/^WjMfC< iWTlg%3Tt"s9PBVC(O?mlWP3KygQL.*6 _y÷lEsXc ~66li\LP>y @o̕*T\fymIU)>wU՚Ćb;q,Ђ߆|_(OenPq.5'U晝V 9+f_Fnjo]p=ME{c66Zsc 晣ZC66Z7{ҵmL8-revDL8c쳙TlMkN!glzK@ڵ/@Ϲrj}CTlg^b~g3yPkx?JǼZsP`YncS%P~8 rm[HȮ?lm,"a8<ыǼG @QyVۙmBVfvGr xyAI\Lp7?Jo o\ZrNji @QyVEzVngҤMG7(Z}mNP;>[KD[Ja8ʉ^/$9(I0l䥟zlq3Z!`=gC U[Ł@rr%%W똅 D3=U2WKP`9>qjn(a |ȓC( Ul~-K#Bskc3Ud%r;&m7]%Wmvj skzZ{5y{tmlr;!gύJ:˛٬V=8"$Ъؖ?v6blW?yS3-k2˩uy3OԺS,ʏM)AޱNl95a%MYN"#9(J9 1Z,Wڬh:z5 O 6F8wc(n@d8Ux?feo\YYW^7 ^||طX\VZwr5{; _3yfu rPf&3OjWA޸`W$W^[Z8Li&y=sfgOxfJZs>_r/Vv=vbO3ÿWz#VDj}&;2soc3?Uxݯ9 `F<奟@9Z+qqVO(AyaIV1yS-Dnuz YS^djd^Ykl Z ըnE[i( U ?MIiKpbKPk|p4I0Ot*[i0yc$k (+&DOj^DyD/Zic3NyF0OXygSk}+4~V瀨:{,!WZZ8<$o+P/wr{؟\x ժrm,5/TIe23~=~ׯq{ڲjzCZrp4G0Od'6 ¡]TXG*WOr_"R5O66Us% R^QؚlyQ6 1 寈2rvb+d pW`# IDAT52-Vng#`-Dez 6깬Oa PKNl=jÂN^-+D(iw"Pal`G)QmMOe֫{ԚJ^[Zo0yîbhT [H5V"TCYNz4`jV!hSȱjy_:yRSP~2 gqIU?/g>ߩ94q?9՞j2V͟vү; RiL8扦f5aMg{rd͵; ^u<~8ReP5C=9V܏1@Z,^ǙвEF??~PV6~֨,K@p0_87gX hN?n.>X<l°zc(? HwUO0ÖR}ɭ^y*i}U`¿՛S(-$CJA_ ۟(ܡPo(+!'dcZ 8Λw8|%堨B V5P2њ'`O{y1oF ]ErZRqn&4\O;O&_/Ft.P>Vi K5=rnd,}B+BU#WK%PS1wWWm8bܚ+R\+cKPogA} BiHn.}`NCliup~3x#XEbv]J'-ĸCh W(o Xb/j-+ʫ"=|T5Ouq2A+o"LBnE+%W4!"؈'5'JڢULvsVs.sJn75'ZI0_mYbqp4o.u4–6 &}o}^kOY X5oCiJP-9I|n]3Ŀ>KXB S%vȢ}>"FBvH[`"]9l`>o4V=p>t{879K#W|u3ܹ0 Vɹw-NWm'&_ <=7֜T0}+yrM*͆hxY3z]`Zfu8\s I Vju2iK & \=>V޿aFɏ\%?f~4!\i< bG*Y\,U᫠ ig@T毄aT!X|̽k.(7f-j=mik˿ډvPg;γj2جso0N_{]-,{;sSj̦ &.A`ZA9& X5=+V{.u7wZsw\%_-,s|\2"Xs%nðs}jh+ Y=Es@UwM0>ڊA* Jg_o乳yBᶃүv# _Æ`ඐzWge4.oZIagpg|mQߛ?jجWqھUp'jGo{kr֜*c c.s0. s@7wpZvŒ0h f8fo%``4@>.@oUKkhV@AyL&d&4FM7#k |t+E3+yI BwjwQNXƻS<ܞS>l16spVy^`F؄Ov^SNVT<lBXVabC`vs3}0 sʊQ3bg^_f(X7(f]DX^w' (, 5wFB4֪c^o{6;釶u͝/(ppvI\7:قl y$rΝ(Ds2)| s^f];'FMwnxjօ(t&Cks&Т)8.h''aTԺ. 16>9̽( TrpaGҬ4vF4(p>óvd첝#[{۽ePT*!d8cY1rQt;aq21_&]]P7 /x1 hAxEQ.u汋3g+9~+̇1yeLiw2[?}),ЭFlVnqbyS(0kn2c.㊹ |8%v'`ea$R6,c{ >lNJ}Gb6e.7hN2W |.'xCbДhۘY0Oa8bwϢE`| *Wη'geL=CNaMsbFY.B?nڢ؊Kl&qbj;myW\¼9^*̇D4so5)\ޫlԤBԺ ;6P3E<%gg ќt@f.̇6_/뒟a˿u/b &h::o׷{ >qbDa x&5I|bF7&{WabS↧81KO+-ޟ͈Z-x#TԺLB?)65wE12e:xa[2* _O4]=RXkR($Qק0S3{?tI]v%2l%ќ0_O㻯؍vBAA]gg"ACke.Y8.*cylR .H,{\;9cs@&^XM,E|1I?YY.?r m|@&˜ނ8q of9P-hN2 ;${Y.OJ<*) p]]c'. Q>l|W[[Q^!NL~f(,` u eq; pn`?묋~aQ7c;p#M >׊H͝}blҢIؗ@q8-@]`c?sOOO?m]9 UYEpL ~o_<s!\>ˢIENDB` jaf-api-2.1.1/spec/src/main/asciidoc/license-efsl.adoc000066400000000000000000000061321435131260600224510ustar00rootroot00000000000000[subs="normal"] .... Specification: {doctitle} Version: {revnumber} ifeval::["{revremark}" != ""] Status: {revremark} endif::[] ifeval::["{revremark}" == ""] Status: Final Release endif::[] Release: {revdate} .... Copyright (c) 2019, 2021 Eclipse Foundation. === Eclipse Foundation Specification License By using and/or copying this document, or the Eclipse Foundation document from which this statement is linked, you (the licensee) agree that you have read, understood, and will comply with the following terms and conditions: Permission to copy, and distribute the contents of this document, or the Eclipse Foundation document from which this statement is linked, in any medium for any purpose and without fee or royalty is hereby granted, provided that you include the following on ALL copies of the document, or portions thereof, that you use: * link or URL to the original Eclipse Foundation document. * All existing copyright notices, or if one does not exist, a notice (hypertext is preferred, but a textual representation is permitted) of the form: "Copyright (c) [$date-of-document] Eclipse Foundation, Inc. <>" Inclusion of the full text of this NOTICE must be provided. We request that authorship attribution be provided in any software, documents, or other items or products that you create pursuant to the implementation of the contents of this document, or any portion thereof. No right to create modifications or derivatives of Eclipse Foundation documents is granted pursuant to this license, except anyone may prepare and distribute derivative works and portions of this document in software that implements the specification, in supporting materials accompanying such software, and in documentation of such software, PROVIDED that all such works include the notice below. HOWEVER, the publication of derivative works of this document for use as a technical specification is expressly prohibited. The notice is: "Copyright (c) 2018 Eclipse Foundation. This software or document includes material copied from or derived from [title and URI of the Eclipse Foundation specification document]." ==== Disclaimers THIS DOCUMENT IS PROVIDED "AS IS," AND THE COPYRIGHT HOLDERS AND THE ECLIPSE FOUNDATION MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, OR TITLE; THAT THE CONTENTS OF THE DOCUMENT ARE SUITABLE FOR ANY PURPOSE; NOR THAT THE IMPLEMENTATION OF SUCH CONTENTS WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS. THE COPYRIGHT HOLDERS AND THE ECLIPSE FOUNDATION WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE DOCUMENT OR THE PERFORMANCE OR IMPLEMENTATION OF THE CONTENTS THEREOF. The name and trademarks of the copyright holders or the Eclipse Foundation may NOT be used in advertising or publicity pertaining to this document or its contents without specific, written prior permission. Title to copyright in this document will at all times remain with copyright holders. jaf-api-2.1.1/spec/src/theme/000077500000000000000000000000001435131260600156465ustar00rootroot00000000000000jaf-api-2.1.1/spec/src/theme/jakartaee-theme.yml000066400000000000000000000241571435131260600214310ustar00rootroot00000000000000# # Following is the asciidoctor-pdf default theme [1], with small # customizations, mostly for header and footer, marked "EE". # # [1] https://github.com/asciidoctor/asciidoctor-pdf/blob/master/data/themes/default-theme.yml # font: catalog: # Noto Serif supports Latin, Latin-1 Supplement, Latin Extended-A, Greek, Cyrillic, Vietnamese & an assortment of symbols Noto Serif: normal: notoserif-regular-subset.ttf bold: notoserif-bold-subset.ttf italic: notoserif-italic-subset.ttf bold_italic: notoserif-bold_italic-subset.ttf # M+ 1mn supports ASCII and the circled numbers used for conums M+ 1mn: normal: mplus1mn-regular-ascii-conums.ttf bold: mplus1mn-bold-ascii.ttf italic: mplus1mn-italic-ascii.ttf bold_italic: mplus1mn-bold_italic-ascii.ttf # M+ 1p supports Latin, Latin-1 Supplement, Latin Extended, Greek, Cyrillic, Vietnamese, Japanese & an assortment of symbols # It also provides arrows for ->, <-, => and <= replacements in case these glyphs are missing from font M+ 1p Fallback: normal: mplus1p-regular-fallback.ttf bold: mplus1p-regular-fallback.ttf italic: mplus1p-regular-fallback.ttf bold_italic: mplus1p-regular-fallback.ttf fallbacks: - M+ 1p Fallback page: background_color: ffffff layout: portrait margin: [0.5in, 0.67in, 0.67in, 0.67in] # margin_inner and margin_outer keys are used for recto/verso print margins when media=prepress margin_inner: 0.75in margin_outer: 0.59in #size: A4 # EE size: Letter # EE base: align: justify # color as hex string (leading # is optional) font_color: 333333 # color as RGB array #font_color: [51, 51, 51] # color as CMYK array (approximated) #font_color: [0, 0, 0, 0.92] #font_color: [0, 0, 0, 92%] font_family: Noto Serif # choose one of these font_size/line_height_length combinations #font_size: 14 #line_height_length: 20 #font_size: 11.25 #line_height_length: 18 #font_size: 11.2 #line_height_length: 16 font_size: 10.5 #line_height_length: 15 # correct line height for Noto Serif metrics line_height_length: 12 #font_size: 11.25 #line_height_length: 18 line_height: $base_line_height_length / $base_font_size font_size_large: round($base_font_size * 1.25) font_size_small: round($base_font_size * 0.85) font_size_min: $base_font_size * 0.75 font_style: normal border_color: eeeeee border_radius: 4 border_width: 0.5 # FIXME vertical_rhythm is weird; we should think in terms of ems #vertical_rhythm: $base_line_height_length * 2 / 3 # correct line height for Noto Serif metrics (comes with built-in line height) vertical_rhythm: $base_line_height_length horizontal_rhythm: $base_line_height_length # QUESTION should vertical_spacing be block_spacing instead? vertical_spacing: $vertical_rhythm link: font_color: 428bca # literal is currently used for inline monospaced in prose and table cells literal: font_color: b12146 font_family: M+ 1mn menu_caret_content: " \u203a " heading: align: left #font_color: 181818 font_color: $base_font_color font_family: $base_font_family font_style: bold # h1 is used for part titles (book doctype) or the doctitle (article doctype) #h1_font_size: floor($base_font_size * 2.6) # EE h1_font_size: floor($base_font_size * 2.5) # EE, squeeze title onto one line # h2 is used for chapter titles (book doctype only) h2_font_size: floor($base_font_size * 2.15) h3_font_size: round($base_font_size * 1.7) h4_font_size: $base_font_size_large h5_font_size: $base_font_size h6_font_size: $base_font_size_small #line_height: 1.4 # correct line height for Noto Serif metrics (comes with built-in line height) line_height: 1 margin_top: $vertical_rhythm * 0.4 margin_bottom: $vertical_rhythm * 0.9 title_page: align: right logo: top: 10% title: top: 55% font_size: $heading_h1_font_size font_color: 999999 line_height: 0.9 subtitle: font_size: $heading_h3_font_size font_style: bold_italic line_height: 1 authors: margin_top: $base_font_size * 1.25 font_size: $base_font_size_large font_color: 181818 revision: margin_top: $base_font_size * 1.25 block: margin_top: 0 margin_bottom: $vertical_rhythm caption: align: left font_size: $base_font_size * 0.95 font_style: italic # FIXME perhaps set line_height instead of / in addition to margins? margin_inside: $vertical_rhythm / 3 #margin_inside: $vertical_rhythm / 4 margin_outside: 0 lead: font_size: $base_font_size_large line_height: 1.4 abstract: font_color: 5c6266 font_size: $lead_font_size line_height: $lead_line_height font_style: italic first_line_font_style: bold title: align: center font_color: $heading_font_color font_family: $heading_font_family font_size: $heading_h4_font_size font_style: $heading_font_style admonition: column_rule_color: $base_border_color column_rule_width: $base_border_width padding: [0, $horizontal_rhythm, 0, $horizontal_rhythm] #icon: # tip: # name: fa-lightbulb-o # stroke_color: 111111 # size: 24 label: text_transform: uppercase font_style: bold blockquote: font_color: $base_font_color font_size: $base_font_size_large border_color: $base_border_color border_width: 5 # FIXME disable negative padding bottom once margin collapsing is implemented padding: [0, $horizontal_rhythm, $block_margin_bottom * -0.75, $horizontal_rhythm + $blockquote_border_width / 2] cite_font_size: $base_font_size_small cite_font_color: 999999 # code is used for source blocks (perhaps change to source or listing?) code: font_color: $base_font_color font_family: $literal_font_family font_size: ceil($base_font_size) padding: $code_font_size line_height: 1.25 # line_gap is an experimental property to control how a background color is applied to an inline block element line_gap: 3.8 background_color: f5f5f5 border_color: cccccc border_radius: $base_border_radius border_width: 0.75 conum: font_family: M+ 1mn font_color: $literal_font_color font_size: $base_font_size line_height: 4 / 3 example: border_color: $base_border_color border_radius: $base_border_radius border_width: 0.75 background_color: ffffff # FIXME reenable padding bottom once margin collapsing is implemented padding: [$vertical_rhythm, $horizontal_rhythm, 0, $horizontal_rhythm] image: align: left prose: margin_top: $block_margin_top margin_bottom: $block_margin_bottom sidebar: background_color: eeeeee border_color: e1e1e1 border_radius: $base_border_radius border_width: $base_border_width # FIXME reenable padding bottom once margin collapsing is implemented padding: [$vertical_rhythm, $vertical_rhythm * 1.25, 0, $vertical_rhythm * 1.25] title: align: center font_color: $heading_font_color font_family: $heading_font_family font_size: $heading_h4_font_size font_style: $heading_font_style thematic_break: border_color: $base_border_color border_style: solid border_width: $base_border_width margin_top: $vertical_rhythm * 0.5 margin_bottom: $vertical_rhythm * 1.5 description_list: term_font_style: bold term_spacing: $vertical_rhythm / 4 description_indent: $horizontal_rhythm * 1.25 outline_list: indent: $horizontal_rhythm * 1.5 #marker_font_color: 404040 # NOTE outline_list_item_spacing applies to list items that do not have complex content item_spacing: $vertical_rhythm / 2 table: background_color: $page_background_color #head_background_color: #head_font_color: $base_font_color head_font_style: bold #body_background_color: body_stripe_background_color: f9f9f9 foot_background_color: f0f0f0 border_color: dddddd border_width: $base_border_width cell_padding: 3 toc: indent: $horizontal_rhythm line_height: 1.4 dot_leader: #content: ". " font_color: a9a9a9 #levels: 2 3 # NOTE in addition to footer, header is also supported footer: font_size: $base_font_size_small # NOTE if background_color is set, background and border will span width of page #border_color: dddddd # EE #border_width: 0.25 # EE height: $base_line_height_length * 2.5 line_height: 1 padding: [$base_line_height_length / 2, 1, 0, 1] vertical_align: top #image_vertical_align: or # additional attributes for content: # * {page-count} # * {page-number} # * {document-title} # * {document-subtitle} # * {chapter-title} # * {section-title} # * {section-or-chapter-title} recto: #columns: "<50% =0% >50%" right: #content: '{page-number}' # EE #content: '{section-or-chapter-title} | {page-number}' #content: '{document-title} | {page-number}' content: '{document-title}{nbsp}{nbsp}{nbsp} *{page-number}*' # EE #center: # content: '{page-number}' left: # EE content: '{status}' # EE verso: #columns: $footer_recto_columns left: #content: $footer_recto_right_content # EE #content: '{page-number} | {chapter-title}' content: '*{page-number}* {nbsp}{nbsp}{nbsp}{document-title}' # EE #center: # content: '{page-number}' right: # EE content: '{status}' # EE header: # EE font_size: $base_font_size_small # EE border_color: dddddd # EE border_width: 0.25 # EE height: $base_line_height_length * 2.5 # EE line_height: 1 # EE padding: [$base_line_height_length / 2, 1, 0, 1] # EE vertical_align: top # EE recto: # EE right: # EE content: '{section-or-chapter-title}' # EE verso: # EE left: # EE content: '{section-or-chapter-title}' # EE jaf-api-2.1.1/www/000077500000000000000000000000001435131260600136475ustar00rootroot00000000000000jaf-api-2.1.1/www/Gemfile000066400000000000000000000002401435131260600151360ustar00rootroot00000000000000source "https://rubygems.org" gem 'github-pages', group: :jekyll_plugins #gem 'jekyll-theme-eclipsefdn' gem 'jekyll-theme-jakarta-ee' gem "webrick", "~> 1.7" jaf-api-2.1.1/www/Gemfile.lock000066400000000000000000000165201435131260600160750ustar00rootroot00000000000000GEM remote: https://rubygems.org/ specs: activesupport (6.0.6) concurrent-ruby (~> 1.0, >= 1.0.2) i18n (>= 0.7, < 2) minitest (~> 5.1) tzinfo (~> 1.1) zeitwerk (~> 2.2, >= 2.2.2) addressable (2.8.1) public_suffix (>= 2.0.2, < 6.0) coffee-script (2.4.1) coffee-script-source execjs coffee-script-source (1.11.1) colorator (1.1.0) commonmarker (0.23.6) concurrent-ruby (1.1.10) dnsruby (1.61.9) simpleidn (~> 0.1) em-websocket (0.5.3) eventmachine (>= 0.12.9) http_parser.rb (~> 0) ethon (0.16.0) ffi (>= 1.15.0) eventmachine (1.2.7) execjs (2.8.1) faraday (2.7.1) faraday-net_http (>= 2.0, < 3.1) ruby2_keywords (>= 0.0.4) faraday-net_http (3.0.2) ffi (1.15.5) forwardable-extended (2.6.0) gemoji (3.0.1) github-pages (227) github-pages-health-check (= 1.17.9) jekyll (= 3.9.2) jekyll-avatar (= 0.7.0) jekyll-coffeescript (= 1.1.1) jekyll-commonmark-ghpages (= 0.2.0) jekyll-default-layout (= 0.1.4) jekyll-feed (= 0.15.1) jekyll-gist (= 1.5.0) jekyll-github-metadata (= 2.13.0) jekyll-include-cache (= 0.2.1) jekyll-mentions (= 1.6.0) jekyll-optional-front-matter (= 0.3.2) jekyll-paginate (= 1.1.0) jekyll-readme-index (= 0.3.0) jekyll-redirect-from (= 0.16.0) jekyll-relative-links (= 0.6.1) jekyll-remote-theme (= 0.4.3) jekyll-sass-converter (= 1.5.2) jekyll-seo-tag (= 2.8.0) jekyll-sitemap (= 1.4.0) jekyll-swiss (= 1.0.0) jekyll-theme-architect (= 0.2.0) jekyll-theme-cayman (= 0.2.0) jekyll-theme-dinky (= 0.2.0) jekyll-theme-hacker (= 0.2.0) jekyll-theme-leap-day (= 0.2.0) jekyll-theme-merlot (= 0.2.0) jekyll-theme-midnight (= 0.2.0) jekyll-theme-minimal (= 0.2.0) jekyll-theme-modernist (= 0.2.0) jekyll-theme-primer (= 0.6.0) jekyll-theme-slate (= 0.2.0) jekyll-theme-tactile (= 0.2.0) jekyll-theme-time-machine (= 0.2.0) jekyll-titles-from-headings (= 0.5.3) jemoji (= 0.12.0) kramdown (= 2.3.2) kramdown-parser-gfm (= 1.1.0) liquid (= 4.0.3) mercenary (~> 0.3) minima (= 2.5.1) nokogiri (>= 1.13.6, < 2.0) rouge (= 3.26.0) terminal-table (~> 1.4) github-pages-health-check (1.17.9) addressable (~> 2.3) dnsruby (~> 1.60) octokit (~> 4.0) public_suffix (>= 3.0, < 5.0) typhoeus (~> 1.3) html-pipeline (2.14.3) activesupport (>= 2) nokogiri (>= 1.4) http_parser.rb (0.8.0) i18n (0.9.5) concurrent-ruby (~> 1.0) jekyll (3.9.2) addressable (~> 2.4) colorator (~> 1.0) em-websocket (~> 0.5) i18n (~> 0.7) jekyll-sass-converter (~> 1.0) jekyll-watch (~> 2.0) kramdown (>= 1.17, < 3) liquid (~> 4.0) mercenary (~> 0.3.3) pathutil (~> 0.9) rouge (>= 1.7, < 4) safe_yaml (~> 1.0) jekyll-avatar (0.7.0) jekyll (>= 3.0, < 5.0) jekyll-coffeescript (1.1.1) coffee-script (~> 2.2) coffee-script-source (~> 1.11.1) jekyll-commonmark (1.4.0) commonmarker (~> 0.22) jekyll-commonmark-ghpages (0.2.0) commonmarker (~> 0.23.4) jekyll (~> 3.9.0) jekyll-commonmark (~> 1.4.0) rouge (>= 2.0, < 4.0) jekyll-default-layout (0.1.4) jekyll (~> 3.0) jekyll-feed (0.15.1) jekyll (>= 3.7, < 5.0) jekyll-gist (1.5.0) octokit (~> 4.2) jekyll-github-metadata (2.13.0) jekyll (>= 3.4, < 5.0) octokit (~> 4.0, != 4.4.0) jekyll-include-cache (0.2.1) jekyll (>= 3.7, < 5.0) jekyll-mentions (1.6.0) html-pipeline (~> 2.3) jekyll (>= 3.7, < 5.0) jekyll-optional-front-matter (0.3.2) jekyll (>= 3.0, < 5.0) jekyll-paginate (1.1.0) jekyll-readme-index (0.3.0) jekyll (>= 3.0, < 5.0) jekyll-redirect-from (0.16.0) jekyll (>= 3.3, < 5.0) jekyll-relative-links (0.6.1) jekyll (>= 3.3, < 5.0) jekyll-remote-theme (0.4.3) addressable (~> 2.0) jekyll (>= 3.5, < 5.0) jekyll-sass-converter (>= 1.0, <= 3.0.0, != 2.0.0) rubyzip (>= 1.3.0, < 3.0) jekyll-sass-converter (1.5.2) sass (~> 3.4) jekyll-seo-tag (2.8.0) jekyll (>= 3.8, < 5.0) jekyll-sitemap (1.4.0) jekyll (>= 3.7, < 5.0) jekyll-swiss (1.0.0) jekyll-theme-architect (0.2.0) jekyll (> 3.5, < 5.0) jekyll-seo-tag (~> 2.0) jekyll-theme-cayman (0.2.0) jekyll (> 3.5, < 5.0) jekyll-seo-tag (~> 2.0) jekyll-theme-dinky (0.2.0) jekyll (> 3.5, < 5.0) jekyll-seo-tag (~> 2.0) jekyll-theme-hacker (0.2.0) jekyll (> 3.5, < 5.0) jekyll-seo-tag (~> 2.0) jekyll-theme-jakarta-ee (0.1.4) jekyll (~> 3.7) jekyll-theme-leap-day (0.2.0) jekyll (> 3.5, < 5.0) jekyll-seo-tag (~> 2.0) jekyll-theme-merlot (0.2.0) jekyll (> 3.5, < 5.0) jekyll-seo-tag (~> 2.0) jekyll-theme-midnight (0.2.0) jekyll (> 3.5, < 5.0) jekyll-seo-tag (~> 2.0) jekyll-theme-minimal (0.2.0) jekyll (> 3.5, < 5.0) jekyll-seo-tag (~> 2.0) jekyll-theme-modernist (0.2.0) jekyll (> 3.5, < 5.0) jekyll-seo-tag (~> 2.0) jekyll-theme-primer (0.6.0) jekyll (> 3.5, < 5.0) jekyll-github-metadata (~> 2.9) jekyll-seo-tag (~> 2.0) jekyll-theme-slate (0.2.0) jekyll (> 3.5, < 5.0) jekyll-seo-tag (~> 2.0) jekyll-theme-tactile (0.2.0) jekyll (> 3.5, < 5.0) jekyll-seo-tag (~> 2.0) jekyll-theme-time-machine (0.2.0) jekyll (> 3.5, < 5.0) jekyll-seo-tag (~> 2.0) jekyll-titles-from-headings (0.5.3) jekyll (>= 3.3, < 5.0) jekyll-watch (2.2.1) listen (~> 3.0) jemoji (0.12.0) gemoji (~> 3.0) html-pipeline (~> 2.2) jekyll (>= 3.0, < 5.0) kramdown (2.3.2) rexml kramdown-parser-gfm (1.1.0) kramdown (~> 2.0) liquid (4.0.3) listen (3.7.1) rb-fsevent (~> 0.10, >= 0.10.3) rb-inotify (~> 0.9, >= 0.9.10) mercenary (0.3.6) minima (2.5.1) jekyll (>= 3.5, < 5.0) jekyll-feed (~> 0.9) jekyll-seo-tag (~> 2.1) minitest (5.16.3) nokogiri (1.13.10-x86_64-darwin) racc (~> 1.4) nokogiri (1.13.10-x86_64-linux) racc (~> 1.4) octokit (4.25.1) faraday (>= 1, < 3) sawyer (~> 0.9) pathutil (0.16.2) forwardable-extended (~> 2.6) public_suffix (4.0.7) racc (1.6.1) rb-fsevent (0.11.2) rb-inotify (0.10.1) ffi (~> 1.0) rexml (3.2.5) rouge (3.26.0) ruby2_keywords (0.0.5) rubyzip (2.3.2) safe_yaml (1.0.5) sass (3.7.4) sass-listen (~> 4.0.0) sass-listen (4.0.0) rb-fsevent (~> 0.9, >= 0.9.4) rb-inotify (~> 0.9, >= 0.9.7) sawyer (0.9.2) addressable (>= 2.3.5) faraday (>= 0.17.3, < 3) simpleidn (0.2.1) unf (~> 0.1.4) terminal-table (1.8.0) unicode-display_width (~> 1.1, >= 1.1.1) thread_safe (0.3.6) typhoeus (1.4.0) ethon (>= 0.9.0) tzinfo (1.2.10) thread_safe (~> 0.1) unf (0.1.4) unf_ext unf_ext (0.0.8.2) unicode-display_width (1.8.0) webrick (1.7.0) zeitwerk (2.6.6) PLATFORMS x86_64-darwin-21 x86_64-linux DEPENDENCIES github-pages jekyll-theme-jakarta-ee webrick (~> 1.7) BUNDLED WITH 2.3.26 jaf-api-2.1.1/www/README.md000066400000000000000000000131101435131260600151220ustar00rootroot00000000000000Jakarta Activation lets you take advantage of standard services to: determine the type of an arbitrary piece of data; encapsulate access to it; discover the operations available on it; and instantiate the appropriate bean to perform the operation(s). Jakarta Activation is used for data content handling by: * [Jakarta Mail](https://jakarta.ee/specifications/mail/) * [Jakarta XML Web Services](https://jakarta.ee/specifications/xml-web-services/)
# Table of Contents * [Latest News](#Latest_News) * [API Documentation](#API_Documentation) * [Help](#Help) * [Bugs](#Bugs) * [Development Releases](#Development_Releases)
# Latest News ## December TBD, 2022 - Jakarta Activation 2.1.1 Final Release ## The 2.1.1 release is the bug fix release which removes the need for accessDeclaredMembers permissions when loading DataHandlers and improves usability in OSGi environment. ## November 20, 2021 - Jakarta Activation 2.1.0 Final Release ## The 2.1.0 release is the first release providing standalone API jar file. The implementation, formerly JakartaActivation, is now standalone project - [Eclipse Angus](https://eclipse-ee4j.github.io/angus-activation/). This version of the specification is included in the [Jakarta EE 10 Platform](https://jakarta.ee/specifications/platform/10/). ## April 6, 2021 - Jakarta Activation 2.0.1 Final Release ## The 2.0.1 release is the bug fix release of 2.0.0. ## October 22, 2020 - Jakarta Activation 2.0.0 Final Release ## The 2.0.0 release is the first release under the `jakarta` namespace. It is also the first release containing full module metadata. ## July 25, 2019 - Jakarta Activation is the new name for JAF ## The JavaBeans Activation Framework has been renamed to Jakarta Activation in preparation for inclusion in a future version of Jakarta EE. ## November 26, 2018 - JavaBeans Activation Framework 1.2.1 Final Release ## The 1.2.1 release is the first release of the Eclipse project for JAF and includes no bug fixes or enhancements. It does include changes to the Maven coordinates. The main jar file is now located at [com.sun.activation:jakarta.activation](https://repo1.maven.org/maven2/com/sun/activation/jakarta.activation/1.2.1/jakarta.activation-1.2.1.jar). This standalone release of JAF uses a [Java Platform Module System](http://openjdk.java.net/projects/jigsaw/spec/) "automatic" module name of `jakarta.activation`, which is different than the module name used in JDK 9 and 10. A future version will include full module metadata. ## September 14, 2018 - JavaBeans Activation Framework project moves to the Eclipse Foundation! ## The JavaBeans Activation Framework project is now hosted at the Eclipse Foundation as part of the [EE4J project](https://projects.eclipse.org/projects/ee4j).
# API Documentation The JavaBeans Activation Framework 1.2 and earlier API is defined through the Java Community Process as [JSR 925](http://jcp.org/en/jsr/detail?id=925). The Jakarta Activation API documentation is available [here](https://jakartaee.github.io/jaf-api/api/). The following documents summarize the API changes in each release of the JavaBeans Activation Framework API specification: - [JAF 2.1](JAF-2.1-changes.txt) - [JAF 2.0](JAF-2.0-changes.txt) - [JAF 1.2](JAF-1.2-changes.txt) - [JAF 1.1](JAF-1.1-changes.txt)
# Help You can post questions to the [jaf-dev mailing list](https://accounts.eclipse.org/mailing-list/jaf-dev).
# Bugs Jakarta Activation bugs are tracked in the [GitHub Jakarta Activation project issue tracker](https://github.com/jakartaee/jaf-api/issues).
# Development Releases From time to time snapshot releases of the next version of JAF under development are published to the [Jakarta Sonatype OSS repository](http://jakarta.oss.sonatype.org). These snapshot releases have received only minimal testing, but may provide previews of bug fixes or new features under development. For example, you can download the jakarta.activation.jar file from the Jakarta Activation 1.2.2-SNAPSHOT release [here](https://jakarta.oss.sonatype.org/content/repositories/snapshots/com/sun/activation/jakarta.activation/1.2.2-SNAPSHOT/). Be sure to scroll to the bottom and choose the jar file with the most recent time stamp. You'll need to add the following configuration to your Maven ~/.m2/settings.xml to be able to use these with Maven: ``` jakarta-snapshots jakarta-snapshots Jakarta Snapshots true always fail https://jakarta.oss.sonatype.org/content/repositories/snapshots/ default ``` And then when you build use `mvn -Pjakarta-snapshots ...`. If you want the plugin repository to be enabled all the time so you don't need the -P, add: ``` jakarta-snapshots ```
By contributing to this project, you agree to these additional terms of use, described in [CONTRIBUTING](CONTRIBUTING.md). jaf-api-2.1.1/www/TCK-Results.md000066400000000000000000000117111435131260600162520ustar00rootroot00000000000000TCK Results =========== As required by the [Eclipse Foundation Technology Compatibility Kit License](https://www.eclipse.org/legal/tck.php), following is a summary of the TCK results for releases of Jakarta Activation. # 2.0.1 Certification Request - [x] Organization Name ("Organization") and, if applicable, URL
[Eclipse Foundation](https://www.eclipse.org/) - [x] Product Name, Version and download URL (if applicable)
[EE4J implementation of Jakarta Activation 2.0.1](https://github.com/eclipse-ee4j/jaf) - [x] Specification Name, Version and download URL
[Jakarta Activation](https://jakarta.ee/activation/2.0) - [x] TCK Version, digital SHA-256 fingerprint and download URL
[Jakarta Activation TCK 2.0.0](https://download.eclipse.org/jakartaee/activation/2.0/jakarta-activation-tck-2.0.0.zip), SHA-256: 98b7aad6d37cfa2eaa45ef7d182e56043a29b56ffd031a25e84e1dd2cb238f8f - [x] Public URL of TCK Results Summary
[TCK results summary](https://eclipse-ee4j.github.io/jaf/TCK-Results.html) - [x] Any Additional Specification Certification Requirements
None - [x] Java runtime used to run the implementation
Oracle JDK 1.8.0_251, Oracle JDK 11.0.10 - [x] Summary of the information for the certification environment, operating system, cloud, ...
Linux - [x] By checking this box I acknowledge that the Organization I represent accepts the terms of the [EFTL](https://www.eclipse.org/legal/tck.php). - [x] By checking this box I attest that all TCK requirements have been met, including any compatibility rules. Test results: ``` [javatest.batch] *************************************************************** [javatest.batch] Completed running 90 tests. [javatest.batch] Number of Tests Passed = 90 [javatest.batch] Number of Tests Failed = 0 [javatest.batch] Number of Tests with Errors = 0 [javatest.batch] Number of Tests Not Run = 0 [javatest.batch] --------------------------------------------------------------- ``` # 2.0.0 Certification Request - [x] Organization Name ("Organization") and, if applicable, URL
[Eclipse Foundation](https://www.eclipse.org/) - [x] Product Name, Version and download URL (if applicable)
[EE4J implementation of Jakarta Activation 2.0.0](https://github.com/eclipse-ee4j/jaf) - [x] Specification Name, Version and download URL
[Jakarta Activation](https://jakarta.ee/activation/2.0) - [x] TCK Version, digital SHA-256 fingerprint and download URL
[Jakarta Activation TCK 2.0.0](https://download.eclipse.org/jakartaee/activation/2.0/jakarta-activation-tck-2.0.0.zip), SHA-256: 98b7aad6d37cfa2eaa45ef7d182e56043a29b56ffd031a25e84e1dd2cb238f8f - [x] Public URL of TCK Results Summary
[TCK results summary](https://eclipse-ee4j.github.io/jaf/TCK-Results.html) - [x] Any Additional Specification Certification Requirements
None - [x] Java runtime used to run the implementation
Oracle JDK 1.8.0_191 - [x] Summary of the information for the certification environment, operating system, cloud, ...
Linux - [x] By checking this box I acknowledge that the Organization I represent accepts the terms of the [EFTL](https://www.eclipse.org/legal/tck.php). - [x] By checking this box I attest that all TCK requirements have been met, including any compatibility rules. Test results: ``` [javatest.batch] Total time = 45s [javatest.batch] Setup time = 0s [javatest.batch] Cleanup time = 0s [javatest.batch] Test results: passed: 90 ``` # 1.2.2 Certification Request - [x] Organization Name ("Organization") and, if applicable, URL
[Eclipse Foundation](https://www.eclipse.org/) - [x] Product Name, Version and download URL (if applicable)
[EE4J implementation of Jakarta Activation 1.2.2](https://github.com/eclipse-ee4j/jaf) - [x] Specification Name, Version and download URL
[Jakarta Activation](https://jakarta.ee/activation/1.2) - [x] TCK Version, digital SHA-256 fingerprint and download URL
[Jakarta Activation TCK 1.2.0](https://download.eclipse.org/jakartaee/activation/1.2/jakarta-activation-tck-1.2.0.zip), SHA-256: 8a2ccba45790f26ef873fc1160cb7795ec4346b17a9dc9687378cbff1b965787 - [x] Public URL of TCK Results Summary
[TCK results summary](https://eclipse-ee4j.github.io/jaf/TCK-Results.html) - [x] Any Additional Specification Certification Requirements
None - [x] Java runtime used to run the implementation
Oracle JDK 1.8.0_191 - [x] Summary of the information for the certification environment, operating system, cloud, ...
Linux - [x] By checking this box I acknowledge that the Organization I represent accepts the terms of the [EFTL](https://www.eclipse.org/legal/tck.php). - [x] By checking this box I attest that all TCK requirements have been met, including any compatibility rules. Test results: ``` [javatest.batch] Completed running 90 tests. [javatest.batch] Number of Tests Passed = 90 [javatest.batch] Number of Tests Failed = 0 [javatest.batch] Number of Tests with Errors = 0 [javatest.batch] Number of Tests Not Run = 0 ``` jaf-api-2.1.1/www/_config.yml000066400000000000000000000006011435131260600157730ustar00rootroot00000000000000github: [metadata] remote_theme: jakartaee/jekyll-theme-jakarta-ee title: [Jakarta Activation] description: [Specification] links: source: https://github.com/jakartaee/jaf-api javadocs: api/ download: https://github.com/eclipse-ee4j/jaf/releases mailinglist: https://accounts.eclipse.org/mailing-list/jaf-dev #faq: FAQ contrib: CONTRIBUTING include: - CONTRIBUTING.md jaf-api-2.1.1/www/_includes/000077500000000000000000000000001435131260600156145ustar00rootroot00000000000000jaf-api-2.1.1/www/_includes/sidebar.html000066400000000000000000000041601435131260600201140ustar00rootroot00000000000000