/*******************************************************************************

  * Licensed to the Apache Software Foundation (ASF) under one

  * or more contributor license agreements.  See the NOTICE file

  * distributed with this work for additional information

  * regarding copyright ownership.  The ASF licenses this file

  * to you under the Apache License, Version 2.0 (the

  * "License"); you may not use this file except in compliance

  * with the License.  You may obtain a copy of the License at

  *

  * http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing,

  * software distributed under the License is distributed on an

  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

  * KIND, either express or implied.  See the License for the

  * specific language governing permissions and limitations

  * under the License.

  *******************************************************************************/

 package org.apache.commons.convert;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.Reader;

 import java.nio.ByteBuffer;

 import java.nio.charset.Charset;

 import java.sql.Blob;

 import java.sql.Clob;

 import java.text.DecimalFormat;

 import java.text.SimpleDateFormat;

 import java.util.Locale;

 import java.util.UUID;

 import java.util.regex.Pattern;

 /** Miscellaneous Converter classes. */

 public class MiscConverters implements ConverterLoader {

     public void loadConverters() {

         Converters.loadContainedConverters(MiscConverters.class);

         Converters.registerConverter(new GenericToStringConverter<Locale>(Locale.class));

         Converters.registerConverter(new GenericToStringConverter<UUID>(UUID.class));

         Converters.registerConverter(new GenericToStringConverter<Pattern>(Pattern.class));

     }

     /**

      * An object that converts a <code>java.sql.Blob</code> to a

      * byte array.

      */

     public static class BlobToByteArray extends AbstractConverter<Blob, byte[]> {

         public BlobToByteArray() {

             super(Blob.class, byte[].class);

         }

         public byte[] convert(Blob obj) throws ConversionException {

             InputStream inStream = null;

             try {

                 inStream = obj.getBinaryStream();

                 int blobLength = (int) obj.length();

                 byte[] byteBuffer = new byte[blobLength];

                 int offset = 0;

                 int bytesRead = inStream.read(byteBuffer, offset, blobLength);

                 while (bytesRead > 0) {

                     offset += bytesRead;

                     bytesRead = inStream.read(byteBuffer, offset, blobLength);

                 }

                 return byteBuffer;

             } catch (Exception e) {

                 throw new ConversionException(e);

             }

             finally {

                 if (inStream != null) {

                     try {

                         inStream.close();

                     } catch (IOException e) {}

                 }

             }

         }

     }

     /**

      * An object that converts a byte array to a

      * <code>ByteBuffer</code>.

      */

     public static class ByteArrayToByteBuffer extends AbstractConverter<byte[], ByteBuffer> {

         public ByteArrayToByteBuffer() {

             super(byte[].class, ByteBuffer.class);

         }

         public ByteBuffer convert(byte[] obj) throws ConversionException {

             try {

                 return ByteBuffer.wrap(obj);

             } catch (Exception e) {

                 throw new ConversionException(e);

             }

         }

     }

     /**

      * An object that converts a <code>ByteBuffer</code> to a

      * byte array.

      */

     public static class ByteBufferToByteArray extends AbstractConverter<ByteBuffer, byte[]> {

         public ByteBufferToByteArray() {

             super(ByteBuffer.class, byte[].class);

         }

         public byte[] convert(ByteBuffer obj) throws ConversionException {

             try {

                 return obj.hasArray() ? obj.array() : null;

             } catch (Exception e) {

                 throw new ConversionException(e);

             }

         }

     }

     /**

      * An object that converts a <code>Charset</code> to a

      * character set name <code>String</code>.

      */

     public static class CharsetToString extends AbstractConverter<Charset, String> {

         public CharsetToString() {

             super(Charset.class, String.class);

         }

         public String convert(Charset obj) throws ConversionException {

             return obj.name();

         }

     }

     /**

      * An object that converts a <code>java.sql.Clob</code> to a

      * <code>String</code>.

      */

     public static class ClobToString extends AbstractConverter<Clob, String> {

         public ClobToString() {

             super(Clob.class, String.class);

         }

         public String convert(Clob obj) throws ConversionException {

             Reader clobReader = null;

             try {

                 clobReader = obj.getCharacterStream();

                 int clobLength = (int) obj.length();

                 char[] charBuffer = new char[clobLength];

                 int offset = 0;

                 int charsRead = clobReader.read(charBuffer, offset, clobLength);

                 while (charsRead > 0) {

                     offset += charsRead;

                     charsRead = clobReader.read(charBuffer, offset, clobLength);

                 }

                 return new String(charBuffer);

             } catch (Exception e) {

                 throw new ConversionException(e);

             }

             finally {

                 if (clobReader != null) {

                     try {

                         clobReader.close();

                     } catch (IOException e) {}

                 }

             }

         }

     }

     /**

      * An object that converts a <code>DecimalFormat</code> to a

      * format pattern <code>String</code>.

      */

     public static class DecimalFormatToString extends AbstractConverter<DecimalFormat, String> {

         public DecimalFormatToString() {

             super(DecimalFormat.class, String.class);

         }

         public String convert(DecimalFormat obj) throws ConversionException {

             return obj.toPattern();

         }

     }

     public static class EnumToString extends AbstractConverter<Enum<?>, String> {

         public EnumToString() {

             super(Enum.class, String.class);

         }

         public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {

             return Enum.class.isAssignableFrom(sourceClass) && String.class.isAssignableFrom(targetClass);

         }

         public String convert(Enum<?> obj) throws ConversionException {

             return obj.toString();

         }

         public Class<? super Enum<?>> getSourceClass() {

             return null;

         }

     }

     /**

      * A class used for testing <code>ConverterLoader</code>

      * implementations.

      */

     public static class NotAConverter {

         protected NotAConverter() {

             throw new Error("Should not be loaded");

         }

     }

     /**

      * An object that converts a <code>SimpleDateFormat</code> to a

      * format pattern <code>String</code>.

      */

     public static class SimpleDateFormatToString extends AbstractConverter<SimpleDateFormat, String> {

         public SimpleDateFormatToString() {

             super(SimpleDateFormat.class, String.class);

         }

         public String convert(SimpleDateFormat obj) throws ConversionException {

             return obj.toPattern();

         }

     }

     /**

      * An object that converts a character set name <code>String</code> to a

      * <code>Charset</code>.

      */

     public static class StringToCharset extends AbstractConverter<String, Charset> {

         public StringToCharset() {

             super(String.class, Charset.class);

         }

         public Charset convert(String obj) throws ConversionException {

             return Charset.forName(obj);

         }

     }

     /**

      * An object that converts a format pattern <code>String</code> to a

      * <code>DecimalFormat</code>.

      */

     public static class StringToDecimalFormat extends AbstractConverter<String, DecimalFormat> {

         public StringToDecimalFormat() {

             super(String.class, DecimalFormat.class);

         }

         public DecimalFormat convert(String obj) throws ConversionException {

             return new DecimalFormat(obj);

         }

     }

     private static class StringToEnum<E extends Enum<E>> extends AbstractConverter<String, E> {

         public StringToEnum() {

             super(String.class, Enum.class);

         }

         public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {

             return String.class.isAssignableFrom(sourceClass) && Enum.class.isAssignableFrom(targetClass);

         }

         public E convert(String obj) throws ConversionException {

             throw new UnsupportedOperationException();

         }

         public Class<? super Enum> getTargetClass() {

             return null;

         }

     }

     public static class StringToEnumConverterCreator implements ConverterCreator, ConverterLoader {

         public <S, T> Converter<S, T> createConverter(Class<S> sourceClass, Class<T> targetClass) {

             if (String.class == sourceClass && Enum.class.isAssignableFrom(targetClass)) {

                 return Util.cast(new StringToEnum());

             } else {

                 return null;

             }

         }

         public void loadConverters() {

             Converters.registerCreator(this);

         }

     }

     /**

      * An object that converts a <code>Locale</code> ID

      * <code>String</code> to a <code>Locale</code>.

      */

     public static class StringToLocale extends AbstractConverter<String, Locale> {

         public StringToLocale() {

             super(String.class, Locale.class);

         }

         public Locale convert(String obj) throws ConversionException {

             return new Locale(obj);

         }

     }

     /**

      * An object that converts a pattern <code>String</code> to a

      * <code>Pattern</code>.

      */

     public static class StringToRegexPattern extends AbstractConverter<String, Pattern> {

         public StringToRegexPattern() {

             super(String.class, Pattern.class);

         }

         public Pattern convert(String obj) throws ConversionException {

             return Pattern.compile(obj);

         }

     }

     /**

      * An object that converts a format <code>String</code> to a

      * <code>SimpleDateFormat</code>.

      */

     public static class StringToSimpleDateFormat extends AbstractConverter<String, SimpleDateFormat> {

         public StringToSimpleDateFormat() {

             super(String.class, SimpleDateFormat.class);

         }

         public SimpleDateFormat convert(String obj) throws ConversionException {

             return new SimpleDateFormat(obj);

         }

     }

     /**

      * An object that converts a UUID <code>String</code> to a

      * <code>UUID</code>.

      */

     public static class StringToUUID extends AbstractConverter<String, UUID> {

         public StringToUUID() {

             super(String.class, UUID.class);

         }

         public UUID convert(String obj) throws ConversionException {

             return UUID.fromString(obj);

         }

     }

 }