Define a property that is set to true if the given token is found in
        the log file.  Uses the __contains__ method of the log file.
352262
def token_scan(cls, result_key, token):
        
        def _scan(self):
            return token in self

        cls.scan(result_key, _scan)
1071494
function checkSpacingAfter(token, pattern) {
            checkMethodMap[token.value].after(token, pattern || NEXT_TOKEN);
        }
1160966
function isMissingTerms(file) {
  var contents = file.contents.toString();
  return Object.keys(requiredTerms).map(function(term) {
    var filter = requiredTerms[term];
    if (!filter.test(file.path)) {
      return false;
    }

    var matches = contents.match(new RegExp(term));
    if (!matches) {
      util.log(util.colors.red('Did not find required: "' + term +
          '" in ' + file.relative));
      util.log(util.colors.blue('=========='));
      return true;
    }
    return false;
  }).some(function(hasMissingTerm) {
    return hasMissingTerm;
  });
}
686166
@Override
	public boolean contains(String str) {
		for (BloomFilter filter : filters) {
			if (filter.contains(str) == false) {
				return false;
			}
		}
		return true;
	}
554732
def include_message?(log)
      return true if @filter.nil?

      if @filter.is_a?(Regexp)
        !(@filter =~ log.name).nil?
      elsif @filter.is_a?(Proc)
        @filter.call(log) == true
      end
    end
248525
def contains(ref_value):
    
    def contains_ref_value(x):
        if ref_value in x:
            return True
        else:
            raise DoesNotContainValue(wrong_value=x, ref_value=ref_value)

    contains_ref_value.__name__ = 'contains_{}'.format(ref_value)
    return contains_ref_value
1236390
public static boolean contains(String target, List<String> containWith) {
		if (isNull(target)) {
			return false;
		}
		
		return matcher(target).contains(containWith);
	}
270690
def contains(self, key):
    '''
    '''
    path = self.object_path(key)
    return os.path.exists(path) and os.path.isfile(path)
856528
private boolean fileContains(File file, IGroupMember member) throws GroupsException {
        Collection ids = null;
        try {
            ids = member.isGroup() ? getGroupIdsFromFile(file) : getEntityIdsFromFile(file);
        } catch (Exception ex) {
            throw new GroupsException("Error retrieving ids from file", ex);
        }
        return ids.contains(member.getKey());
    }
1230674
def expr_contains(e, o):
    '''  '''
    if o == e:
        return True
    if e.has_args():
        for a in e.args():
            if expr_contains(a, o):
                return True
    return False
695318
function contains(collection, target) {
	let containsTarget = false;
	collection.some((object) => {
		if (object === target) {
			containsTarget = true;
			return true;
		}
		return false;
	});
	return containsTarget;
}
604262
function contains(container, contained, className) {
        var current = contained;

        while (current && current.ownerDocument && current.nodeType !== 11) {
            if (className) {
                if (current === container) {
                    return false;
                }
                if (current.className.indexOf(className) >= 0) { //current.classList.contains(className) doesn't work in IE9
                    return true;
                }
            } else {
                if (current === container) {
                    return true;
                }
            }
            current = current.parentNode;
        }

        return false;
    }
849057
def check_building(self, token):
        
        if self.street and self.house_number:
            if not self.building:
                self.building = self._clean(token)
            else:
                self.building = self._clean(token + ' ' + self.building)
            return True
        return False
295098
private boolean containsOnlyInfinitivesToTheLeft(AnalyzedTokenReadings[] tokens, int startPos) throws IOException {
    int infinitives = 0;
    for (int i = startPos; i > 0; i--) {
      String token = tokens[i].getToken();
      if (tokens[i].hasPartialPosTag("SUB:")) {
        AnalyzedTokenReadings lookup = tagger.lookup(token.toLowerCase());
        if (lookup != null && lookup.hasPosTagStartingWith("VER:INF")) {
          infinitives++;
        } else {
          return false;
        }
      }
    }
    return infinitives >= 2;
  }
413076
def contains(self, element, key=lambda x: x):
        
        return self.select(key).any(lambda x: x == key(element))
378084
def contains(self, key):
        
        n = binascii.crc32(key.encode()) % RING_SIZE
        for start, end in self.ranges:
            if start <= n < end:
                return True
        return False
1050003
public static boolean containsFile(final File parent, final File search)
	{
		boolean exists = false;
		final String[] children = parent.list();
		if (children == null)
		{
			return false;
		}
		final List<String> fileList = Arrays.asList(children);
		if (fileList.contains(search.getName()))
		{
			exists = true;
		}
		return exists;
	}