Coverage Report

Coverage Report - net.sf.ezmorph.array.FloatArrayMorpher

Classes in this File

Line Coverage

Branch Coverage

Complexity

FloatArrayMorpher

100%

46/46

94%

30/32

 /*
  * Copyright 2006-2007 the original author or authors.
  *
  * Licensed 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 net.sf.ezmorph.array;
 
 import java.lang.reflect.Array;
 
 import net.sf.ezmorph.MorphException;
 import net.sf.ezmorph.primitive.FloatMorpher;
 
 import org.apache.commons.lang.builder.EqualsBuilder;
 import org.apache.commons.lang.builder.HashCodeBuilder;
 
 /**
  * Morphs an array to a float[].
  *
  * @author Andres Almiray <aalmiray@users.sourceforge.net>
  */
 public final class FloatArrayMorpher extends AbstractArrayMorpher
 {
    private static final Class FLOAT_ARRAY_CLASS = float[].class;
    private float defaultValue;
 
    public FloatArrayMorpher()
    {
       super( false );
    }
 
    /**
     * @param defaultValue return value if the value to be morphed is null
     */
    public FloatArrayMorpher( float defaultValue )
    {
       super( true );
       this.defaultValue = defaultValue;
    }
 
    public boolean equals( Object obj )
    {
       if( this == obj ){
          return true;
       }
       if( obj == null ){
          return false;
       }
 
       if( !(obj instanceof FloatArrayMorpher) ){
          return false;
       }
 
       FloatArrayMorpher other = (FloatArrayMorpher) obj;
       EqualsBuilder builder = new EqualsBuilder();
       if( isUseDefault() && other.isUseDefault() ){
          builder.append( getDefaultValue(), other.getDefaultValue() );
          return builder.isEquals();
       }else if( !isUseDefault() && !other.isUseDefault() ){
          return builder.isEquals();
       }else{
          return false;
       }
    }
 
    /**
     * Returns the default value for this Morpher.
     */
    public float getDefaultValue()
    {
       return defaultValue;
    }
 
    public int hashCode()
    {
       HashCodeBuilder builder = new HashCodeBuilder();
       if( isUseDefault() ){
          builder.append( getDefaultValue() );
       }
       return builder.toHashCode();
    }
 
    public Object morph( Object array )
    {
       if( array == null ){
          return null;
       }
 
       if( FLOAT_ARRAY_CLASS.isAssignableFrom( array.getClass() ) ){
          // no conversion needed
          return (float[]) array;
       }
 
       if( array.getClass()
             .isArray() ){
          int length = Array.getLength( array );
          int dims = getDimensions( array.getClass() );
          int[] dimensions = createDimensions( dims, length );
          Object result = Array.newInstance( float.class, dimensions );
          FloatMorpher morpher = isUseDefault() ? new FloatMorpher( defaultValue )
                : new FloatMorpher();
          if( dims == 1 ){
             for( int index = 0; index < length; index++ ){
                Array.set( result, index, new Float( morpher.morph( Array.get( array, index ) ) ) );
             }
          }else{
             for( int index = 0; index < length; index++ ){
                Array.set( result, index, morph( Array.get( array, index ) ) );
             }
          }
          return result;
       }else{
          throw new MorphException( "argument is not an array: " + array.getClass() );
       }
    }
 
    public Class morphsTo()
    {
       return FLOAT_ARRAY_CLASS;
    }
 }

1		/*
2		* Copyright 2006-2007 the original author or authors.
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16
17		package net.sf.ezmorph.array;
18
19		import java.lang.reflect.Array;
20
21		import net.sf.ezmorph.MorphException;
22		import net.sf.ezmorph.primitive.FloatMorpher;
23
24		import org.apache.commons.lang.builder.EqualsBuilder;
25		import org.apache.commons.lang.builder.HashCodeBuilder;
26
27		/**
28		* Morphs an array to a float[].
29		*
30		* @author Andres Almiray <aalmiray@users.sourceforge.net>
31		*/
32	3	public final class FloatArrayMorpher extends AbstractArrayMorpher
33		{
34	5	private static final Class FLOAT_ARRAY_CLASS = float[].class;
35		private float defaultValue;
36
37		public FloatArrayMorpher()
38		{
39	132	super( false );
40	132	}
41
42		/**
43		* @param defaultValue return value if the value to be morphed is null
44		*/
45		public FloatArrayMorpher( float defaultValue )
46		{
47	637	super( true );
48	637	this.defaultValue = defaultValue;
49	637	}
50
51		public boolean equals( Object obj )
52		{
53	28	if( this == obj ){
54	8	return true;
55		}
56	20	if( obj == null ){
57	4	return false;
58		}
59
60	16	if( !(obj instanceof FloatArrayMorpher) ){
61	4	return false;
62		}
63
64	12	FloatArrayMorpher other = (FloatArrayMorpher) obj;
65	12	EqualsBuilder builder = new EqualsBuilder();
66	12	if( isUseDefault() && other.isUseDefault() ){
67	4	builder.append( getDefaultValue(), other.getDefaultValue() );
68	4	return builder.isEquals();
69	8	}else if( !isUseDefault() && !other.isUseDefault() ){
70	4	return builder.isEquals();
71		}else{
72	4	return false;
73		}
74		}
75
76		/**
77		* Returns the default value for this Morpher.
78		*/
79		public float getDefaultValue()
80		{
81	20	return defaultValue;
82		}
83
84		public int hashCode()
85		{
86	24	HashCodeBuilder builder = new HashCodeBuilder();
87	24	if( isUseDefault() ){
88	12	builder.append( getDefaultValue() );
89		}
90	24	return builder.toHashCode();
91		}
92
93		public Object morph( Object array )
94		{
95	76	if( array == null ){
96	4	return null;
97		}
98
99	72	if( FLOAT_ARRAY_CLASS.isAssignableFrom( array.getClass() ) ){
100		// no conversion needed
101	28	return (float[]) array;
102		}
103
104	44	if( array.getClass()
105	33	.isArray() ){
106	40	int length = Array.getLength( array );
107	40	int dims = getDimensions( array.getClass() );
108	40	int[] dimensions = createDimensions( dims, length );
109	40	Object result = Array.newInstance( float.class, dimensions );
110	70	FloatMorpher morpher = isUseDefault() ? new FloatMorpher( defaultValue )
111	27	: new FloatMorpher();
112	40	if( dims == 1 ){
113	60	for( int index = 0; index < length; index++ ){
114	44	Array.set( result, index, new Float( morpher.morph( Array.get( array, index ) ) ) );
115		}
116		}else{
117	60	for( int index = 0; index < length; index++ ){
118	40	Array.set( result, index, morph( Array.get( array, index ) ) );
119		}
120		}
121	36	return result;
122		}else{
123	4	throw new MorphException( "argument is not an array: " + array.getClass() );
124		}
125		}
126
127		public Class morphsTo()
128		{
129	1022	return FLOAT_ARRAY_CLASS;
130		}
131		}