libjava/classpath/javax/management/openmbean/ArrayType.java

   1 /* ArrayType.java -- Open type descriptor for an array.
   2    Copyright (C) 2006, 2007 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38 package javax.management.openmbean;
  39
  40 import java.lang.reflect.Array;
  41
  42 import java.util.HashMap;
  43 import java.util.Map;
  44
  45 /**
  46  * The open type descriptor for arrays of open data values.
  47  *
  48  * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
  49  * @since 1.5
  50  */
  51 public class ArrayType<T>
  52   extends OpenType<T>
  53 {
  54
  55   /**
  56    * Compatible with JDK 1.5
  57    */
  58   private static final long serialVersionUID = 720504429830309770L;
  59
  60   /**
  61    * The number of dimensions arrays of this type has.
  62    */
  63   private int dimension;
  64
  65   /**
  66    * The element type of arrays of this type.
  67    */
  68   private OpenType<?> elementType;
  69
  70   /**
  71    * True if this type represents a primitive array.
  72    */
  73   private boolean primitiveArray;
  74
  75   /**
  76    * The hash code of this instance.
  77    */
  78   private transient Integer hashCode;
  79
  80   /**
  81    * The <code>toString()</code> result of this instance.
  82    */
  83   private transient String string;
  84
  85   /**
  86    * A cache of {@link ArrayType} instances created
  87    * by {@link #getArrayType(OpenType)}.
  88    */
  89   private static final Map<OpenType<?>,ArrayType<?>> cache =
  90     new HashMap<OpenType<?>,ArrayType<?>>();
  91
  92   /**
  93    * A cache of {@link ArrayType} instances created
  94    * by {@link #getPrimitiveArrayType(Class)}.
  95    */
  96   private static final Map<Class<?>,ArrayType<?>> primCache =
  97     new HashMap<Class<?>,ArrayType<?>>();
  98
  99   /**
 100    * Returns the class name of the array, given the element
 101    * class name and its dimensions.
 102    *
 103    * @param elementType the type of the array's elements.
 104    * @param dim the dimensions of the array.
 105    * @param primitive true if this should be a primitive array.
 106    * @return the array's class name.
 107    * @throws OpenDataException if the class name does not reference
 108    *                           a loadable class.
 109    */
 110   private static final String getArrayClassName(OpenType<?> elementType,
 111                                                 int dim,
 112                                                 boolean primitive)
 113     throws OpenDataException
 114   {
 115     Class<?> type;
 116     if (primitive)
 117       type = getPrimitiveTypeClass((SimpleType<?>) elementType);
 118     else
 119       {
 120         String className = elementType.getClassName();
 121         try
 122           {
 123             type = Class.forName(className);
 124           }
 125         catch (ClassNotFoundException e)
 126           {
 127             throw new OpenDataException("The class name, " + className +
 128                                         ", is unavailable.");
 129           }
 130       }
 131     while (type.isArray())
 132       type = type.getComponentType();
 133     return
 134       Array.newInstance(type,
 135                         new int[getDimensions(elementType, dim)]).getClass().getName();
 136   }
 137
 138   /**
 139    * Returns the dimensions of the new {@link ArrayType},
 140    * based on whether the given element type is already an
 141    * {@link ArrayType} or not.
 142    *
 143    * @param elementType the type of the array.
 144    * @param dim the proposed dimensions.
 145    * @return the resultant dimensions.
 146    * @throws IllegalArgumentException if <code>dim</code> is less than 1.
 147    */
 148   private static final int getDimensions(OpenType<?> elementType,
 149                                          int dim)
 150   {
 151     if (dim < 1)
 152       throw new IllegalArgumentException("Dimensions must be greater " +
 153                                          "than or equal to 1.");
 154     if (elementType instanceof ArrayType)
 155       return dim + ((ArrayType<?>) elementType).getDimension();
 156     return dim;
 157   }
 158
 159   /**
 160    * Returns the appropriate primitive type name, given the
 161    * corresponding wrapper class.
 162    *
 163    * @param type the type to convert.
 164    * @return the corresponding primitive type.
 165    * @throws OpenDataException if {@code type} is not a valid
 166    *                           {@link Class} for a primitive type.
 167    *
 168    */
 169   private static final SimpleType<?> getPrimitiveType(Class<?> type)
 170     throws OpenDataException
 171   {
 172     if (type.equals(Boolean.TYPE))
 173       return SimpleType.BOOLEAN;
 174     if (type.equals(Byte.TYPE))
 175       return SimpleType.BYTE;
 176     if (type.equals(Character.TYPE))
 177       return SimpleType.CHARACTER;
 178     if (type.equals(Double.TYPE))
 179       return SimpleType.DOUBLE;
 180     if (type.equals(Float.TYPE))
 181       return SimpleType.FLOAT;
 182     if (type.equals(Integer.TYPE))
 183       return SimpleType.INTEGER;
 184     if (type.equals(Long.TYPE))
 185       return SimpleType.LONG;
 186     if (type.equals(Short.TYPE))
 187       return SimpleType.SHORT;
 188     if (type.equals(Void.TYPE))
 189       return SimpleType.VOID;
 190     throw new OpenDataException(type + " is not a primitive type.");
 191   }
 192
 193   /**
 194    * Returns the appropriate primitive type name, given the
 195    * corresponding wrapper class.
 196    *
 197    * @param type the type to convert.
 198    * @return the corresponding primitive type.
 199    * @throws OpenDataException if {@code type} is not a valid
 200    *                           {@link SimpleType} for a primitive type.
 201    *
 202    */
 203   private static final Class<?> getPrimitiveTypeClass(SimpleType<?> type)
 204     throws OpenDataException
 205   {
 206     if (type.equals(SimpleType.BOOLEAN))
 207       return Boolean.TYPE;
 208     if (type.equals(SimpleType.BYTE))
 209       return Byte.TYPE;
 210     if (type.equals(SimpleType.CHARACTER))
 211       return Character.TYPE;
 212     if (type.equals(SimpleType.DOUBLE))
 213       return Double.TYPE;
 214     if (type.equals(SimpleType.FLOAT))
 215       return Float.TYPE;
 216     if (type.equals(SimpleType.INTEGER))
 217       return Integer.TYPE;
 218     if (type.equals(SimpleType.LONG))
 219       return Long.TYPE;
 220     if (type.equals(SimpleType.SHORT))
 221       return Short.TYPE;
 222     if (type.equals(SimpleType.VOID))
 223       return Void.TYPE;
 224     throw new OpenDataException(type + " is not a primitive type.");
 225   }
 226
 227   /**
 228    * Returns the element type that will actually be used, if the
 229    * specified element type is passed to a constructor.  This is
 230    * necessary to ensure that a non-array type is still returned when
 231    * an {@link ArrayType} is constructed from an {@link ArrayType}.
 232    *
 233    * @param elemType the element type that was supplied.
 234    * @return the element type that will be used.
 235    */
 236   private static final OpenType<?> getElementType(OpenType<?> elemType)
 237   {
 238     if (elemType instanceof ArrayType)
 239       return ((ArrayType<?>) elemType).getElementOpenType();
 240     return elemType;
 241   }
 242
 243   /**
 244    * Returns the element type name that will actually be used, if the
 245    * specified element type is passed to a constructor.  This is
 246    * necessary to ensure that a non-array type is still returned when
 247    * an {@link ArrayType} is constructed from an {@link ArrayType},
 248    * and that primitive arrays are described correctly.
 249    *
 250    * @param elemType the element type that was supplied.
 251    * @return the element type name that will be used.
 252    * @throws OpenDataException if the element type is not a valid
 253    *                           {@link SimpleType} for a primitive type.
 254    */
 255   private static final String getElementTypeName(OpenType<?> elemType)
 256     throws OpenDataException
 257   {
 258     OpenType<?> trueElemType = getElementType(elemType);
 259     if (elemType instanceof ArrayType &&
 260         ((ArrayType<?>) elemType).isPrimitiveArray())
 261       return getPrimitiveTypeClass((SimpleType<?>) trueElemType).getName();
 262     return trueElemType.getClassName();
 263   }
 264
 265   /**
 266    * <p>
 267    * Constructs a new {@link ArrayType} instance for an array of the
 268    * specified type with the supplied number of dimensions.  The attributes
 269    * used by the superclass, {@link OpenType}, are automatically defined,
 270    * based on these values.  Both the class name and type name are set
 271    * to the value returned by the {@link java.lang.Class#getName()} of
 272    * the array's class (i.e. the element type, preceded by n instances of
 273    * '[' and an 'L', where n is the number of dimensions the array has).
 274    * The description is based upon the template <code>n-dimension array
 275    * of e</code>, where n is the number of dimensions of the array, and
 276    * e is the element type.  The class name of the actual elements is
 277    * obtainable by calling {@link OpenType#getClassName()} on the result
 278    * of {@link #getElementOpenType()}.
 279    * </p>
 280    * <p>
 281    * As an example, the array type returned by
 282    * <code>new ArrayType(6, SimpleType.INTEGER)</code> has the following
 283    * values:
 284    * </p>
 285    * <table>
 286    * <th><td>Attribute</td><td>Value</td></th>
 287    * <tr><td>Class Name</td><td><code>[[[[[[Ljava.lang.Integer;</code>
 288    * </td></tr>
 289    * <tr><td>Type Name</td><td><code>[[[[[[Ljava.lang.Integer;</code>
 290    * </td></tr>
 291    * <tr><td>Description</td><td><code>6-dimension array of
 292    * java.lang.Integer</code></td></tr>
 293    * <tr><td>Element Type Class Name</td><td><code>java.lang.Integer</code>
 294    * </td></tr>
 295    * </table>
 296    * <p>
 297    * The dimensions of the array must be equal to or greater than 1.  The
 298    * element type must be an instance of {@link SimpleType},
 299    * {@link CompositeType} or {@link TabularType}.
 300    * </p>
 301    *
 302    * @param dim the dimensions of the array.
 303    * @param elementType the type of the elements of the array.
 304    * @throws IllegalArgumentException if <code>dim</code> is less than 1.
 305    * @throws OpenDataException if the element type is not an instance of either
 306    *                           {@link SimpleType}, {@link CompositeType}
 307    *                           or {@link TabularType}.
 308    */
 309   public ArrayType(int dim, OpenType<?> elementType)
 310     throws OpenDataException
 311   {
 312     super(getArrayClassName(elementType, dim, false),
 313           getArrayClassName(elementType, dim, false),
 314           getDimensions(elementType, dim) + "-dimension array of "
 315           + getElementTypeName(elementType));
 316     if (!(elementType instanceof SimpleType ||
 317           elementType instanceof CompositeType ||
 318           elementType instanceof TabularType ||
 319           elementType instanceof ArrayType))
 320       throw new OpenDataException("The element type must be a simple " +
 321                                   "type, an array type, a composite type " +
 322                                   "or a tabular type.");
 323     dimension = getDimensions(elementType, dim);
 324     this.elementType = getElementType(elementType);
 325     primitiveArray = (elementType instanceof ArrayType &&
 326                       ((ArrayType<?>) elementType).isPrimitiveArray());
 327   }
 328
 329   /**
 330    * <p>
 331    * Constructs a new {@link ArrayType} instance for a unidimensional
 332    * array of the specified {@link SimpleType}.  The attributes
 333    * used by the superclass, {@link OpenType}, are automatically defined,
 334    * based on these values.  Both the class name and type name are set
 335    * to the value returned by the {@link java.lang.Class#getName()} of
 336    * the array's class.  If the array is of a primitive type (indicated
 337    * by giving {@code primitiveArray} the value {@code true}), the
 338    * name will be '[' followed by the appropriate letter for the
 339    * primitive type (see {@link java.lang.Class#getName()}).  If the
 340    * array is not of a primitive type, then the name is formed from
 341    * the element type, preceded by '[' and an 'L', in the same way
 342    * as when the multi-dimensional constructor is used.
 343    * </p>
 344    * <p>
 345    * The description is based upon the template <code>1-dimension array
 346    * of e</code>, where e is either the primitive type or a class name,
 347    * depending on whether the array itself is of a primitive type or not.
 348    * The class name of the actual elements is obtainable by calling
 349    * {@link OpenType#getClassName()} on the result of
 350    * {@link #getElementOpenType()}.  This will be the appropriate wrapper
 351    * class for a primitive type.
 352    * </p>
 353    * <p>
 354    * As an example, the array type returned by
 355    * <code>new ArrayType(SimpleType.INTEGER, true)</code> has the following
 356    * values:
 357    * </p>
 358    * <table>
 359    * <th><td>Attribute</td><td>Value</td></th>
 360    * <tr><td>Class Name</td><td><code>[I</code>
 361    * </td></tr>
 362    * <tr><td>Type Name</td><td><code>[I</code>
 363    * </td></tr>
 364    * <tr><td>Description</td><td><code>1-dimension array of int</code></td></tr>
 365    * <tr><td>Element Type Class Name</td><td><code>java.lang.Integer</code>
 366    * </td></tr>
 367    * </table>
 368    *
 369    * @param elementType the type of the elements of the array.
 370    * @param primitiveArray true if the array should be of a primitive type.
 371    * @throws OpenDataException if {@code primitiveArray} is {@code true},
 372    *                           and {@link elementType} is not a valid
 373    *                           {@link SimpleType} for a primitive type.
 374    * @since 1.6
 375    */
 376   public ArrayType(SimpleType<?> elementType, boolean primitiveArray)
 377     throws OpenDataException
 378   {
 379     super(getArrayClassName(elementType, 1, primitiveArray),
 380           getArrayClassName(elementType, 1, primitiveArray),
 381           "1-dimension array of " +
 382           (primitiveArray ? getPrimitiveTypeClass(elementType).getName()
 383            : elementType.getClassName()));
 384     dimension = 1;
 385     this.elementType = elementType;
 386     this.primitiveArray = primitiveArray;
 387   }
 388
 389   /**
 390    * <p>
 391    * Compares this array type with another object
 392    * for equality.  The objects are judged to be equal if:
 393    * </p>
 394    * <ul>
 395    * <li><code>obj</code> is not null.</li>
 396    * <li><code>obj</code> is an instance of
 397    * {@link ArrayType}.</li>
 398    * <li>The dimensions are equal.</li>
 399    * <li>The element types are equal.</li>
 400    * <li>The primitive array flag is set the same in both
 401    * instances.</li>
 402    * </ul>
 403    *
 404    * @param obj the object to compare with.
 405    * @return true if the conditions above hold.
 406    */
 407   public boolean equals(Object obj)
 408   {
 409     if (!(obj instanceof ArrayType))
 410       return false;
 411     ArrayType<?> atype = (ArrayType<?>) obj;
 412     return (atype.getDimension() == dimension &&
 413             atype.getElementOpenType().equals(elementType) &&
 414             atype.isPrimitiveArray() == primitiveArray);
 415   }
 416
 417   /**
 418    * <p>
 419    * Returns a new {@link ArrayType} instance in a type-safe
 420    * manner, by ensuring that the type of the given {@link OpenType}
 421    * matches the component type used in the type of the
 422    * returned instance.  If the given {@link OpenType} is a
 423    * {@link SimpleType}, {@link CompositeType} or
 424    * {@link TabularType}, then a 1-dimensional array of that
 425    * type is returned.  Otherwise, if the type is
 426    * an {@link ArrayType} of n dimensions, the returned
 427    * type is also an {@link ArrayType} but of n+1 dimensions.
 428    * For example,
 429    * {@code ArrayType.getArrayType(ArrayType.getArrayType(SimpleType.STRING))}
 430    * returns a 2-dimensional array of {@link SimpleType#String}.
 431    * </p>
 432    * <p>
 433    * This method caches its results, so that the same instance
 434    * is returned from subsequent calls with the same parameters.
 435    * </p>
 436    *
 437    * @param elementType the element type of the new array type.
 438    * @throws OpenDataException if the class name of {@code elementType}
 439    *                           is not in {@link OpenType#ALLOWED_CLASSNAMES_LIST}.
 440    * @since 1.6
 441    */
 442   @SuppressWarnings("unchecked")
 443   public static <E> ArrayType<E[]> getArrayType(OpenType<E> elementType)
 444     throws OpenDataException
 445   {
 446     ArrayType<E[]> arr = (ArrayType<E[]>) cache.get(elementType);
 447     if (arr != null)
 448       return arr;
 449     arr = new ArrayType<E[]>(1, elementType);
 450     cache.put(elementType, arr);
 451     return arr;
 452   }
 453
 454   /**
 455    * <p>
 456    * Returns a new {@link ArrayType} instance for the given
 457    * primitive type in a type-safe* manner, by ensuring that
 458    * the type of the given {@link OpenType} matches the type
 459    * used in the returned instance.  If the type is
 460    * an array of n dimensions, the returned
 461    * type is also an {@link ArrayType} of n dimensions.
 462    * </p>
 463    * <p>
 464    * As an example, the array type returned by
 465    * <code>getPrimitiveArrayType(Integer.TYPE)</code> has the
 466    * following values:
 467    * </p>
 468    * <table>
 469    * <th><td>Attribute</td><td>Value</td></th>
 470    * <tr><td>Class Name</td><td><code>[I</code>
 471    * </td></tr>
 472    * <tr><td>Type Name</td><td><code>[I</code>
 473    * </td></tr>
 474    * <tr><td>Description</td><td><code>1-dimension array of int</code></td></tr>
 475    * <tr><td>Element Type Class Name</td><td><code>java.lang.Integer</code>
 476    * </td></tr>
 477    * </table>
 478    * <p>
 479    * This method caches its results, so that the same instance
 480    * is returned from subsequent calls with the same parameters.
 481    * </p>
 482    *
 483    * @param type the type of the new {@link ArrayType}.
 484    * @throws IllegalArgumentException if the type is not a primitive
 485    *                                  array.
 486    * @since 1.6
 487    */
 488   @SuppressWarnings("unchecked")
 489   public static <T> ArrayType<T> getPrimitiveArrayType(Class<T> type)
 490   {
 491     ArrayType<T> arr = (ArrayType<T>) primCache.get(type);
 492     if (arr != null)
 493       return arr;
 494     Class<?> comType = type;
 495     int dim = 0;
 496     do
 497       {
 498         comType = comType.getComponentType();
 499         ++dim;
 500         if (comType == null)
 501           throw new IllegalArgumentException("The given class is " +
 502                                              "not an array.");
 503       } while (comType.isArray());
 504     try
 505       {
 506         arr = new ArrayType<T>(getPrimitiveType(comType), true);
 507       }
 508     catch (OpenDataException e)
 509       {
 510         throw new IllegalArgumentException("The array is not of a primitive " +
 511                                            "type", e);
 512       }
 513     while (dim > 1)
 514       try
 515         {
 516           arr = new ArrayType<T>(1, arr);
 517           --dim;
 518         }
 519       catch (OpenDataException e)
 520         {
 521           throw (Error)
 522             new InternalError("Couldn't generate extra dimensions").initCause(e);
 523         }
 524     primCache.put(type, arr);
 525     return arr;
 526   }
 527
 528   /**
 529    * Returns the number of dimensions used by arrays
 530    * of this type.
 531    *
 532    * @return the number of dimensions.
 533    */
 534   public int getDimension()
 535   {
 536     return dimension;
 537   }
 538
 539   /**
 540    * Returns the open type descriptor which describes
 541    * the type of the elements of this array type.
 542    *
 543    * @return the type of the elements.
 544    */
 545   public OpenType<?> getElementOpenType()
 546   {
 547     return elementType;
 548   }
 549
 550   /**
 551    * <p>
 552    * Returns the hash code of the array type.
 553    * This is computed as the sum of the hash code of the
 554    * element type together with the number of dimensions
 555    * the array has and the primitive array flag.  These
 556    * are the same elements of the type that are compared as
 557    * part of the {@link #equals(java.lang.Object)} method,
 558    * thus ensuring that the hashcode is compatible with the
 559    * equality test.
 560    * </p>
 561    * <p>
 562    * As instances of this class are immutable, the hash code
 563    * is computed just once for each instance and reused
 564    * throughout its life.
 565    * </p>
 566    *
 567    * @return the hash code of this instance.
 568    */
 569   public int hashCode()
 570   {
 571     if (hashCode == null)
 572       hashCode = Integer.valueOf(dimension +
 573                                  elementType.hashCode() +
 574                                  Boolean.valueOf(primitiveArray).hashCode());
 575     return hashCode.intValue();
 576   }
 577
 578   /**
 579    * Returns true if this instance represents an array of
 580    * a primitive type.
 581    *
 582    * @return true if the array is of a primitive type.
 583    */
 584   public boolean isPrimitiveArray()
 585   {
 586     return primitiveArray;
 587   }
 588
 589   /**
 590    * <p>
 591    * Returns true if the specified object is a member of this
 592    * array type.  The object is judged to be so if it is
 593    * non-null, an array and one of the following two conditions
 594    * holds:
 595    * </p>
 596    * <ul>
 597    * <li>This {@link ArrayType} instance has a {@link SimpleType}
 598    * as its element type.  Thus, the object must have the same
 599    * class name as that returned by {@link SimpleType#getClassName()}
 600    * for this class.</li>
 601    * <li>This {@link ArrayType} instance has a {@link CompositeType}
 602    * or a {@link TabularType} as its element type.  Thus, the object
 603    * must be assignable to such an array, and have elements which
 604    * are either null or valid values for the element type.</li>
 605    * </ul>
 606    *
 607    * @param obj the object to test for membership.
 608    * @return true if the object is a member of this type.
 609    */
 610   public boolean isValue(Object obj)
 611   {
 612     if (obj == null)
 613       return false;
 614     Class<?> objClass = obj.getClass();
 615     if (!(objClass.isArray()))
 616       return false;
 617     if (elementType instanceof SimpleType)
 618       return getClassName().equals(objClass.getName());
 619     Class<?> elementClass = null;
 620     try
 621       {
 622         elementClass = Class.forName(getClassName());
 623       }
 624     catch (ClassNotFoundException e)
 625       {
 626         throw new IllegalStateException("The array type's element " +
 627                                         "class could not be found.", e);
 628       }
 629     if (!(elementClass.isAssignableFrom(objClass)))
 630       return false;
 631     for (int a = 0; a < Array.getLength(obj); ++a)
 632       {
 633         Object elem = Array.get(obj, a);
 634         if (elem != null &&
 635             (!(elementType.isValue(elem))))
 636           return false;
 637       }
 638     return true;
 639   }
 640
 641   /**
 642    * <p>
 643    * Returns a textual representation of this instance.  This
 644    * is constructed using the class name
 645    * (<code>javax.management.openmbean.ArrayType</code>)
 646    * and each element of the instance which is relevant to
 647    * the definition of {@link equals(java.lang.Object)} and
 648    * {@link hashCode()} (i.e. the type name, the number of
 649    * dimensions and the element type).
 650    * </p>
 651    * <p>
 652    * As instances of this class are immutable, the return value
 653    * is computed just once for each instance and reused
 654    * throughout its life.
 655    * </p>
 656    *
 657    * @return a @link{java.lang.String} instance representing
 658    *         the instance in textual form.
 659    */
 660   public String toString()
 661   {
 662     if (string == null)
 663       string = getClass().getName()
 664         + "[name=" + getTypeName()
 665         + ", dimension=" + dimension
 666         + ", elementType=" + elementType
 667         + ", primitiveArray=" + primitiveArray
 668         + "]";
 669     return string;
 670   }
 671
 672 }