Get format info from the array type
182013
function fromTypedArray (array) {
	if (array instanceof Int8Array) {
		return {
			float: false,
			signed: true,
			bitDepth: 8
		}
	}
	if ((array instanceof Uint8Array) || (array instanceof Uint8ClampedArray)) {
		return {
			float: false,
			signed: false,
			bitDepth: 8
		}
	}
	if (array instanceof Int16Array) {
		return {
			float: false,
			signed: true,
			bitDepth: 16
		}
	}
	if (array instanceof Uint16Array) {
		return {
			float: false,
			signed: false,
			bitDepth: 16
		}
	}
	if (array instanceof Int32Array) {
		return {
			float: false,
			signed: true,
			bitDepth: 32
		}
	}
	if (array instanceof Uint32Array) {
		return {
			float: false,
			signed: false,
			bitDepth: 32
		}
	}
	if (array instanceof Float32Array) {
		return {
			float: true,
			signed: false,
			bitDepth: 32
		}
	}
	if (array instanceof Float64Array) {
		return {
			float: true,
			signed: false,
			bitDepth: 64
		}
	}

	//other dataview types are Uint8Arrays
	return {
		float: false,
		signed: false,
		bitDepth: 8
	}
}
780223
function parse_Array(blob, length, opts) {
	var ref = parse_Ref(blob, 6);
	/* TODO: fAlwaysCalc */
	switch(opts.biff) {
		case 2: blob.l ++; length -= 7; break;
		case 3: case 4: blob.l += 2; length -= 8; break;
		default: blob.l += 6; length -= 12;
	}
	return [ref, parse_ArrayParsedFormula(blob, length, opts, ref)];
}
289181
def _format_object(obj, format_type=None):
    """"""

    if json_api_settings.FORMAT_KEYS is not None:
        return format_keys(obj, format_type)

    return format_field_names(obj, format_type)
1258280
function getParseType (file) {
  let ext = path.extname(file)

  for (let type in FILE_TYPE_MAP) {
    let exts = FILE_TYPE_MAP[type]

    if (exts.indexOf(ext) >= 0) {
      return type
    }
  }
}
417272
def get_formatted_output(self, format_type=FormatType.JSON):
        
        if format_type not in [FormatType.JSON, FormatType.YAML]:
            raise ArgumentInvalid('"format_type" should be one of FormatType.JSON / YAML!')
        elif format_type is FormatType.JSON:
            return self._format_json()
        elif format_type is FormatType.YAML:
            return self._format_yaml()
1226077
public static String toFormattedString(LongArrayND array, String format)
    {
        if (array == null)
        {
            return "null";
        }
        StringBuilder sb = new StringBuilder();
        Iterable<MutableIntTuple> iterable = 
            IntTupleIterables.lexicographicalIterable(array.getSize());
        IntTuple previous = null;
        for (IntTuple coordinates : iterable)
        {
            if (previous != null)
            {
                int c = Utils.countDifferences(previous, coordinates);
                for (int i=0; i<c-1; i++)
                {
                    sb.append("\n");
                }
            }
            long value = array.get(coordinates);
            sb.append(String.format(format+", ", value));
            previous = coordinates;
        }
        return sb.toString();
    }
192630
def get_type(bind):
    
    types = bind.types + [bind.schema.get('format')]
    for type_name in ('date-time', 'date', 'decimal', 'integer', 'boolean',
                      'number', 'string'):
        if type_name in types:
            return type_name
    return 'string'
926202
function getFormatter(oType) {
		var oFormatOptions;

		if (!oType.oFormat) {
			oFormatOptions = jQuery.extend({strictParsing : true}, oType.oFormatOptions);
			oFormatOptions.UTC = true;
			oType.oFormat = DateFormat.getTimeInstance(oFormatOptions);
		}
		return oType.oFormat;
	}
687391
function getType(value) {
  if (Array.isArray(value)) {
    return 'array';
  } else if (value === null) {
    return 'null';
  }
  return typeof value === 'undefined' ? 'undefined' : _typeof(value);
}
662592
def get_format(n):
    """"""
    formats = []

    if is_visa(n):
        formats.append('visa')
    if is_visa_electron(n):
        formats.append('visa electron')
    if is_mastercard(n):
        formats.append('mastercard')
    if is_amex(n):
        formats.append('amex')
    if is_maestro(n):
        formats.append('maestro')
    if is_discover(n):
        formats.append('discover')

    return formats
1047251
function format(input, level, options) {
  if (util.isArray(input)) {
    return array(input, level, options);
  } else if (util.isObject(input)) {
    return object(input, level, options);
  } else {
    return stringify(input, options);
  }
}
541629
function getFormatExtension()
    {
        $environment = $this->environment;

        $formatExtension = current(array_filter(
            $this->getExtensions(),
            function($ext) use ($environment) {
                return
                    isset($environment->contentTypes[$ext])
                    and !$environment->engines->get($ext);
            }
        ));

        return $formatExtension
            ?: array_search($this->getEngineContentType(), $environment->contentTypes)
            ?: join('', $this->getExtensions());
    }
618581
final public static function get_formatted_properties() {
        $properties = static::properties_definition();

        $formatted = array();
        foreach ($properties as $property => $definition) {
            $propertyformat = $property . 'format';
            if (($definition['type'] == PARAM_RAW || $definition['type'] == PARAM_CLEANHTML)
                    && array_key_exists($propertyformat, $properties)
                    && $properties[$propertyformat]['type'] == PARAM_INT) {
                $formatted[$property] = $propertyformat;
            }
        }

        return $formatted;
    }
666110
function getTypes()
    {
        $t = array();
        foreach ($this->getElements('xrd:Type') as $elem) {
            $c = $this->parser->content($elem);
            if ($c) {
                $t[] = $c;
            }
        }
        return $t;
    }
1095393
function getFormatFunction(name) {
  // lookup format
  const fmt = formats[name] || name || formats.default;
  // return compiled format
  return typeof fmt !== 'function' ? compile(fmt) : fmt;
}
955804
def extract_format(format, extra_types):
    '''
    '''
    fill = align = None
    if format[0] in '<>=^':
        align = format[0]
        format = format[1:]
    elif len(format) > 1 and format[1] in '<>=^':
        fill = format[0]
        align = format[1]
        format = format[2:]

    zero = False
    if format and format[0] == '0':
        zero = True
        format = format[1:]

    width = ''
    while format:
        if not format[0].isdigit():
            break
        width += format[0]
        format = format[1:]

    if format.startswith('.'):
        # Precision isn't needed but we need to capture it so that
        # the ValueError isn't raised.
        format = format[1:]  # drop the '.'
        precision = ''
        while format:
            if not format[0].isdigit():
                break
            precision += format[0]
            format = format[1:]

    # the rest is the type, if present
    type = format
    if type and type not in ALLOWED_TYPES and type not in extra_types:
        raise ValueError('format spec %r not recognised' % type)

    return locals()
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();
    }