How to use

isMap

method

in

js.util.Types

/**
 * Test if instance is a map. If instance to test is not null delegates {@link #isMap(Type)}; otherwise returns false.
 * 
 * @param o instance to test, possible null.
 * @return true if instance is a map; returns false if instance to test is null.
 */
public static boolean isMap(Object o)
{
 return o != null && Types.isMap(o.getClass());
}

/**
 * Retrieve content map instance. Delegates {@link #getValue(Object, String)} to obtain the requested value. If value is
 * null warn the event an return empty map. If value is map return it, otherwise throws context exception.
 * 
 * @param scope scope object,
 * @param propertyPath object property path.
 * @return map instance, possible empty.
 * @throws TemplateException if requested value is undefined or not a {@link Types#isMap(Object) map}.
 */
Map<?, ?> getMap(Object scope, String propertyPath) throws TemplateException {
  Object map = getValue(scope, propertyPath);
  if (map == null) {
    warn(scope.getClass(), propertyPath);
    return Collections.EMPTY_MAP;
  }
  if (!Types.isMap(map)) {
    throw new TemplateException("Invalid type. Expected map but got |%s|.", map.getClass());
  }
  return (Map<?, ?>) map;
}

 return ((Collection<?>)o).isEmpty();
if(isMap(o)) {
 return ((Map<?, ?>)o).isEmpty();

 return newCollection(rawClass);
if(Types.isMap(rawClass)) {
 return newMap(rawClass);

 return ((Collection<?>)o).size() > 0;
if(isMap(o)) {
 return ((Map<?, ?>)o).size() > 0;

/**
 * Test if method formal parameters designates a strict object, that is, is not primitive, array, collection or map.
 * 
 * @param formalParameters method formal parameters list.
 * @return true if formal parameters designates a strict object.
 */
private static boolean isObject(Type[] formalParameters) {
  if (formalParameters.length != 1) {
    return false;
  }
  final Type type = formalParameters[0];
  if (!(type instanceof Class)) {
    return false;
  }
  if (Types.isPrimitive(type)) {
    return false;
  }
  if (Types.isArrayLike(type)) {
    return false;
  }
  if (Types.isMap(type)) {
    return false;
  }
  if (ConverterRegistry.hasType(type)) {
    return false;
  }
  return true;
}

if (Types.isMap(value)) {
  serializeMap(value);
  return;

  return new PrimitiveValue(converter, (Class<?>) type);
if (Types.isMap(type)) {
  return new MapValue(converter, type);