Tell if the table contains the given node.

@param s Node to look for

@return True if the given node was found.
346209
public boolean contains(Node s)
  {
    runTo(-1);

    if (null == m_map)
      return false;

    for (int i = 0; i < m_firstFree; i++)
    {
      Node node = m_map[i];

      if ((null != node) && node.equals(s))
        return true;
    }

    return false;
  }
67181
public static boolean tableContainsString(VoltTable t, String s, boolean caseSenstive) {
        if (t.getRowCount() == 0) {
            return false;
        }
        if (!caseSenstive) {
            s = s.toLowerCase();
        }

        VoltTableRow row = t.fetchRow(0);
        do {
            for (int i = 0; i < t.getColumnCount(); i++) {
                if (t.getColumnType(i) == VoltType.STRING) {
                    String value = row.getString(i);
                    if (value == null) {
                        continue;
                    }
                    if (!caseSenstive) {
                        value = value.toLowerCase();
                    }
                    if (value.contains(s)) {
                        return true;
                    }
                }
            }

        } while (row.advanceRow());

        return false;
    }
5243
public boolean intersects(final Span s) {
    final int sstart = s.getStart();
    // either s's start is in this or this' start is in s
    return this.contains(s) || s.contains(this)
        || getStart() <= sstart && sstart < getEnd()
        || sstart <= getStart() && getStart() < s.getEnd();
  }
200701
private boolean selectNode(SNode n)
  {
    String annoKey = null;

    if (mappings.containsKey(MAPPING_NODE_KEY))
    {
      annoKey = mappings.getProperty(MAPPING_NODE_KEY);
    }

    /**
     * Default behaviour, when mapping is not set correctly or is not set at
     * all.
     */
    if (annoKey == null)
    {
      if (n instanceof SToken)
      {
        return true;
      }
      else
      {
        return false;
      }
    }


    // if mapping is set, we check, if the node carries the mapped annotation key
    Set<SAnnotation> annos = n.getAnnotations();
    for (SAnnotation a : annos)
    {
      if (annoKey.equals(a.getName()))
      {
        return true;
      }
    }

    return false;
  }
607791
boolean contains(Linked<?> e) {
        return (e.getPrevious() != null)
                || (e.getNext() != null)
                || (e == first);
    }
880404
@Override
    public boolean contains(CharSequence s) {
        if (s instanceof FastStr) {
            return indexOf((FastStr) s) > -1;
        }
        return indexOf(s.toString()) > -1;
    }
656249
@Override
    public boolean contains(ChronoElement<?> element) {

        if ((element != null) && (this.map != null)) {
            return this.map.containsKey(element);
        }

        return false;

    }
1235685
private static boolean containsGreekLetter(String s) {
    Matcher m = biogreek.matcher(s);
    return m.find();
  }
1251891
private boolean containsBoth(N a, N b)
    {
        return nodes.containsKey(a) && nodes.containsKey(b);
    }
98019
public boolean containsColumn(final String tableName, final String column) {
        return containsTable(tableName) && tables.get(tableName).getColumns().keySet().contains(column.toLowerCase());
    }
502141
boolean contains(Object entity)
    {
        Node node = getPersistenceCache().getMainCache().getNodeFromCache(entity, getMetadata(entity.getClass()), this);
        return node != null && node.isInState(ManagedState.class);
    }
1194663
public boolean contains(final String n, final boolean fwd) {
	synchronized (this) {
	    return find_i(n, fwd) != null ? true : false;
	}
    }
989869
public boolean containsKey(Object key) {
	if (key == null) {
	    throw new NullPointerException("key cannot be null");
	}
	else if (key instanceof String) {
	    Node<V> n = lookup((String)key);
	    return n != null && n.isTerminal();
	}
	else {
	    throw new ClassCastException("The provided key does not implement" +
					 " String: " + key);
	}
    }
1153579
boolean contains(WriteOrder<?> e) {
    return (e.getPreviousInWriteOrder() != null)
        || (e.getNextInWriteOrder() != null)
        || (e == first);
  }
237081
@SuppressWarnings("unchecked")
  public boolean contains(final Object key) {
    // validate key
    if (key == null) {
      throw new IllegalArgumentException("Null element is not supported.");
    }
    // find element
    final int hashCode = ((T)key).hashCode();
    final int index = getIndex(hashCode);
    return containsElem(index, (T) key, hashCode);
  }
648144
public static boolean isSelfCall(JCTree tree) {
        Name name = calledMethodName(tree);
        if (name != null) {
            Names names = name.table.names;
            return name==names._this || name==names._super;
        } else {
            return false;
        }
    }
166944
def bsp_contains(node: tcod.bsp.BSP, cx: int, cy: int) -> bool:
    
    return node.contains(cx, cy)