<p>
It returns the {@link String} representation of the input number
</p>

@return the {@link String} representation of the input
191095
public static final Function<Double,String> toStr() {
        return (Function<Double,String>)((Function)FnNumber.toStr());
    }
531710
public String getString() 
    {
        String string = super.getString();
        if ((string != null) && (string.length() > 0))
            string = this.decodeString(string);
        return string;
    }
1356641
public String getString() {
        int len = getInt();
        String s = new String(_buffer, _offset, len, RpcRequest.CHARSET);
        skip(len);
        return s;
    }
916053
public String toStringValue() {
        return value instanceof String ? (QUOTE + value + QUOTE) : String.valueOf(value);
    }
612219
public static final Function<Double,String> toCurrencyStr() {
        return (Function<Double,String>)((Function)FnNumber.toCurrencyStr());
    }
868538
public String getString()
    {
        String string = super.getString();
        int iIndent = (int)m_convIndent.getValue();
        string = gstrSpaces.substring(0, iIndent * m_iIndentAmount) + string;
        return string;
    }
886629
public static <T extends Number> String str(T x) {
        return str(x, FuzzyLite.getFormatter());
    }
662137
public String getString() 
    {
        String string = super.getString();  // By default, get the data as-is
        if (this.getField() instanceof NumberField)
        {
            double dValue = this.getField().getValue();
            if (m_bDebit)
            {
                if (dValue < 0)
                    string = Constants.BLANK; // For debit/negative, return a null
            }
            else
            {   // Credit
                if (dValue >= 0)
                    string = Constants.BLANK; // For credit/positive, return a null
                else
                    string = ((NumberField)this.getField()).binaryToString(new Double(-dValue));  // Positive representation
            }
        }
        return string;
    }
685564
public String asString() {
    final StringBuilder builder = new StringBuilder();
    boolean first = true;
    for (int i = 1; i < this.nodeList.size(); i++) {
      final NodeImpl nodeImpl = (NodeImpl) this.nodeList.get(i);
      final String name = nodeImpl.asString();
      if (name.isEmpty()) {
        // skip the node if it does not contribute to the string representation of the path, eg
        // class level constraints
        continue;
      }

      if (!first) {
        builder.append(PROPERTY_PATH_SEPARATOR);
      }

      builder.append(nodeImpl.asString());

      first = false;
    }
    return builder.toString();
  }
336300
public byte[] getOctetString() throws IOException {
        if (buffer.read() != DerValue.tag_OctetString)
            throw new IOException("DER input not an octet string");

        int length = getLength(buffer);
        byte[] retval = new byte[length];
        if ((length != 0) && (buffer.read(retval) != length))
            throw new IOException("short read of DER octet string");

        return retval;
    }
31425
public static final Function<Float,String> toStr() {
	    return (Function<Float,String>)((Function)FnNumber.toStr());
    }
290921
public String readString()
        throws IOException
    {
        int tag = is.read();

        if (tag == 'N')
            return null;

        if (tag != 'S')
            throw expect("string", tag);

        int b16 = is.read();
        int b8 = is.read();

        int len = (b16 << 8) + b8;

        return readStringImpl(len);
    }
77550
public static final String getString(InputStream is) throws IOException
   {
      int type = is.read();
      if (type != 1)
      {
         throw new IllegalArgumentException("Unexpected string format");
      }

      Charset charset = CharsetHelper.UTF8;
      
      int length = is.read();
      if (length == 0xFF)
      {
         length = getShort(is);
         if (length == 0xFFFE)
         {
            charset = CharsetHelper.UTF16LE;
            length = (is.read() * 2);
         }
      }

      String result;
      if (length == 0)
      {
         result = null;
      }
      else
      {
         byte[] stringData = new byte[length];         
         is.read(stringData);
         result = new String(stringData, charset);
      }
      return result;
   }
974001
public final String toHexString() {
		if (this.hexString == null) {
			final byte[] ba = new byte[SIZE];
			longToByteArray(this.lowerPart, ba, 0);
			longToByteArray(this.upperPart, ba, SIZE_OF_LONG);

			this.hexString = StringUtils.byteToHexString(ba);
		}

		return this.hexString;
	}
1317364
public static String encodeString(final String s) {
		if (s != null) {
			final StringBuilder sb = new StringBuilder(s.length() + s.length() / 4);
			encodeString(sb, s);
			return sb.toString();
		}
		return "";
	}
743031
public String readString() {
    int size = value.size();
    if (size > Constants.MaxStringSize)
      size = Constants.MaxStringSize;

    if (value == null || size == 0)
      return "";

    byte[] bbs = new byte[size - 1];
    for (int i = 0; i < size - 1; i++) {
      abstractTiffType att = value.get(i);
      bbs[i] = att.toByte();
    }
    try {
      return new String(bbs, "UTF8");
    } catch (UnsupportedEncodingException e) {
      return "";
    }
  }
711440
public String getAsString()
   {

      if (stringName == null)
      {

         StringBuilder str = new StringBuilder();
         for (int i = 0; i < getLength(); i++)
         {
            str.append(names[i].getAsString(true));
         }
         stringName = str.toString();
      }

      return stringName;
   }