/*
    * Copyright (c) 2001, Zoltan Farkas All Rights Reserved.
    *
    * 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 General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this program; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
   */
  package net.sf.zel.nr;
  
  import java.math.BigDecimal;
  import java.math.BigInteger;
  import javax.annotation.concurrent.Immutable;
  import net.sf.zel.nr.ExtendedNumber.Type;
  
  @Immutable
  public final class OperableLong extends OperableNumber
  {
  
      private static final long serialVersionUID = 6989912035116276536L;
      public static final OperableLong ZERO = new OperableLong(0L);
      public static final OperableLong ONE = new OperableLong(1L);
      private final long number;
  
      public OperableLong(final long n)
      {
          number = n;
      }
  
      public OperableLong(final String val)
      {
          number = Long.parseLong(val);
      }
  
  
      @Override
      public OperableNumber zero()
      {
          return ZERO;
      }
  
      @Override
      public OperableNumber add(OperableNumber addend)
      {
          long b = addend.longValue();
          long result = number + b;
          if (((number ^ result) & (b ^ result)) < 0)
          {
              return new OperableBigInteger(BigInteger.valueOf(number).add(BigInteger.valueOf(b)));
          } else
          {
              return new OperableLong(result);
          }
      }
  
      @Override
      public OperableNumber subtract(OperableNumber subtrahend)
      {
          long b = subtrahend.longValue();
          long result = number - b;
          if (((number ^ result) & ((-b) ^ result)) < 0)
          {
              return new OperableBigInteger(BigInteger.valueOf(number).subtract(BigInteger.valueOf(b)));
          } else
          {
              return new OperableLong(result);
          }
      }
  
      @Override
      public OperableNumber multiply(OperableNumber multiplier)
      {
          return new OperableBigInteger(BigInteger.valueOf(number).multiply(BigInteger.valueOf(multiplier.longValue())));
      }
  
      @Override
      public OperableNumber divide(OperableNumber divisor)
      {
          return new OperableLong(number / divisor.longValue());
      }
  
      @Override
      public OperableNumber mod(OperableNumber divisor)
      {
          return new OperableLong(number % divisor.longValue());
      }
  
      @Override
      public BigDecimal bigDecimalValue()
      {
         return BigDecimal.valueOf(number);
     }
 
     @Override
     public BigInteger bigIntegerValue()
     {
         return BigInteger.valueOf(number);
     }
 
     public int compareTo(OperableNumber o)
     {
         long other = o.longValue();
         if (number > other)
         {
             return 1;
         } else if (number == other)
         {
             return 0;
         } else
         {
             return -1;
         }
     }
 
     @Override
     public Type getType()
     {
         return Type.INTEGER;
     }
 
     @Override
     public OperableGNUBigInteger gnuBigIntegerValue()
     {
         return new OperableGNUBigInteger(toString());
     }
 
     @Override
     public int intValue()
     {
         return (int) number;
     }
 
     @Override
     public long longValue()
     {
         return (long) number;
     }
 
     @Override
     public float floatValue()
     {
         return (float) number;
     }
 
     @Override
     public double doubleValue()
     {
         return (double) number;
     }
 
     @Override
     public int compareTo(final Object o)
     {
         long other = ((OperableNumber) o).longValue();
         if (number > other)
         {
             return 1;
         } else if (number == other)
         {
             return 0;
         } else
         {
             return -1;
         }
     }
 
     @Override
     public String toString()
     {
         return Long.toString(number);
     }
 
     @Override
     public boolean equals(Object obj)
     {
         if (obj == null)
         {
             return false;
         }
         if (getClass() != obj.getClass())
         {
             return false;
         }
         final OperableLong other = (OperableLong) obj;
         if (this.number != other.number)
         {
             return false;
         }
         return true;
     }
 
     @Override
     public int hashCode()
     {
         return (int) number;
     }
 
     @Override
     public OperableGNUBigFloat gnuBigFloatValue()
     {
         return new OperableGNUBigFloat(toString());
     }
 
     @Override
     public int getPrecision()
     {
         return 64;
     }
 
     @Override
     public OperableNumber create(final String val)
     {
         if ("0".equals(val))
             return ZERO;
         else
             return new OperableLong(val);
     }
 
     @Override
     public ExtendedNumber one()
     {
         return ONE;
     }
 
     @Override
     public OperableNumber convert(ExtendedNumber val)
     {
         return new OperableLong(val.longValue());
     }
 
 
 }