Determines if a value is contained in the tree
@param {*} value the value to find

@return {Boolean} true if the tree contains the item false otherwise.
962238
function (value) {
            var ret = false;
            var root = this.__root;
            while (root != null) {
                var cmp = this.compare(value, root.data);
                if (cmp) {
                    root = root[(cmp === -1) ? "left" : "right"];
                } else {
                    ret = true;
                    root = null;
                }
            }
            return ret;
        }
751748
function contains( arr, value ) {
	var len, i;
	if ( !isArray( arr ) ) {
		throw new TypeError( 'contains()::invalid input argument. First argument must be an array. Value: `' + arr + '`.' );
	}
	len = arr.length;
	if ( isnan( value ) ) {
		for ( i = 0; i < len; i++ ) {
			if ( isnan( arr[ i ] ) ) {
				return true;
			}
		}
		return false;
	}
	for ( i = 0; i < len; i++ ) {
		if ( arr[ i ] === value ) {
			return true;
		}
	}
	return false;
}
920655
def _contains_value(self, value):
        """"""
        g = operator.gt if self._lower is self.OPEN else operator.ge
        l = operator.lt if self._upper is self.OPEN else operator.le
        return g(value, self.lower_value) and l(value, self._upper_value)
299039
function isValueInList(list, value) {
    for (var i = list.length - 1; i >= 0; i--) {
        if (list[i] == value) {
            return true;
        }
    }
    return false;
}
642011
@Override
    public boolean contains(Object value) {
        if (value == null) {
            return false;
        }
        final Iterator it = new StepIterator(this, stepSize);
        while (it.hasNext()) {
            if (compareEqual(value, it.next())) {
                return true;
            }
        }
        return false;
    }
689962
function contains(query, node, info) {
  if (!has(node, info.property)) {
    return false
  }

  return (
    normalizeValue(node.properties[info.property], info).indexOf(
      query.value
    ) !== -1
  )
}
693884
public boolean containsValue(final Object value) {
	return ! forEachPair( 
		new IntObjectProcedure() {
			public boolean apply(int iterKey, Object iterValue) {
				return (value != iterValue);
			}
		}
	);
}
127215
public boolean containsSimpleValue(V value) {
        for (List<V> vals : values()) {
            if ((vals.size() == 1) && vals.contains(value)) {
                return true;
            }
        }
        return false;
    }
1069146
function contains(array, item) {
  if (array && array.length && item) {
    return array.indexOf(item) !== -1;
  }
  return false;
}
1073933
def contains(self, value):
        
        str_value = StringConverter.to_nullable_string(value)

        for element in self:
            str_element = StringConverter.to_string(element)

            if str_value == None and str_element == None:
                return True
            if str_value == None or str_element == None:
                continue
            
            if str_value == str_element:
                return True

        return False
467482
public static boolean contains(Iterable<?> iterable, Object value)
    {
        if (iterable instanceof Collection)
        {
            return ((Collection<?>) iterable).contains(value);
        }
        if (iterable instanceof RichIterable)
        {
            return ((RichIterable<?>) iterable).contains(value);
        }
        return IterableIterate.detectIndex(iterable, Predicates.equal(value)) > -1;
    }
1246506
public function contains( $value )
    {
        if ( $value instanceof Closure )
        {
            return !is_null( $this->first( $value ) );
        }

        return in_array( $value, $this->items );
    }
604108
function isPlainObject(value) {
  return (
    isObject(value) &&
    (!value.constructor || value.constructor === Object) &&
    (!value.toString || value.toString === Object.prototype.toString)
  );
}
454073
public boolean containsValue(Object value) {
        if (value == null) {
            value = new Null();
        }

        Entry tab[] = mTable;
        
        for (int i = tab.length ; i-- > 0 ;) {
            for (Entry e = tab[i], prev = null; e != null; e = e.mNext) {
                Object entryValue = e.getValue();

                if (entryValue == null) {
                    // Clean up after a cleared Reference.
                    mModCount++;
                    if (prev != null) {
                        prev.mNext = e.mNext;
                    }
                    else {
                        tab[i] = e.mNext;
                    }
                    mCount--;
                }
                else if (value.equals(entryValue)) {
                    return true;
                }
                else {
                    prev = e;
                }
            }
        }

        return false;
    }
872574
function isEmpty( value ) {
  return isUndefined( value ) ||
         value === null ||
         isString( value ) &&
         value.length <= 0 ||
         ( /^\s*$/ ).test( value );
}
559788
function containsDeep(parent, child) {
        var node = child;
        while (node) {
            if (node == parent) return true;

            node = getParentNode(node);
        }
        return false;
    }
233626
function contains( element ) {
    for( var i = 0, len = lists.length; i < len; i++ ) {
      if( lists[i].element == element ) {
        return true;
      }
    }
    return false;
  }