Laboratoire ICAR » Plateforme TXM

public class AHCCoreMessages extends Utf8NLS {

	static {

		Utf8NLS.initializeMessages(AHCCoreMessages.class);

	}

import org.txm.rcp.editors.TXMEditorToolBar;

	public void updateEditorFromResult(boolean update) {

		super.createPartControl(parent);

		formPanel = getCommandParametersGroup();

		//TXMEditorToolBar navigationPanelToolBar = new TXMEditorToolBar(this.getTopToolBarContainer(), SWT.FLAT | SWT.RIGHT, "top", this);

		navigationPanel = getTopToolbar().installGroup("navigation", "Navigation", null, true);

		resultPanel = getResultArea();

		//resultPanel.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, true));

					compute(true);

		propSelector = new PropertiesSelector<Property>(formPanel, SWT.NONE);

				compute(true);

		structSelector = new PropertiesSelector<StructuralUnitProperty>(formPanel, SWT.NONE);

					for (int i = 0 ; i < props.size() ; i++) {

	@Override

	public void updateResultFromEditor() {

		final StructuralUnit struct = internalView.getAvailableStructs().get(this.structCombo.getSelectionIndex());

		final  List<Property> properties = propSelector.getProperties();

		final List<StructuralUnitProperty> supList = new ArrayList<StructuralUnitProperty>();

		List<StructuralUnitProperty> pList = structSelector.getProperties();

		for (Property property : pList) if (property instanceof StructuralUnitProperty) supList.add((StructuralUnitProperty) property);

		Integer currentPage = internalView.getCurrentSegmentNo();

		if (currentPage == null) currentPage = 0;

		internalView.setParameters(properties, struct, supList, currentPage);

	}

import org.txm.utils.messages.Utf8NLS;

public class Messages extends Utf8NLS {

		Utf8NLS.initializeMessages(Messages.class);

import org.txm.core.results.Parameter;

import org.txm.searchengine.cqp.corpus.StructuralUnitProperty;

	/** The positions. */

	int[] positions;

	/** The hierarchic sort. */

	@Parameter

	/** The pattern. */

	@Parameter

	List<StructuralUnitProperty> pPattern;

	/** The prop. */

	@Parameter

	/** The query. */

	@Parameter

	}

		for (Line line : this.lines) {

			if (this.writer != null) {

				this.writer.flush();

				this.writer.close();	

			}

		for(Line line : lines) { // we need to recompute lines' references

	 * Gets the parent corpus.

	public List<StructuralUnitProperty> getPattern() {

	public void setParameters(Query query, Property prop, List<StructuralUnitProperty> pattern, Boolean hierarchicSort) {

		return getCorpus() != null 

				&& pQuery != null 

				&& !pQuery.isEmpty();

	public boolean loadParameters() throws CqiClientException {

		this.pQuery = new Query(this.getStringParameterValue(ReferencerPreferences.QUERY));

		String s = this.getStringParameterValue(ReferencerPreferences.PATTERN);

		this.pPattern = StructuralUnitProperty.fromStringToList(getCorpus(), s);

		s = this.getStringParameterValue(ReferencerPreferences.PROPERTY);

		this.pProperty = getCorpus().getProperty(s);

		this.pHierarchicSort = this.getBooleanParameterValue(ReferencerPreferences.SORTBYFREQ);

	}

	public void setQuery(Query query) {

		this.pQuery = query;

	}

	public void setProperty(Property property) {

		this.pProperty = property;

	}

	public void setPattern(List<StructuralUnitProperty> properties) {

		this.pPattern = properties;

	public static final String SORTBYFREQ = "sorttype"; //$NON-NLS-1$

	public static final String QUERY = "query";

	public static final String PROPERTY = "property";

	public static final String PATTERN = "pattern";

		preferences.put(QUERY, ""); //$NON-NLS-1$

		preferences.put(PROPERTY, "word"); //$NON-NLS-1$

		preferences.put(PATTERN, "text_id"); //$NON-NLS-1$

 * WordCloud computes word clouds using the "wordcloud" R package and an Index result

	protected Integer pFMinFilter;

	protected Integer pVMaxFilter;

		return WordCloudCoreMessages.RESULT_TYPE + " (" + this.pFMinFilter

				+ this.pVMaxFilter

		return parent != null && pFMinFilter != null;

		if (parameters.containsKey(WordCloudPreferences.FMIN)) {

			Object value = parameters.get(WordCloudPreferences.FMIN);

			if (value instanceof String) {

				this.pFMinFilter = Integer.parseInt(value.toString());

			} else if (value instanceof Integer) {

				this.pFMinFilter = (Integer)value;

			}

		}

		if (parameters.containsKey(WordCloudPreferences.MAX_WORDS)) {

			Object value = parameters.get(WordCloudPreferences.MAX_WORDS);

			if (value instanceof String) {

				this.pVMaxFilter = Integer.parseInt(value.toString());

			} else if (value instanceof Integer) {

				this.pVMaxFilter = (Integer)value;

			}

		}

//		// FIXME: source must always be an Index because the corpus source produces an Index

//		// from corpus

//		if (source instanceof Corpus)	{ 

//			try {

//				Corpus corpus = (Corpus) source;

//				Query query;

//				String lang = corpus.getLang();

//				if (corpus.getProperty(lang + "pos") != null) {

//					query = new Query(getQueryForLang(lang));

//				}

//				else {

//					query = new Query("[]");

//				}

//				

//				System.out.println("Used query: " + query);

//				

//				ArrayList<Property> props = new ArrayList<Property>();

//				props.add(corpus.getWordProperty());

//				Index index = new Index(corpus);

//				index.setParameters(query, props, null, null, null, null);

//				if (!query.toString().equals("[]")) {

//					corpus.addChild(index);

//				}

//

//				index.compute(false, monitor);

//				

//				index.addChild(this);

//					

//				List<Line> lines = index.getAllLines();

//				if (lines != null && lines.size() > 0) {

//					this.initWith(index);

//				}

//				else {

//					Log.severe("Error: Could not build a word selection with this corpus");

//					throw new IllegalArgumentException("Error: Index failed with corpus " + corpus + " with lang " + lang + " and query " + query);

//				}

//			}

//			catch(Exception e) {

//				System.out.println("Error: "+e.getLocalizedMessage());

//				Log.printStackTrace(e);

//				return false;

//			}

			this.initWith((Index)parent);

//		}

//		// from index

//		else if(this.source instanceof Index)	{

//			this.initWith((Index) this.source);

//			return true;

//		}

//		

	@Override

	public boolean loadParameters() throws Exception {

		this.pFMinFilter = this.getIntParameterValue(WordCloudPreferences.FMIN);

		this.pVMaxFilter = this.getIntParameterValue(WordCloudPreferences.MAX_WORDS);

		return false;

	}

	public Integer getFMinFilter() {

		return pFMinFilter;

	}

	public Integer getVMaxFilter() {

		return pVMaxFilter;

	}

import org.txm.utils.messages.Utf8NLS;

public class Messages extends Utf8NLS {

	static {

		Utf8NLS.initializeMessages(Messages.class);

	}

import org.txm.core.results.Parameter;

import org.txm.searchengine.cqp.corpus.WordProperty;

	@Parameter

	@Parameter

	@Parameter

	@Parameter

			pProperties = WordProperty.fromStringToList(corpus, propNames);

			propNames = this.getStringParameterValue(InternalViewPreferences.STRUCTURALUNIT);

			List<StructuralUnit> structs = StructuralUnit.stringToStructuralUnits(corpus, propNames);

			pStructure = structs.get(0);

			//availableStructs.remove(pStructure);

		if (pCurrentPage != null) this.setParameterValue(InternalViewPreferences.CURRENTPAGE, pCurrentPage);

		if (pStructure != null) this.setParameterValue(InternalViewPreferences.STRUCTURALUNIT, pStructure.getName());

		if (pStructProperties != null) this.setParameterValue(InternalViewPreferences.STRUCTURALUNITPROPERTIES, StringUtils.join(pStructProperties, "\t"));

		if (pProperties != null) this.setParameterValue(InternalViewPreferences.PROPERTIES, StringUtils.join(pProperties, "\t"));

	public boolean loadParameters() throws Exception {

		this.pCurrentPage = this.getIntParameterValue(InternalViewPreferences.CURRENTPAGE);

		String s = this.getStringParameterValue(InternalViewPreferences.STRUCTURALUNIT);

		if (s != null && s.length() > 0)

			this.pStructure = corpus.getStructuralUnit(s);

		s = this.getStringParameterValue(InternalViewPreferences.STRUCTURALUNITPROPERTIES);

		this.pStructProperties = StructuralUnitProperty.fromStringToList(corpus, s);

		s = this.getStringParameterValue(InternalViewPreferences.PROPERTIES);

		this.pProperties = WordProperty.fromStringToList(corpus, s);

	public static final String STRUCTURALUNIT = "structuralunit";

		preferences.put(STRUCTURALUNIT, "text");

		preferences.put(STRUCTURALUNITPROPERTIES, "text_id");

public class CAUIMessages extends Utf8NLS {

	static {

		Utf8NLS.initializeMessages(CAUIMessages.class);

	}

		<accessrules>

			<accessrule kind="accessible" pattern="**"/>

		</accessrules>

	/**

	 * Looks for the value of the specified <code>key</code> in the specified parameters and preference nodes.

	 * Returns the value of a key in the specified parameters if exists.

	 * Otherwise try to get it from the local result node if exists.

	 * Otherwise try to get it from the specified node qualifier if exists.

	 * Otherwise try to get it from the specified alternative node qualifiers defined in the list <code>TXMPreferences.alternativeNodesQualifiers</code>.

	 * Returns <code>false</code> if no value has been found for the specified key.

	 * @param commandParameters

	 * @param nodeQualifier

	 * @param result

	 * @param key

	 * @return

	 */

	public static Serializable getSerializable(String key, TXMParameters commandParameters, TXMResult result, String nodeQualifier)	{

		if(commandParameters != null && commandParameters.get(key) != null)	{

			return (Serializable) commandParameters.get(key);

		}

		return getSerializable(key, result, nodeQualifier);

	}

	public static Serializable getSerializable(String key, TXMParameters commandParameters, TXMResult result)	{

		return getSerializable(key, commandParameters, result, result.getPreferencesNodeQualifier());

	}

	 * Looks for the value of the specified <code>key</code> in preference nodes.

	 * Returns the value of the local result node if exists.

	 * Otherwise try to get it from the specified node qualifier if exists.

	 * Otherwise try to get it from the specified alternative node qualifiers defined in the list <code>TXMPreferences.alternativeNodesQualifiers</code>.

	 * Returns defaultValue if no value has been found for the specified key.

	 * @param nodeQualifier

	 * @param result

	 * @param key

	 * @return

	 */

	public static Serializable getSerializable(String key, TXMResult result, String nodeQualifier, Serializable defaultValue)	{

		nodeQualifier = findNodeQualifier(nodeQualifier, result, key);

		String data_default = DefaultScope.INSTANCE.getNode(nodeQualifier).get(key, "");

		if (data_default.length() == 0) {

			return null;

		}

		try {

			defaultValue = fromString(data_default);

		} catch (Exception e) {

			Log.printStackTrace(e);

		}

		String data_return = scope.getNode(nodeQualifier).get(key, "");

		if (data_return.length() == 0) {

			return defaultValue;

		}

		try {

			return fromString(data_return);

		} catch (Exception e) {

			Log.printStackTrace(e);

		}

		return null;

	}

	/**

	 * Looks for the value of the specified <code>key</code> in preference nodes.

	 * Returns the value of the local result node if exists.

	 * Otherwise try to get it from the specified node qualifier if exists.

	 * Otherwise try to get it from the specified alternative node qualifiers defined in the list <code>TXMPreferences.alternativeNodesQualifiers</code>.

	 * Returns <code>false</code> if no value has been found for the specified key.

	 * @param nodeQualifier

	 * @param result

	 * @param key

	 * @return

	 */

	public static Serializable getSerializable(String key, TXMResult result, String nodeQualifier)	{

		return getSerializable(key, result, nodeQualifier, false);

	}

	/**

	 *

	 * @param nodeQualifier

	 * @param key

	 * @return

	 */

	public static Serializable getSerializable(String key, String nodeQualifier)	{

		return getSerializable(key, null, nodeQualifier);

	}

	/**

	 *

	 * @param result

	 * @param key

	 * @return

	 */

	public static Serializable getSerializable(String key, TXMResult result)	{

		return getSerializable(key, result, null);

	}

	/**

		else if (Serializable.class.isInstance(value))	{

			try {

				scope.getNode(nodeQualifier).put(key, toString((Serializable)value));

			} catch (IOException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

		}

		// FIXME: to do

		else {

			System.err.println("TXMPreferences.putLocal(): error, can't find a put method that matches the value type: " + value.getClass() + "=" + value + ".");

	/** Read the object from Base64 string. */

	private static Serializable fromString( String s ) throws IOException ,

	ClassNotFoundException {

		byte [] data = Base64.getDecoder().decode( s );

		ObjectInputStream ois = new ObjectInputStream( 

				new ByteArrayInputStream(  data ) );

		Object o  = ois.readObject();

		ois.close();

		return (Serializable)o;

	}

	/** Write the object to a Base64 string. */

	private static String toString( Serializable o ) throws IOException {

		ByteArrayOutputStream baos = new ByteArrayOutputStream();

		ObjectOutputStream oos = new ObjectOutputStream( baos );

		oos.writeObject( o );

		oos.close();

		return Base64.getEncoder().encodeToString(baos.toByteArray());		

	}

/*

 * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package org.txm.core.preferences;

import java.io.FilterOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.nio.ByteBuffer;

import java.nio.charset.StandardCharsets;

import java.util.Arrays;

import java.util.Objects;

/**

 * This class consists exclusively of static methods for obtaining

 * encoders and decoders for the Base64 encoding scheme. The

 * implementation of this class supports the following types of Base64

 * as specified in

 * <a href="http://www.ietf.org/rfc/rfc4648.txt">RFC 4648</a> and

 * <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045</a>.

 *

 * <ul>

 * <li><a name="basic"><b>Basic</b></a>

 * <p> Uses "The Base64 Alphabet" as specified in Table 1 of

 *     RFC 4648 and RFC 2045 for encoding and decoding operation.

 *     The encoder does not add any line feed (line separator)

 *     character. The decoder rejects data that contains characters

 *     outside the base64 alphabet.</p></li>

 *

 * <li><a name="url"><b>URL and Filename safe</b></a>

 * <p> Uses the "URL and Filename safe Base64 Alphabet" as specified

 *     in Table 2 of RFC 4648 for encoding and decoding. The

 *     encoder does not add any line feed (line separator) character.

 *     The decoder rejects data that contains characters outside the

 *     base64 alphabet.</p></li>

 *

 * <li><a name="mime"><b>MIME</b></a>

 * <p> Uses the "The Base64 Alphabet" as specified in Table 1 of

 *     RFC 2045 for encoding and decoding operation. The encoded output

 *     must be represented in lines of no more than 76 characters each

 *     and uses a carriage return {@code '\r'} followed immediately by

 *     a linefeed {@code '\n'} as the line separator. No line separator

 *     is added to the end of the encoded output. All line separators

 *     or other characters not found in the base64 alphabet table are

 *     ignored in decoding operation.</p></li>

 * </ul>

 *

 * <p> Unless otherwise noted, passing a {@code null} argument to a

 * method of this class will cause a {@link java.lang.NullPointerException

 * NullPointerException} to be thrown.

 *

 * @author  Xueming Shen

 * @since   1.8

 */

//TODO: switch to Java 1.8 and drop this copy of java.util.Base64

public class Base64 {

    private Base64() {}

    /**

     * Returns a {@link Encoder} that encodes using the

     * <a href="#basic">Basic</a> type base64 encoding scheme.

     *

     * @return  A Base64 encoder.

     */

    public static Encoder getEncoder() {

         return Encoder.RFC4648;

    }

    /**

     * Returns a {@link Encoder} that encodes using the

     * <a href="#url">URL and Filename safe</a> type base64

     * encoding scheme.

     *

     * @return  A Base64 encoder.

     */

    public static Encoder getUrlEncoder() {

         return Encoder.RFC4648_URLSAFE;

    }

    /**

     * Returns a {@link Encoder} that encodes using the

     * <a href="#mime">MIME</a> type base64 encoding scheme.

     *

     * @return  A Base64 encoder.

     */

    public static Encoder getMimeEncoder() {

        return Encoder.RFC2045;

    }

    /**

     * Returns a {@link Encoder} that encodes using the

     * <a href="#mime">MIME</a> type base64 encoding scheme

     * with specified line length and line separators.

     *

     * @param   lineLength

     *          the length of each output line (rounded down to nearest multiple

     *          of 4). If {@code lineLength <= 0} the output will not be separated

     *          in lines

     * @param   lineSeparator

     *          the line separator for each output line

     *

     * @return  A Base64 encoder.

     *

     * @throws  IllegalArgumentException if {@code lineSeparator} includes any

     *          character of "The Base64 Alphabet" as specified in Table 1 of

     *          RFC 2045.

     */

    public static Encoder getMimeEncoder(int lineLength, byte[] lineSeparator) {

         Objects.requireNonNull(lineSeparator);

         int[] base64 = Decoder.fromBase64;

         for (byte b : lineSeparator) {

             if (base64[b & 0xff] != -1)

                 throw new IllegalArgumentException(

                     "Illegal base64 line separator character 0x" + Integer.toString(b, 16));

         }

         if (lineLength <= 0) {

             return Encoder.RFC4648;

         }

         return new Encoder(false, lineSeparator, lineLength >> 2 << 2, true);

    }

    /**

     * Returns a {@link Decoder} that decodes using the

     * <a href="#basic">Basic</a> type base64 encoding scheme.

     *

     * @return  A Base64 decoder.

     */

    public static Decoder getDecoder() {

         return Decoder.RFC4648;

    }

    /**

     * Returns a {@link Decoder} that decodes using the

     * <a href="#url">URL and Filename safe</a> type base64

     * encoding scheme.

     *

     * @return  A Base64 decoder.

     */

    public static Decoder getUrlDecoder() {

         return Decoder.RFC4648_URLSAFE;

    }

    /**

     * Returns a {@link Decoder} that decodes using the

     * <a href="#mime">MIME</a> type base64 decoding scheme.

     *

     * @return  A Base64 decoder.

     */

    public static Decoder getMimeDecoder() {

         return Decoder.RFC2045;

    }

    /**

     * This class implements an encoder for encoding byte data using

     * the Base64 encoding scheme as specified in RFC 4648 and RFC 2045.

     *

     * <p> Instances of {@link Encoder} class are safe for use by

     * multiple concurrent threads.

     *

     * <p> Unless otherwise noted, passing a {@code null} argument to

     * a method of this class will cause a

     * {@link java.lang.NullPointerException NullPointerException} to

     * be thrown.

     *

     * @see     Decoder

     * @since   1.8

     */

    public static class Encoder {

        private final byte[] newline;

        private final int linemax;

        private final boolean isURL;

        private final boolean doPadding;

        private Encoder(boolean isURL, byte[] newline, int linemax, boolean doPadding) {

            this.isURL = isURL;

            this.newline = newline;

            this.linemax = linemax;

            this.doPadding = doPadding;

        }

        /**

         * This array is a lookup table that translates 6-bit positive integer

         * index values into their "Base64 Alphabet" equivalents as specified

         * in "Table 1: The Base64 Alphabet" of RFC 2045 (and RFC 4648).

         */

        private static final char[] toBase64 = {

            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',

            'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',

            'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',

            'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',

            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'

        };

        /**

         * It's the lookup table for "URL and Filename safe Base64" as specified

         * in Table 2 of the RFC 4648, with the '+' and '/' changed to '-' and

         * '_'. This table is used when BASE64_URL is specified.

         */

        private static final char[] toBase64URL = {

            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',

            'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',

            'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',

            'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',

            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_'

        };

        private static final int MIMELINEMAX = 76;

        private static final byte[] CRLF = new byte[] {'\r', '\n'};

        static final Encoder RFC4648 = new Encoder(false, null, -1, true);

        static final Encoder RFC4648_URLSAFE = new Encoder(true, null, -1, true);

        static final Encoder RFC2045 = new Encoder(false, CRLF, MIMELINEMAX, true);

        private final int outLength(int srclen) {

            int len = 0;

            if (doPadding) {

                len = 4 * ((srclen + 2) / 3);

            } else {

                int n = srclen % 3;

                len = 4 * (srclen / 3) + (n == 0 ? 0 : n + 1);

            }

            if (linemax > 0)                                  // line separators

                len += (len - 1) / linemax * newline.length;

            return len;

        }

        /**

         * Encodes all bytes from the specified byte array into a newly-allocated

         * byte array using the {@link Base64} encoding scheme. The returned byte

         * array is of the length of the resulting bytes.

         *

         * @param   src

         *          the byte array to encode

         * @return  A newly-allocated byte array containing the resulting

         *          encoded bytes.

         */

        public byte[] encode(byte[] src) {

            int len = outLength(src.length);          // dst array size

            byte[] dst = new byte[len];

            int ret = encode0(src, 0, src.length, dst);

            if (ret != dst.length)

                 return Arrays.copyOf(dst, ret);

            return dst;

        }

        /**

         * Encodes all bytes from the specified byte array using the

         * {@link Base64} encoding scheme, writing the resulting bytes to the

         * given output byte array, starting at offset 0.

         *

         * <p> It is the responsibility of the invoker of this method to make

         * sure the output byte array {@code dst} has enough space for encoding

         * all bytes from the input byte array. No bytes will be written to the

         * output byte array if the output byte array is not big enough.

         *

         * @param   src

         *          the byte array to encode

         * @param   dst

         *          the output byte array

         * @return  The number of bytes written to the output byte array

         *

         * @throws  IllegalArgumentException if {@code dst} does not have enough

         *          space for encoding all input bytes.

         */

        public int encode(byte[] src, byte[] dst) {

            int len = outLength(src.length);         // dst array size

            if (dst.length < len)

                throw new IllegalArgumentException(

                    "Output byte array is too small for encoding all input bytes");

            return encode0(src, 0, src.length, dst);

        }

        /**

         * Encodes the specified byte array into a String using the {@link Base64}

         * encoding scheme.

         *

         * <p> This method first encodes all input bytes into a base64 encoded

         * byte array and then constructs a new String by using the encoded byte

         * array and the {@link java.nio.charset.StandardCharsets#ISO_8859_1

         * ISO-8859-1} charset.

         *

         * <p> In other words, an invocation of this method has exactly the same

         * effect as invoking

         * {@code new String(encode(src), StandardCharsets.ISO_8859_1)}.

         *

         * @param   src

         *          the byte array to encode

         * @return  A String containing the resulting Base64 encoded characters

         */

        @SuppressWarnings("deprecation")

        public String encodeToString(byte[] src) {

            byte[] encoded = encode(src);

            return new String(encoded, 0, 0, encoded.length);

        }

        /**

         * Encodes all remaining bytes from the specified byte buffer into

         * a newly-allocated ByteBuffer using the {@link Base64} encoding

         * scheme.

         *

         * Upon return, the source buffer's position will be updated to

         * its limit; its limit will not have been changed. The returned

         * output buffer's position will be zero and its limit will be the

         * number of resulting encoded bytes.

         *

         * @param   buffer

         *          the source ByteBuffer to encode

         * @return  A newly-allocated byte buffer containing the encoded bytes.

         */

        public ByteBuffer encode(ByteBuffer buffer) {

            int len = outLength(buffer.remaining());

            byte[] dst = new byte[len];

            int ret = 0;

            if (buffer.hasArray()) {

                ret = encode0(buffer.array(),

                              buffer.arrayOffset() + buffer.position(),

                              buffer.arrayOffset() + buffer.limit(),

                              dst);

                buffer.position(buffer.limit());

            } else {

                byte[] src = new byte[buffer.remaining()];

                buffer.get(src);

                ret = encode0(src, 0, src.length, dst);

            }

            if (ret != dst.length)

                 dst = Arrays.copyOf(dst, ret);

            return ByteBuffer.wrap(dst);

        }

        /**

         * Wraps an output stream for encoding byte data using the {@link Base64}

         * encoding scheme.

         *

         * <p> It is recommended to promptly close the returned output stream after

         * use, during which it will flush all possible leftover bytes to the underlying

         * output stream. Closing the returned output stream will close the underlying

         * output stream.

         *

         * @param   os

         *          the output stream.

         * @return  the output stream for encoding the byte data into the

         *          specified Base64 encoded format

         */

        public OutputStream wrap(OutputStream os) {

            Objects.requireNonNull(os);

            return new EncOutputStream(os, isURL ? toBase64URL : toBase64,

                                       newline, linemax, doPadding);

        }

        /**

         * Returns an encoder instance that encodes equivalently to this one,

         * but without adding any padding character at the end of the encoded

         * byte data.

         *

         * <p> The encoding scheme of this encoder instance is unaffected by

         * this invocation. The returned encoder instance should be used for

         * non-padding encoding operation.

         *

         * @return an equivalent encoder that encodes without adding any

         *         padding character at the end

         */

        public Encoder withoutPadding() {

            if (!doPadding)

                return this;

            return new Encoder(isURL, newline, linemax, false);

        }

        private int encode0(byte[] src, int off, int end, byte[] dst) {

            char[] base64 = isURL ? toBase64URL : toBase64;

            int sp = off;

            int slen = (end - off) / 3 * 3;

            int sl = off + slen;

            if (linemax > 0 && slen  > linemax / 4 * 3)

                slen = linemax / 4 * 3;

            int dp = 0;

            while (sp < sl) {

                int sl0 = Math.min(sp + slen, sl);

                for (int sp0 = sp, dp0 = dp ; sp0 < sl0; ) {

                    int bits = (src[sp0++] & 0xff) << 16 |

                               (src[sp0++] & 0xff) <<  8 |

                               (src[sp0++] & 0xff);

                    dst[dp0++] = (byte)base64[(bits >>> 18) & 0x3f];

                    dst[dp0++] = (byte)base64[(bits >>> 12) & 0x3f];

                    dst[dp0++] = (byte)base64[(bits >>> 6)  & 0x3f];

                    dst[dp0++] = (byte)base64[bits & 0x3f];

                }

                int dlen = (sl0 - sp) / 3 * 4;