Returns true, if entities contains VO members group

@param Group[] $entities
@return bool
13143
private function containsMembersGroup($entities)
    {
        if (empty($entities)) {
            return false;
        }
        foreach ($entities as $entity) {
            if (preg_match('/[^:]*:members$/', $entity->getName())) {
                return true;
            }
        }
        return false;
    }
744246
@Override
    public boolean contains(IEntityGroup group, IGroupMember member) throws GroupsException {
        return (member.isGroup())
                ? containsGroup(group, (IEntityGroup) member)
                : containsEntity(group, member);
    }
243670
protected function doesContainsObjects(array $objects) : bool
    {
        $this->toOrderedMap();

        foreach ($objects as $object) {
            if ($object->hasId()) {
                if (!isset($this->identityMap[$object->getId()])) {
                    return false;
                }
            } else {
                if (!isset($this->instanceIdMap[$object])) {
                    return false;
                }
            }
        }

        return true;
    }
854538
public function isAttached( Base $entity )
    {
        return false !== array_search( $entity, $this->instancesPersisted, true ) ||
               false !== array_search( $entity, $this->instancesUnpersisted, true );
    }
488948
public function isManagedByDoctrine($entity)
    {
        $cacheKey  = 'managed';
        $entity    = $this->toString($entity);
        $isManaged = $this->getFromCache($entity, $cacheKey, null);

        if (null !== $isManaged) {
            return $isManaged;
        }

        try {
            $this->managed = $isManaged = (bool) $this->entityManager->getReference($entity, 0);
            $entity = $this->getEntityClassFull($entity);
        } catch (\Exception $e) {
            $isManaged = false;
        }

        $this->cache[$entity][$cacheKey] = $isManaged;

        return $isManaged;
    }
649575
public function isGranted($roles)
    {
        $this->parseRoles();

        $roles = (array) $roles;
        $intersection = array_intersect($roles, $this->roles);

        return count($intersection) > 0;
    }
56076
public function addGrouping( $grouping )
	{
		if( is_array( $grouping ) )
			return $this->addGroupings( $grouping );
		if( in_array( $grouping, $this->groupings ) )
			return FALSE;
		$this->groupings[] = $grouping;
		return TRUE;
	}
985165
protected function doesContainsObjects(array $objects) : bool
    {
        $objectsLookup = $this->asArray();

        foreach ($objects as $object) {
            if (!in_array($object, $objectsLookup, false)) {
                return false;
            }
        }

        return true;
    }
270598
public function equals(Entity $entity = null)
	{
		if ($entity === null) {
			return false;
		}

		// Equals if matches
		if ($entity === $this) {
			return true;
		}

		$id = $this->getId();

		if ( ! empty($id) && $entity->getId() === $id) {
			return true;
		}

		return false;
	}
972401
public function contains($entity)
    {
        return $this->unitOfWork->isScheduledForInsert($entity)
            || ($this->unitOfWork->isInIdentityMap($entity) && ! $this->unitOfWork->isScheduledForDelete($entity));
    }
62287
public function has($key)
    {
        $result = $this->get($key);

        //an empty EntityCollection means no related entities
        if ($result instanceof EntityCollection && count($result) === 0) {
            return false;
        }

        return $result ? true : false;
    }
357217
public function hasRoles($roles): bool
    {
        $userRoles = $this->getRoles()->all();

        // We should ensure that all given roles match the current user,
        // consider it as a AND condition instead of OR.
        foreach ((array) $roles as $role) {
            if (! \in_array($role, $userRoles)) {
                return false;
            }
        }

        return true;
    }
1374681
protected function isValidEntityState($entity)
    {
        $entityState = $this->uow->getEntityState($entity, UnitOfWork::STATE_NEW);

        if ($entityState === UnitOfWork::STATE_NEW) {
            return false;
        }

        // If Entity is scheduled for inclusion, it is not in this collection.
        // We can assure that because it would have return true before on array check
        if ($entityState === UnitOfWork::STATE_MANAGED && $this->uow->isScheduledForInsert($entity)) {
            return false;
        }

        return true;
    }
620426
protected function isAll(array $roles)
    {
        foreach ($roles as $role) {
            if (!$this->hasRole($role)) {
                return false;
            }
        }

        return true;
    }
574482
public function delete($entities)
    {
        if($entities instanceof Entity) {
            $entities = [$entities];
        }
        return $this->obj_gateway
            ->withSchema($this->obj_schema)
            ->withTransaction($this->consumeTransaction())
            ->deleteMulti($entities);
    }
376949
public function containsAll($elements): bool {
        $contains = false;
        if (\is_iterable($elements)) {
            foreach ($elements as $element) {
                $contains &= $this->contains($element);
            }
        }
        return $contains;
    }
134368
protected function isGroupExcluded(array $commandGroups): bool
    {
        return (count($this->excludedCommandsAndGroups) > 0 && (count(array_intersect($this->excludedCommandsAndGroups, $commandGroups)) > 0));
    }