Whether the collection contains anything but a RecordContainer object.

@return boolean
491248
public function anythingButRecord()
    {
        foreach (array_keys($this->getDataPlaceHolder()) as $key) {
            $v = $this[$key];
            if ($v instanceof RecordContainer) {
                return false;
            }
        }

        return true;
    }
496854
public function contains( $id )
    {
        $iterator = $this->getIterator();

        $role_id = ($id instanceOf RoleInterface) ? $id->getId() : $id;

        while ($iterator->valid()) {
            if ($iterator->current() == $role_id) {
                return true;
            }
            $iterator->next();
        }

        return false;
    }
55603
public function isNull($name): bool
    {
        if ($this->contains($name) == false) {
            return true;
        }

        $value = $this->record[$name];

        return ($value == null);
    }
1050205
public boolean isContainerOfManagedTypes(JaversType javersType){
        if (! (javersType instanceof ContainerType)) {
            return false;
        }

        return getJaversType(((ContainerType)javersType).getItemType()) instanceof ManagedType;
    }
661087
public function contains(callable $callback)
    {
        foreach (array_keys($this->storage) as $priority) {
            if (false !== ($index = array_search($callback, $this->storage[$priority], true))) {
                return true;
            }
        }
        return false;
    }
648266
public function contains()
    {

        // build new set from passed arguments
        $reflection = new \ReflectionClass( get_called_class() );
        $comparing = $reflection->newInstanceArgs( func_get_args() );

        // we don't have a null but the set we're comparing against has it
        if( !$this->containsNull and $comparing->containsNull ) {
            return false;
        }

        reset( $this->intervals );
        reset( $comparing->intervals );

        list(,$compare) = each($comparing->intervals);
        list(,$current) = each($this->intervals);

        while( $compare and $current) {

            // Intervals are maximal. They're either entirely contained or not at all
            if( $compare[0] !== null and $this->sort( $compare[0], $current[1], self::NULL_IS_HIGH ) > 0 ) {
                list(,$current) = each($this->intervals);
                continue;
            }

            // are intervals contained?
            if(
                // compare lower is >= current lower
                $this->sort( $compare[0], $current[0], self::NULL_IS_LOW ) >= 0 and
                // compare upper is <= current upper
                $this->sort( $compare[1], $current[1], self::NULL_IS_HIGH ) <= 0
            ) {

                list(,$compare) = each($comparing->intervals);

            // interval can't be contained
            } else {

                return false;

            }

        }

        // if we're still got something to comparing something we've not been able to match it up with a interval
        return !$compare;

    }
828178
public function isFieldInRecord()
    {
        //zażądany join
        if (strpos($this->getName(), '.')) {
            return true;
        }
        //sorawdzenie w rekordzie
        return property_exists($this->_grid->getQuery()->getRecordName(), $this->getName());
    }
761513
public function classIsContainer()
    {
        if ( $this->ClassIsContainer === null )
        {
            $object = $this->object();
            $class = $object->contentClass();
            $this->ClassIsContainer = $class->attribute( 'is_container' );
        }
        return $this->ClassIsContainer;
    }
440694
public function isRecordOriginFlagSet()
    {
        $retVal = false;
        if ($this->def->getService() !== null
            && is_object($this->def->getService())
            && $this->def->getService()->getRecordOriginModifiable() !== null) {
            $retVal = true;
        }

        return $retVal;
    }
906442
static boolean safeContains(Collection<?> collection, @Nullable Object object) {
    checkNotNull(collection);
    try {
      return collection.contains(object);
    } catch (ClassCastException e) {
      return false;
    } catch (NullPointerException e) {
      return false;
    }
  }
681756
public static boolean contains(Collection<?> collection, Object value) {
		return isNotEmpty(collection) && collection.contains(value);
	}
1109469
public function containsData()
    {
        if (!isset($this->Data["Series"])) {
            return false;
        }

        foreach (array_keys($this->Data["Series"]) as $Key) {
            if ($this->Data["Abscissa"] != $Key
                && $this->Data["Series"][$Key]["isDrawable"] == true
            ) {
                return true;
            }
        }

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

        return false;
    }
1230216
public function hasPatterns()
    {
        return (boolean) count($this->includesFileList) > 0 || count($this->excludesFileList) > 0
            || count($this->includeList) > 0 || count($this->excludeList) > 0;
    }
32791
public function has_summary() {
        if (isset($this->record->hassummary)) {
            return !empty($this->record->hassummary);
        }
        if (!isset($this->record->summary)) {
            // We need to retrieve summary.
            $this->__get('summary');
        }
        return !empty($this->record->summary);
    }
778894
public static function isEmpty()
    {
        $config = Conf::f('storage-mongodb-object', array());
        $db = isset($config['databases']) ? $config['databases'] : 'default';
        $db = DB::get($db);

        $collection = $db->selectCollection($this->getCollectionName());
        $it = $collection->find();
        $it->limit(1);
        $it->rewind();
        return $it->hasNext() === false;
    }
1004557
function hasContent()
    {
        $dataType = $this->dataType();
        if ( is_object( $dataType ) )
        {
            return $dataType->hasObjectAttributeContent( $this );
        }
        return false;
    }