Check whether node has a child node with given valid policy OID.

@param string $oid
@return boolean
167614
public function hasChildWithValidPolicy(string $oid): bool
    {
        foreach ($this->_children as $node) {
            if ($node->validPolicy() == $oid) {
                return true;
            }
        }
        return false;
    }
354083
public function has($iElementID)
    {
        if (empty($iElementID) || $this->isEmpty()) {
            return false;
        }

        return in_array($iElementID, (array) $this->arElementIDList);
    }
1257155
public function isParentOf($itemId, $parentId)
    {
        $path = $this->getMelisKeyData($itemId);
        $paths = explode('/', $path);

        if (count($paths) > 0) {
            if (in_array($parentId, $paths)) {
                return true;
            }
        }

        return false;
    }
763291
protected function validateEzObject($objectId)
    {
        try {
            $this->contentHandler->loadContentInfo($objectId);
        } catch (NotFoundException $e) {
            return false;
        }

        return true;
    }
1259568
public function has($id)
    {
        /** @var ContainerInterface $item */
        foreach ($this->list as $item) {
            if ($item->has($id)) {
                return true;
            }
        }

        return false;
    }
947199
public function has($id) {
		foreach($this->values as $container) {
			if($container->has($id)) {
				return true;
			}
		}
		return false;
	}
169487
public function children($id = null)
    {
        $id = ($id == null) ? $this->root : $id;
        foreach ($this->data as $v) {
            if ($v[$this->fields[1]] == $id) {
                $result[$v[$this->fields[0]]] = $v;
            }
        }
        return isset($result) ? $result : null;
    }
752113
public function has($id)
    {
        if (!is_string($id)) {
            throw new ContainerException('$id must be a string');
        }

        if (array_key_exists($id, $this->definitions)) {
            return true;
        }

        return false;
    }
1276759
public function has($key)
    {
        if (mb_strpos($key, $this->delimiter) !== false) {
            return (!is_null($this->getChild($key)));
        }
        return parent::has($key);
    }
872085
public boolean hasNodeWithId(int nodeId) {
        Node node = nodesById.get(nodeId);
        if(node == null) {
            return false;
        }
        return true;
    }
1113163
public function removeNode($nodeId)
    {
        if (isset($this->nodeSet[$nodeId]))
            unset($this->nodeSet[$nodeId]);
        return true;
    }
1069513
public function hasTagById( $id )
	{
		$xpath	= new DomXPath( $this->document );
		$query	= "//*[@id = '$id']";
		$nodes	= $xpath->query( $query );
		return (bool) $nodes->length;
	}
1283338
protected function getChildren($oid) {
    $permissionManager = $this->getPermissionManager();
    $persistenceFacade = $this->getPersistenceFacade();

    // check read permission on type
    $type = $oid->getType();
    if (!$permissionManager->authorize($type, '', PersistenceAction::READ)) {
      return [];
    }

    $objectsTmp = [];
    if ($this->isRootTypeNode($oid)) {
      // load instances of type
      $objectsTmp = $persistenceFacade->loadObjects($type, BuildDepth::SINGLE);
    }
    else {
      // load children of node
      if ($permissionManager->authorize($oid, '', PersistenceAction::READ)) {
        $node = $persistenceFacade->load($oid, 1);
        if ($node) {
          $objectsTmp = $node->getChildren();
        }
      }
    }

    // check read permission on instances
    $objects = [];
    foreach ($objectsTmp as $object) {
      if ($permissionManager->authorize($object->getOID(), '', PersistenceAction::READ)) {
        $objects[] = $object;
      }
    }

    return $objects;
  }
321872
public function has($id)
    {
        try {
            $existing = $this->get($id);
        } catch (\OutOfBoundsException $e) {
            return false;
        }
        return Util::typeOf($existing);
    }
1358537
public function has($id)
    {
        $res = isset($this->_classes[$id]);

        if ($res == false && isset($this->_lazy_classes[$id])) {
            if (is_callable($this->_lazy_classes[$id])) {
                $this->_classes[$id] = $this->_lazy_classes[$id]($this);
            } else {
                $this->_classes[$id] = $this->_lazy_classes[$id];
            }

            $res = true;
        }

        if ($res == false && $this->isSystemClass($id)) {
            $res = $this->_loadSystemClass($id);
        }

        return $res;
    }
132021
public function contain(string $id): bool
    {
        if ($this->properties()->containSection($id)) {
            return true;
        }

        return $this->hasFallback();
    }
844203
public function findParentNodesByChildId($id)
	{
        // To be returned
        $result = array();

        $rl = $this->getRelations();
        $data = $rl[RelationBuilder::TREE_PARAM_ITEMS];

        // If can't find, then return empty array
        if (!isset($data[$id])) {
            return array();
        }

        $current = $data[$id];
        $parentId = $current[RelationBuilder::TREE_PARAM_PARENT_ID];

        while (isset($data[$parentId])) {
            $current = $data[$parentId];
            $parentId = $current[RelationBuilder::TREE_PARAM_PARENT_ID];

            array_push($result, $current);
        }

        return $result;
    }