package net.sourceforge.jparam.conversion.converters;
   
   import net.sourceforge.jparam.JParamException;
   import net.sourceforge.jparam.conversion.weights.ScalarConversionWeight;
   import net.sourceforge.jparam.typename.TypeNameRegistry;
   
   /***
    * @author Ron_Sidi
    *
   * The base class for all converters, it implements all the basic funcionality
   * of a converter.
   * 
   */
  public abstract class AbstractConverter implements IConverter {
  
      /***
       * the source and target classes, and conversion weight, subclasses
       * must initialize these in order to index the converter correctly
       */
      Class sourceClass;
  
      Class targetClass;
  
      ScalarConversionWeight conversionWeight;
  
      /* (non-Javadoc)
       * @see net.sourceforge.jparam.conversion.converters.IConverter#getTargetClass()
       */
      public Class getTargetClass() {
          return targetClass;
      }
  
      /* (non-Javadoc)
       * @see net.sourceforge.jparam.conversion.converters.IConverter#getWeight()
       */
      public ScalarConversionWeight getWeight() {
          return conversionWeight;
      }
  
      /* (non-Javadoc)
       * @see net.sourceforge.jparam.conversion.converters.IConverter#getSourceClass()
       */
      public Class getSourceClass() {
          return sourceClass;
      }
  
      /* (non-Javadoc)
       * @see net.sourceforge.jparam.conversion.converters.IConverter#convert(java.lang.Object)
       */
      public Object convert(Object o) throws JParamException {
          // Verify the given <code>Object</code> is the expected one
          if (!sourceClass.isInstance(o)) {
              throw new JParamException("Cannot convert from: " + o.getClass()
                      + " supported class: " + sourceClass);
          }
  
          try {
              // Use the overriden internal create method
              Object ret = internalConvert(o);
  
              // Verify the returned object is of the expected instance, if for
              // some reason there is a bug in the converter, we want to find it
              // as soon as possible, we use isInstance and not exact class
              // comparison since we have no static types in Java hence there is
              // no way of returnig something like the super class
              if (!targetClass.isInstance(ret)) {
                  throw new JParamException("Converter returned invalid class: " + ret.getClass()
                          + " expected class: " + targetClass + "\nReturned value: " + ret);
              }
              return ret;
          } catch (JParamException e) {
              // If an "expected" exception was thrown, forward it so the original
              // error is reported
              throw e;
          } catch (Exception e) {
              // Wrap the thrown exception with a supported exception
              throw new JParamException(
                      "Unexpected error occured while converting: " + o + " to: "
                              + targetClass, e);
          }
      }
  
      /***
       * Internal conversion method, all subclasses must implement the actual
       * conversion logic here
       * <p>
       * No tests are needed since the given object is of the expected type
       * 
       * @param o An object instanceof <code>getSourceClass</code>
       * @return An object instanceof <code>getTargetClass</code>
       * @throws Exception If there was an error performing the conversion
       */
      protected abstract Object internalConvert(Object o) throws Exception;
  
      /* (non-Javadoc)
       * @see java.lang.Object#toString()
       */
      public String toString() {
          StringBuffer result = new StringBuffer();
         result.append(toConversionString());
         result.append("(");
         result.append(conversionWeight);
         result.append(")");
 
         return result.toString();
     }
 
     public String toConversionString() {
         StringBuffer result = new StringBuffer();
         try {
             // the conversion string should use the JParam type name
             result.append(TypeNameRegistry.getInstance().getJParamTypeName(
                     sourceClass));
         } catch (JParamException e) {
             // if there is no type then use the Java Class name
             result.append(sourceClass.getName());
         }
 
         result.append(" -> ");
 
         try {
             result.append(TypeNameRegistry.getInstance().getJParamTypeName(
                     targetClass));
         } catch (JParamException e) {
             result.append(targetClass.getName());
         }
 
         return result.toString();
     }
 
     /***
      * Tests if this converter is equal to the given converter, all validity
      * checks of source/target/weight and class instance are performed in the
      * <code>equal</code> method, the derived class can perform all casts with
      * no verification
      * 
      * The check must verify equality, and not similarity meaning to converters
      * performing the same conversion with the same weight are not necesarily
      * equal, for instance two conversion paths from the same source to the same
      * target but not through the same types, will cause ambiguity if not equal
      * 
      * @param o A converter to check for equality
      * @return true if the converters are equal
      */
     protected abstract boolean converterEquals(IConverter o);
 
     /* (non-Javadoc)
      * @see java.lang.Object#hashCode()
      */
     public int hashCode() {
         return sourceClass.hashCode() * 37 + targetClass.hashCode() * 37
                 + conversionWeight.hashCode();
     }
 
     /***
      * Verify all trivial tests, and let subclass to specific verification
      * only
      * 
      * @see java.lang.Object#equals(java.lang.Object)
      */
     public boolean equals(Object obj) {
         if (!obj.getClass().equals(this.getClass())) {
             return false;
         }
 
         AbstractConverter other = (AbstractConverter) obj;
 
         if (!sourceClass.equals(other.sourceClass)) {
             return false;
         }
         if (!targetClass.equals(other.targetClass)) {
             return false;
         }
         if (!conversionWeight.equals(other.conversionWeight)) {
             return false;
         }
 
         return converterEquals(other);
     }
 }