If this Type supports array lookup, then return all of the methods
that can be called to access the array. If there are no methods, then
an empty array is returned. Null is returned only if this Type
doesn't support array lookup.
491003
public Method[] getArrayAccessMethods() throws IntrospectionException {
        if (!mCheckedForArrayLookup) {
            checkForArrayLookup();
        }

        return mArrayAccessMethods == null ? null :
            (Method[])mArrayAccessMethods.clone();
    }
974536
private void getMethods(ArrayList<JMethod> methodList)
  {
    for (JMethod method : getDeclaredMethods()) {
      if (! methodList.contains(method))
        methodList.add(method);
    }

    if (getSuperClass() != null) {
      for (JMethod method : getSuperClass().getMethods()) {
        if (! methodList.contains(method))
          methodList.add(method);
      }
    }
  }
1244391
private static int[] getFingerprints(Method[] methods) {
    if (methods == null) {
      return null;
    }
    int[] hashCodes = new int[methods.length];
    for (int i = 0; i<methods.length; i++) {
      hashCodes[i] = getFingerprint(methods[i]);
    }
    return hashCodes;
  }
204188
function findType (node, typeInfo, nestedCall) {
  typeInfo = typeInfo || { noNull: false, isArray: false, noNullArrayValues: false }
  if (!node) {
    return typeInfo
  }

  // Validate nested call, the parser will check first if the array can be null
  // then it will check if the values inside can be null
  if (!nestedCall && node.kind === 'NonNullType') {
    typeInfo.noNull = true
  }

  // If it is an array, validate if the values inside can be null
  if (nestedCall && typeInfo.isArray && node.kind === 'NonNullType') {
    typeInfo.noNullArrayValues = true
  }

  if (node.kind === 'ListType') {
    typeInfo.isArray = true
  }

  if (node.name) {
    typeInfo.type = node.name.value
  }

  return findType(node.type, typeInfo, true)
}
1317311
@Override
	public boolean isEmpty() {
		for(List<? extends Method<? extends E>> methods : methodsByClass.values()) {
			for(Method<? extends E> method : methods) {
				E singleton = method.getSingleton(target);
				if(singleton!=null) return false;
				Set<? extends E> set = method.getSet(target);
				if(set!=null && !set.isEmpty()) return false;
			}
		}
		return true;
	}
1226471
@Override
    public Array getArray(int index) {
        synchronized (lock) {
            final Object obj = getMValue(internalArray, index).asNative(internalArray);
            return obj instanceof Array ? (Array) obj : null;
        }
    }
1085503
public String[] getTypeArr() {
		List<String> list = new ArrayList<>();
		From index = null;
		for (int i = 0; i < from.size(); i++) {
			index = from.get(i);
			if (index.getType() != null && index.getType().trim().length() > 0) {
				list.add(index.getType());
			}
		}
		if (list.size() == 0) {
			return null;
		}

		return list.toArray(new String[list.size()]);
	}
442028
@SuppressWarnings("unchecked")
	@Override
	public <T> T[] toArray(T[] array) {
		return (T[])(booleanTerms == null ? new BooleanTerm[0] : booleanTerms.toArray(new BooleanTerm[booleanTerms.size()]));
	}
438325
public static Class<?> getComponentType(Object array) {
		return null == array ? null : array.getClass().getComponentType();
	}
1218990
public JavaMethod getMethod(String name)
  {
    ArrayList<JavaMethod> methodList = getMethodList();
    
    for (int i = 0; i < methodList.size(); i++) {
      JavaMethod method = methodList.get(i);

      if (method.getName().equals(name))
        return method;
    }

    return null;
  }
1100760
function findAdapter(adapters, mediaType, method) {
  for (let i = 0; i < adapters.length; i += 1) {
    if (adapters[i].mediaTypes.indexOf(mediaType) !== -1 && adapters[i][method]) {
      return adapters[i];
    }
  }

  return null;
}
306547
private static Method lookup( String method, String url ) {
    String s = method+url;
    for( String x : _handlers.keySet() )
      if( x.equals(s) )         // TODO: regex
        return _handlers.get(x);
    return null;
  }
945687
private static Class<? extends StackTraceElement> findClassCaller()
    {
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();

        for( int i = 2; i < stackTrace.length; i++ )
        {
            StackTraceElement call = stackTrace[i];
            if (!Log.class.isAssignableFrom(call.getClass()))
                return call.getClass();
        }

        return null;
    }
252508
public static Method getMethod(Class<?> cls, String methodName, Class<?>... types) {
        try {
            return cls.getMethod(methodName, types);
        } catch (Exception e) {
            return null;
        }
    }
697805
public static int arrayDimensions(Class<?> arrType) {
        if ( null == arrType || !arrType.isArray() )
            return 0;
        return arrType.getName().lastIndexOf('[') + 1;
    }
1108026
public static boolean isArray( Class clazz ) {
      return clazz != null
            && (clazz.isArray() || Collection.class.isAssignableFrom( clazz ) || (JSONArray.class.isAssignableFrom( clazz )));
   }
531080
public Object[] readArray() throws IOException
    {
        if (_parser.isExpectedStartArrayToken()) {
            return AnyReader.std.readArrayFromArray(this, _parser, _collectionBuilder);
        }
        if (_parser.hasToken(JsonToken.VALUE_NULL)) {
            return null;
        }
        throw JSONObjectException.from(_parser,
                "Can not read an array: expect to see START_ARRAY ('['), instead got: "+ValueReader._tokenDesc(_parser));
    }