valueClass, isList
16115
private void determineFieldType(Field field) {
        // Determine the class of data stored in the field
        Class<?> fieldType = field.getType();

        isCollection = Collection.class.isAssignableFrom(fieldType);

        valueClass=null;
        if (!isCollection) {
            // It's not a list so assume its single valued - so just take the field type
            valueClass = fieldType;
        } else {
            determineCollectionClass(fieldType);
            // It's multi-valued - so we need to look at the signature in
            // the class file to find the generic type - this is supported for class file
            // format 49 and greater which corresponds to java 5 and later.
            ParameterizedType paramType;
            try {
                paramType = (ParameterizedType)field.getGenericType();
            } catch (ClassCastException e) {
                throw new MetaDataException(String.format("Can't determine destination type for field %1$s in Entry class %2$s", 
                        field, field.getDeclaringClass()), e);
            }
            Type[] actualParamArguments = paramType.getActualTypeArguments();
            if (actualParamArguments.length == 1) {
                if (actualParamArguments[0] instanceof Class) {
                    valueClass = (Class<?>)actualParamArguments[0];                    
                } else {
                    if (actualParamArguments[0] instanceof GenericArrayType) {
                        // Deal with arrays
                        Type type=((GenericArrayType)actualParamArguments[0]).getGenericComponentType();
                        if (type instanceof Class) {
                            valueClass=Array.newInstance((Class<?>)type, 0).getClass();
                        } 
                    } 
                }
            } 
        }

        // Check we have been able to determine the value class
        if (valueClass==null) {
            throw new MetaDataException(String.format("Can't determine destination type for field %1$s in class %2$s", 
                    field, field.getDeclaringClass()));
        }
    }
332520
public static boolean contains (int[] list, int value)
    {
        int llength = list.length; // no optimizing bastards
        for (int i = 0; i < llength; i++) {
            if (list[i] == value) {
                return true;
            }
        }
        return false;
    }
1245679
private int getIndexOfClass(List list, Class cls) {
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).getClass().equals(cls)) {
                return i;
            }
        }
        return -1;
    }
994438
def p_list_type(self, p):
        ''''''
        p[0] = ast.ListType(value_type=p[3], annotations=p[5])
790991
private boolean walkInvalidList(String className, String name, String[][] list) {
        boolean isInvalidCombination = false;

        for (int i = 0; i != list.length; i++) {
            if (className.equalsIgnoreCase(list[i][0])) {
                if (name.equalsIgnoreCase(list[i][1])) {
                    isInvalidCombination = true;
                    break;
                }
            }
        }
        return isInvalidCombination;
    }
746902
function isValue(val) {
    return (!isUndefined(val)
        && !isNull(val) && !(isNumber(val) && isNaN(val))
        && !isInfinite(val));
}
975144
def is_list(node):
    """"""
    return (isinstance(node, Node)
            and len(node.children) > 1
            and isinstance(node.children[0], Leaf)
            and isinstance(node.children[-1], Leaf)
            and node.children[0].value == u"["
            and node.children[-1].value == u"]")
1035963
def wrap(cls, value):
        ''' 

        '''
        if isinstance(value, list):
            if isinstance(value, PropertyValueList):
                return value
            else:
                return PropertyValueList(value)
        else:
            return value
1059865
@Override
    public boolean containsValue(Object value) {
	// Overridden to take advantage of faster iterator
	if (value == null) {
	    for (Entry e = header.after; e != header; e = e.after)
		if (e.value == null) return true;
	}
	else {
	    for (Entry e = header.after; e != header; e = e.after)
		if (value.equals(e.value)) return true;
	}
	return false;
    }
1148908
static boolean isNode(Object v) {
        // Note: A value is a subject if all of these hold true:
        // 1. It is an Object.
        // 2. It is not a @value, @set, or @list.
        // 3. It has more than 1 key OR any existing key is not @id.
        if (v instanceof Map && !(((Map) v).containsKey("@value") || ((Map) v).containsKey("@set")
                || ((Map) v).containsKey("@list"))) {
            return ((Map<String, Object>) v).size() > 1 || !((Map) v).containsKey("@id");
        }
        return false;
    }
648818
function isList(opts: Options, node: Node): boolean {
    return opts.types.includes(node.type);
}
551084
@Override
	public <T> T asObject(String string, Class<T> valueType) {
		// at this point value type is a boolean or a boxing boolean
		string = string.toLowerCase();
		if (string.equals("true")) {
			return (T) (Boolean) true;
		}
		if (string.equals("yes")) {
			return (T) (Boolean) true;
		}
		if (string.equals("1")) {
			return (T) (Boolean) true;
		}
		if (string.equals("on")) {
			return (T) (Boolean) true;
		}
		return (T) (Boolean) false;
	}
463916
def from_value(cls, value: str) -> T:
        
        return [x for x in cls.__members__.values() if x.value[0] == value][0]
286815
def _is_simple_type(value):
    '''
    
    '''
    return isinstance(value, six.string_types) or isinstance(value, int) or isinstance(value, float) or isinstance(value, bool)
764185
@SuppressWarnings("unchecked")
	@Override
	public T in(final String col, final Iterable<?> valueList) {
		context().param(CaseFormat.CAMEL_CASE.convert(col), new In(col, valueList));
		this.useOperator = true;
		return (T) this;
	}
865880
function isInList(value, listOfValues, msg) {
    value = value.toLowerCase().trim();
    if (listOfValues.indexOf(value) === -1) {
        throw new Error(msg);
    }
}
118415
static Boolean isList(Object v) {
        return (v instanceof Map && ((Map<String, Object>) v).containsKey("@list"));
    }