Returns the formatter. Creates it lazily.
@param {sap.ui.model.odata.type.Double} oType
the type instance
@returns {sap.ui.core.format.NumberFormat}
the formatter
760909
function getFormatter(oType) {
		var oFormatOptions;

		if (!oType.oFormat) {
			oFormatOptions = jQuery.extend({groupingEnabled : true}, oType.oFormatOptions);
			oType.oFormat = NumberFormat.getFloatInstance(oFormatOptions);
		}
		return oType.oFormat;
	}
1284258
public static JKType getType(int typeNumber) {
		JKType sqlDataType = codeToJKTypeMapping.get(typeNumber);
		if (sqlDataType == null) {
			logger.debug("No mapping found for datatype , default mapping will return " + typeNumber);
			return DEFAULT_MAPPING;
		}
		return sqlDataType;
	}
560604
function formatType6(indexedPropPath) {
    return function(index_) {
      return function(f) {
        return function(t) {
          return function(propPath_) {
            var indexedPropPath_ = Z.concat ([index_], propPath_);
            var p = isPrefix (indexedPropPath_) (indexedPropPath);
            var q = isPrefix (indexedPropPath) (indexedPropPath_);
            return p && q ? f : p ? I : _;
          };
        };
      };
    };
  }
380676
def format(object, type = nil)
      core_class = cast(object, type)
      awesome = if core_class != :self
        send(:"awesome_#{core_class}", object) # Core formatters.
      else
        awesome_self(object, type) # Catch all that falls back to object.inspect.
      end
      awesome
    end
251902
Format getFormat() {
    final int ordinal;
    final Flavor f = getFlavor();
    if ((f == Flavor.HYBRID) || (f == Flavor.SPARSE)) {
      ordinal = 2 | ( mergeFlag ? 0 : 1 ); //Hybrid is serialized as SPARSE
    } else {
      ordinal = ((slidingWindow != null) ? 4 : 0)
               | (((pairTable != null) && (pairTable.getNumPairs() > 0)) ? 2 : 0)
               | ( mergeFlag ? 0 : 1 );
    }
    return Format.ordinalToFormat(ordinal);
  }
292411
private NumberFormat createFormatter(Locale loc) throws JspException {
        NumberFormat formatter = null;

        if ((type == null) || NUMBER.equalsIgnoreCase(type)) {
            formatter = NumberFormat.getNumberInstance(loc);
        } else if (CURRENCY.equalsIgnoreCase(type)) {
            formatter = NumberFormat.getCurrencyInstance(loc);
        } else if (PERCENT.equalsIgnoreCase(type)) {
            formatter = NumberFormat.getPercentInstance(loc);
        } else {
            throw new JspException(
                    Resources.getMessage("FORMAT_NUMBER_INVALID_TYPE", type));
        }

        return formatter;
    }
797404
function getFormattedValue(value) {
            let format;

            if (isInteger(value)) {
                format = formatIntegerValue;
            } else {
                format = formatDecimalValue;
            }

            return format(value);
        }
407560
function (context, type, value, options) {
    var FORMATTER;

    switch (type) {
      case 'number':
        FORMATTER = {
          constructor: Intl.NumberFormat,
          cachedInstance: context.$i18n.NUMBER_FORMATTER
        };
        break
      case 'currency':
        FORMATTER = {
          constructor: Intl.CurrencyFormat,
          cachedInstance: context.$i18n.CURRENCY_FORMATTER
        };
        break
      case 'date':
        FORMATTER = {
          constructor: Intl.DateTimeFormat,
          cachedInstance: context.$i18n.DATE_TIME_FORMATTER
        };
        break
    }

    if (FORMATTER && value !== undefined && value !== null && value !== false) {
      if (typeof options === 'object') {
        options = Object.assign(context.$i18n[(type + "Format")], options);
      } else {
        options = undefined;
      }

      return options ? new FORMATTER.constructor(context.$i18n.activeLocale, options).format(value) : FORMATTER.cachedInstance.format(value)
    } else {
      return value
    }
  }
376211
@SuppressWarnings("unchecked")
	public static TypeInformation createExternalTypeInfoFromInternalType(InternalType type) {
		TypeInformation typeInfo = INTERNAL_TYPE_TO_EXTERNAL_TYPE_INFO.get(type);
		if (typeInfo != null) {
			return typeInfo;
		}

		if (type instanceof RowType) {
			RowType rowType = (RowType) type;
			return new RowTypeInfo(Arrays.stream(rowType.getFieldTypes())
					.map(TypeConverters::createExternalTypeInfoFromInternalType)
					.toArray(TypeInformation[]::new),
					rowType.getFieldNames());
		} else if (type instanceof ArrayType) {
			return ObjectArrayTypeInfo.getInfoFor(
					createExternalTypeInfoFromInternalType(((ArrayType) type).getElementType()));
		} else if (type instanceof MapType) {
			MapType mapType = (MapType) type;
			return new MapTypeInfo(
					createExternalTypeInfoFromInternalType(mapType.getKeyType()),
					createExternalTypeInfoFromInternalType(mapType.getValueType()));
		} else if (type instanceof MultisetType) {
			MultisetType multisetType = (MultisetType) type;
			return MultisetTypeInfo.getInfoFor(
				createExternalTypeInfoFromInternalType(multisetType.getElementType()));
		}
		else if (type instanceof DecimalType) {
			DecimalType decimalType = (DecimalType) type;
			return new BigDecimalTypeInfo(decimalType.precision(), decimalType.scale());
		}  else if (type instanceof GenericType) {
			GenericType genericType = (GenericType) type;
			return genericType.getTypeInfo();
		} else {
			throw new UnsupportedOperationException("Not support yet: " + type);
		}
	}
410874
@Nullable
  private Type getPrimitiveOrVoidType(String typeStr) {
    switch (typeStr) {
      case "byte":
        return getSymtab().byteType;
      case "short":
        return getSymtab().shortType;
      case "int":
        return getSymtab().intType;
      case "long":
        return getSymtab().longType;
      case "float":
        return getSymtab().floatType;
      case "double":
        return getSymtab().doubleType;
      case "boolean":
        return getSymtab().booleanType;
      case "char":
        return getSymtab().charType;
      case "void":
        return getSymtab().voidType;
      default:
        return null;
    }
  }
1128302
function getUiFormat(oType) {
		var oFormatOptions;

		if (!oType.oUiFormat) {
			oFormatOptions = jQuery.extend({strictParsing : true}, oType.oFormatOptions);
			oFormatOptions.UTC = true; // value is always UTC; no overwrite via format options
			oType.oUiFormat = DateFormat.getTimeInstance(oFormatOptions);
		}
		return oType.oUiFormat;
	}
1114011
function getModelFormatter() {
		if (!oModelFormatter) {
			oModelFormatter = DateFormat.getDateInstance({
				pattern : 'yyyy-MM-dd',
				strictParsing : true,
				UTC : true
			});
		}
		return oModelFormatter;
	}
761648
public static <O> Function<Object, O> getParseFunction(Class<O> type) {
        return new StructBehavior<Function<Object, O>>(type) {

            @SuppressWarnings("unchecked")
            @Override protected Function<Object, O> booleanIf() {
                return (Function<Object, O>) TO_BOOLEAN; 
            }

            @SuppressWarnings("unchecked")
            @Override protected Function<Object, O> byteIf() {
                return (Function<Object, O>) TO_BYTE;
            }

            @SuppressWarnings("unchecked")
            @Override protected Function<Object, O> characterIf() {
                return (Function<Object, O>) TO_CHARACTER;
            }

            @SuppressWarnings("unchecked")
            @Override protected Function<Object, O> doubleIf() {
                return (Function<Object, O>) TO_DOUBLE;
            }

            @SuppressWarnings("unchecked")
            @Override protected Function<Object, O> floatIf() {
                return (Function<Object, O>) TO_FLOAT;
            }

            @SuppressWarnings("unchecked")
            @Override protected Function<Object, O> integerIf() {
                return (Function<Object, O>) TO_INTEGER;
            }

            @SuppressWarnings("unchecked")
            @Override protected Function<Object, O> longIf() {
                return (Function<Object, O>) TO_LONG;
            }

            @SuppressWarnings("unchecked")
            @Override protected Function<Object, O> shortIf() {
                return (Function<Object, O>) TO_SHORT;
            }

            @Override protected Function<Object, O> nullIf() {
                return null;
            }

            @Override protected Function<Object, O> noneMatched() {
                return new ValueBehaviorAdapter<Function<Object, O>>(delegate) {
                    
                    @SuppressWarnings("unchecked")
                    @Override protected Function<Object, O> dateIf(Date resolvedP) {
                        return (Function<Object, O>) TO_DATE;
                    }

                    @SuppressWarnings("unchecked")
                    @Override protected Function<Object, O> bigDecimalIf(BigDecimal resolvedP) {
                        return (Function<Object, O>) TO_BIGDECIMAL;
                    }

                    @SuppressWarnings("unchecked")
                    @Override protected Function<Object, O> bigIntegerIf(BigInteger resolvedP) {
                        return (Function<Object, O>) TO_BIGINTEGER;
                    }

                    @Override protected Function<Object, O> defaultBehavior() {
                        return null;
                    }
                }.doDetect();
            }
        }.doDetect();
    }
263885
def _jsTypeof(o):
    ''''''
    if o == None:
        return 'object'
    elif o == Undefined:
        return 'undefined'
    elif isinstance(o, bool):
        return 'boolean'
    if isinstance(o, int) or isinstance(o, float):
        return 'number'
    elif isinstance(o, list) or isinstance(o, dict):
        return 'object'
    elif isinstance(o, stringtype):
        return 'string'
    raise ValueError('Unknown type for object %s (%s)' % (o, type(o)))
1056522
String getFormattedArray(Object attribute, String indent) {
        int arrayLength = Array.getLength(attribute);
        if (arrayLength == 0) {
            return "[]";
        }

        Class<?> componentType = attribute.getClass().getComponentType();

        // For the 8 primitive types, a cast is necessary when invoking
        // Arrays.toString.  The array data is then broken into separate
        // lines
        if (componentType.equals(boolean.class)) {
            return formatPrimitiveArrayString(Arrays.toString((boolean[]) attribute), indent);
        } else if (componentType.equals(byte.class)) {
            return formatPrimitiveArrayString(Arrays.toString((byte[]) attribute), indent);
        } else if (componentType.equals(char.class)) {
            return formatPrimitiveArrayString(Arrays.toString((char[]) attribute), indent);
        } else if (componentType.equals(double.class)) {
            return formatPrimitiveArrayString(Arrays.toString((double[]) attribute), indent);
        } else if (componentType.equals(float.class)) {
            return formatPrimitiveArrayString(Arrays.toString((float[]) attribute), indent);
        } else if (componentType.equals(int.class)) {
            return formatPrimitiveArrayString(Arrays.toString((int[]) attribute), indent);
        } else if (componentType.equals(long.class)) {
            return formatPrimitiveArrayString(Arrays.toString((long[]) attribute), indent);
        } else if (componentType.equals(short.class)) {
            return formatPrimitiveArrayString(Arrays.toString((short[]) attribute), indent);
        }

        // Arbitrary strings can have ', ' in them so we iterate here
        StringBuilder sb = new StringBuilder();
        indent += INDENT;

        Object[] array = (Object[]) attribute;
        for (int i = 0; i < array.length; i++) {
            sb.append("\n").append(indent).append("[").append(i).append("]: ");
            sb.append(String.valueOf(array[i]));
        }
        return sb.toString();
    }
814674
function makePlusMinus(formatter) {
  return function plusMinusWrapped(value) {
    if (value != null && value > 0) {
      return '+' + formatter(value);
    }

    return formatter(value);
  };
}
492896
function(_data,_type){
        try{
            _type = _type.toLowerCase();
            if (_data===null) return _type=='null';
            if (_data===undefined) return _type=='undefined';
            return _o.toString.call(_data).toLowerCase()=='[object '+_type+']';
        }catch(e){
            return !1;
        }
    }