Mercurial > jdk8-mips64-public > corba / file revision

 /*

  * Copyright (c) 2000, 2003, Oracle and/or its affiliates. All rights reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  *

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.  Oracle designates this

  * particular file as subject to the "Classpath" exception as provided

  * by Oracle in the LICENSE file that accompanied this code.

  *

  * This code 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

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

  * or visit www.oracle.com if you need additional information or have any

  * questions.

  */

 package com.sun.corba.se.impl.dynamicany;

 import org.omg.CORBA.TypeCode;

 import org.omg.CORBA.Any;

 import org.omg.CORBA.NO_IMPLEMENT;

 import org.omg.DynamicAny.*;

 import org.omg.DynamicAny.DynAnyPackage.*;

 import java.math.BigDecimal;

 import java.math.BigInteger;

 import org.omg.CORBA.TypeCodePackage.BadKind;

 import com.sun.corba.se.spi.orb.ORB ;

 import com.sun.corba.se.spi.logging.CORBALogDomains ;

 import com.sun.corba.se.impl.logging.ORBUtilSystemException ;

 public class DynFixedImpl extends DynAnyBasicImpl implements DynFixed

 {

     //

     // Constructors

     //

     private DynFixedImpl() {

         this(null, (Any)null, false);

     }

     protected DynFixedImpl(ORB orb, Any any, boolean copyValue) {

         super(orb, any, copyValue);

     }

     // Sets the current position to -1 and the value to zero.

     protected DynFixedImpl(ORB orb, TypeCode typeCode) {

         super(orb, typeCode);

         index = NO_INDEX;

     }

     //

     // DynAny interface methods

     //

 /*

     public int component_count() {

         return 0;

     }

 */

     //

     // DynFixed interface methods

     //

     public String get_value () {

         if (status == STATUS_DESTROYED) {

             throw wrapper.dynAnyDestroyed() ;

         }

         return any.extract_fixed().toString();

     }

     // Initializes the value of the DynFixed.

     // The val string must contain a fixed string constant in the same format

     // as used for IDL fixed-point literals.

     //

     // It may consist of an integer part, an optional decimal point,

     // a fraction part and an optional letter d or D.

     // The integer and fraction parts both must be sequences of decimal (base 10) digits.

     // Either the integer part or the fraction part, but not both, may be missing.

     //

     // If val contains a value whose scale exceeds that of the DynFixed or is not initialized,

     // the operation raises InvalidValue.

     // The return value is true if val can be represented as the DynFixed without loss of precision.

     // If val has more fractional digits than can be represented in the DynFixed,

     // fractional digits are truncated and the return value is false.

     // If val does not contain a valid fixed-point literal or contains extraneous characters

     // other than leading or trailing white space, the operation raises TypeMismatch.

     //

     public boolean set_value (String val)

         throws org.omg.DynamicAny.DynAnyPackage.TypeMismatch,

                org.omg.DynamicAny.DynAnyPackage.InvalidValue

     {

         if (status == STATUS_DESTROYED) {

             throw wrapper.dynAnyDestroyed() ;

         }

         int digits = 0;

         int scale = 0;

         boolean preservedPrecision = true;

         try {

             digits = any.type().fixed_digits();

             scale = any.type().fixed_scale();

         } catch (BadKind ex) { // impossible

         }

         // First get rid of leading or trailing whitespace which is allowed

         String string = val.trim();

         if (string.length() == 0)

             throw new TypeMismatch();

         // Now scan for the sign

         String sign = "";

         if (string.charAt(0) == '-') {

             sign = "-";

             string = string.substring(1);

         } else if (string.charAt(0) == '+') {

             sign = "+";

             string = string.substring(1);

         }

         // Now get rid of the letter d or D.

         int dIndex = string.indexOf('d');

         if (dIndex == -1) {

             dIndex = string.indexOf('D');

         }

         if (dIndex != -1) {

             string = string.substring(0, dIndex);

         }

         // Just to be sure

         if (string.length() == 0)

             throw new TypeMismatch();

         // Now look for the dot to determine the integer part

         String integerPart;

         String fractionPart;

         int currentScale;

         int currentDigits;

         int dotIndex = string.indexOf('.');

         if (dotIndex == -1) {

             integerPart = string;

             fractionPart = null;

             currentScale = 0;

             currentDigits = integerPart.length();

         } else if (dotIndex == 0 ) {

             integerPart = null;

             fractionPart = string;

             currentScale = fractionPart.length();

             currentDigits = currentScale;

         } else {

             integerPart = string.substring(0, dotIndex);

             fractionPart = string.substring(dotIndex + 1);

             currentScale = fractionPart.length();

             currentDigits = integerPart.length() + currentScale;

         }

         // Let's see if we have to drop some precision

         if (currentDigits > digits) {

             preservedPrecision = false;

             // truncate the fraction part

             if (integerPart.length() < digits) {

                 fractionPart = fractionPart.substring(0, digits - integerPart.length());

             } else if (integerPart.length() == digits) {

                 // currentScale > 0

                 // drop the fraction completely

                 fractionPart = null;

             } else {

                 // integerPart.length() > digits

                 // unable to truncate fraction part

                 throw new InvalidValue();

             }

         }

         // If val contains a value whose scale exceeds that of the DynFixed or is not initialized,

         // the operation raises InvalidValue.

         // Reinterpreted to mean raise InvalidValue only if the integer part exceeds precision,

         // which is handled above (integerPart.length() > digits)

 /*

         if (currentScale > scale) {

             throw new InvalidValue("Scale exceeds " + scale);

         }

 */

         // Now check whether both parts are valid numbers

         BigDecimal result;

         try {

             new BigInteger(integerPart);

             if (fractionPart == null) {

                 result = new BigDecimal(sign + integerPart);

             } else {

                 new BigInteger(fractionPart);

                 result = new BigDecimal(sign + integerPart + "." + fractionPart);

             }

         } catch (NumberFormatException nfe) {

             throw new TypeMismatch();

         }

         any.insert_fixed(result, any.type());

         return preservedPrecision;

     }

     public String toString() {

         int digits = 0;

         int scale = 0;

         try {

             digits = any.type().fixed_digits();

             scale = any.type().fixed_scale();

         } catch (BadKind ex) { // impossible

         }

         return "DynFixed with value=" + this.get_value() + ", digits=" + digits + ", scale=" + scale;

     }

 }