/YOYOPlayer/src/com/hadeslee/audiotag/tag/datatype/StringFixedLength.java

/**

 *  @author : Paul Taylor

 *  @author : Eric Farng

 *

 *  Version @version:$Id: StringFixedLength.java,v 1.11 2007/08/07 14:36:15 paultaylor Exp $

 *

 *  MusicTag Copyright (C)2003,2004

 *

 *  This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser

 *  General Public  License as published by the Free Software Foundation; either version 2.1 of the License,

 *  or (at your option) any later version.

 *

 *  This library 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 Lesser General Public License for more details.

 *

 *  You should have received a copy of the GNU Lesser General Public License along with this library; if not,

 *  you can get a copy from http://www.opensource.org/licenses/lgpl-license.php or write to the Free Software

 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

 *

 * Description:

 *

 */

package com.hadeslee.audiotag.tag.datatype;



import com.hadeslee.audiotag.tag.id3.AbstractTagFrameBody;

import com.hadeslee.audiotag.tag.InvalidDataTypeException;

import com.hadeslee.audiotag.tag.id3.valuepair.TextEncoding;



import java.nio.ByteBuffer;

import java.nio.CharBuffer;

import java.nio.charset.*;





/**

 * Represents a fixed length String, whereby the length of the String is known. The String

 * will be encoded based upon the text encoding of the frame that it belongs to.

 */

public class StringFixedLength

    extends AbstractString

{

    /**

     * Creates a new ObjectStringFixedsize datatype.

     *

     * @param identifier 

     * @param size       

     * @throws IllegalArgumentException 

     */

    public StringFixedLength(String identifier, AbstractTagFrameBody frameBody, int size)

    {

        super(identifier, frameBody);

        if (size < 0)

        {

            throw new IllegalArgumentException("size is less than zero: " + size);

        }

        setSize(size);

    }



    public StringFixedLength(StringFixedLength copyObject)

    {

        super(copyObject);

        this.size = copyObject.size;

    }



    /**

     * 

     *

     * @param obj 

     * @return if obj is equivalent to this

     */

    public boolean equals(Object obj)

    {

        if ((obj instanceof StringFixedLength) == false)

        {

            return false;

        }

        StringFixedLength object = (StringFixedLength) obj;

        if (this.size != object.size)

        {

            return false;

        }

        return super.equals(obj);

    }



    /**

     * Read a string from buffer of fixed size(size has already been set in constructor)

     *

     * @param arr    this is the buffer for the frame

     * @param offset this is where to start reading in the buffer for this field

     */

    public void readByteArray(byte[] arr, int offset) throws InvalidDataTypeException

    {

        logger.info("Reading from array from offset:" + offset);

        try

        {

            String charSetName = getTextEncodingCharSet();

            CharsetDecoder decoder = Charset.forName(charSetName).newDecoder();



            //Decode buffer if runs into problems should through exception which we

            //catch and then set value to empty string.

            logger.finest("Array length is:" + arr.length + "offset is:" + offset + "Size is:" + size);





            if(arr.length - offset < size)

            {

                throw new InvalidDataTypeException("byte array is to small to retrieve string of declared length:"+size);

            }

            String str = decoder.decode(ByteBuffer.wrap(arr, offset, size)).toString();

            if (str == null)

            {

                throw new NullPointerException("String is null");

            }

            value = str;

        }

        catch (CharacterCodingException ce)

        {

            logger.severe(ce.getMessage());

            value = "";

        }

        logger.info("Read StringFixedLength:" + value);

    }



    /**

     * Write String into byte array

     *

     * The string will be adjusted to ensure the correct number of bytes are written, If the current value is null

     * or to short the written value will have the 'space' character appended to ensure this. We write this instead of

     * the null character because the null character is likely to confuse the parser into misreading the next field.

     *

     * @return the byte array to be written to the file

     */

    public byte[] writeByteArray()

    {

        ByteBuffer dataBuffer = null;

        byte[] data;



        //Create with a series of empty of spaces to try and ensure integrity of field

        if(value==null)

        {

            logger.warning("Value of StringFixedlength Field is null using default value instead");

            data = new byte[size];

            for(int i=0;i<size;i++)

            {

                data[i]=' ';

            }

            return data;

        }



        try

        {

            String charSetName = getTextEncodingCharSet();

            CharsetEncoder encoder = Charset.forName(charSetName).newEncoder();

            dataBuffer = encoder.encode(CharBuffer.wrap((String) value));

        }

        catch (CharacterCodingException ce)

        {

            logger.warning("There was a problem writing the following StringFixedlength Field:"+value+":"+ce.getMessage()+"using default value instead");

            data = new byte[size];

            for(int i=0;i<size;i++)

            {

                data[i]=' ';

            }

            return data;

        }



        // We must return the defined size.

        // To check now because size is in bytes not chars

        if (dataBuffer != null)

        {

            //Everything ok

            if (dataBuffer.limit() == size)

            {

                data = new byte[dataBuffer.limit()];

                dataBuffer.get(data, 0, dataBuffer.limit());

                return data;

            }

            //There is more data available than allowed for this field strip

            else if (dataBuffer.limit() > size)

            {

                logger.warning("There was a problem writing the following StringFixedlength Field:"

                    +value

                    +" when converted to bytes has length of:"+dataBuffer.limit()

                    +" but field was defined with length of:"+size

                    +" too long so stripping extra length");

                data = new byte[size];

                dataBuffer.get(data, 0, size);

                return data;

            }

            //There is not enough data

            else

            {

                logger.warning("There was a problem writing the following StringFixedlength Field:"

                    +value

                    +" when converted to bytes has length of:"+dataBuffer.limit()

                    +" but field was defined with length of:"+size

                    +" too short so padding with spaces to make up extra length");



                data = new byte[size];

                dataBuffer.get(data, 0, dataBuffer.limit());



                for(int i=dataBuffer.limit();i<size;i++)

                {

                    data[i]=' ';

                }

                return data;

            }

        }

        else

        {

            logger.warning("There was a serious problem writing the following StringFixedlength Field:"+value+":"+"using default value instead");

            data = new byte[size];

            for(int i=0;i<size;i++)

            {

                data[i]=' ';

            }

            return data;

        }

    }



    /**

     *

     * @return the encoding of the frame body this datatype belongs to

     */

    protected String  getTextEncodingCharSet()

    {

         byte textEncoding = this.getBody().getTextEncoding();

         String charSetName = TextEncoding.getInstanceOf().getValueForId(textEncoding);

         logger.finest("text encoding:"+textEncoding + " charset:"+charSetName);

         return charSetName;

    }

}