checks input array for ObjectInFolderDataInterface and sets objects

@param ObjectInFolderDataInterface[] $objects
542026
public function setObjects(array $objects)
    {
        foreach ($objects as $object) {
            $this->checkType(ObjectInFolderDataInterface::class, $object);
        }

        $this->objects = $objects;
    }
1313569
protected function checkAllScheduledByAction(array $objects, $action): void
    {
        foreach ($objects as $object) {
            $this->postResetPermissions[] = $object;

            if ('delete' !== $action) {
                $this->getObjectFilter()->restore($object);
            }
        }
    }
240485
protected function fetchArray(array &$array, array &$objects = [])
    {
        foreach ($array as &$value) {
            if (is_array($value)) {
                $this->fetchArray($value, $objects);
            } elseif (is_string($value) &&
                     strpos($value, '__php_object_freezer_') === 0) {
                $uuid = str_replace('__php_object_freezer_', '', $value);

                if (!$this->lazyLoad) {
                    $this->doFetch($uuid, $objects);
                } else {
                    $value = new Object_Freezer_LazyProxy($this, $uuid);
                }
            }
        }
    }
1066799
public function setModels($models)
    {
        if (!is_object($models)) {
            if (is_array($models)) {
                $models = collect($models);
            }
        }

        if(class_basename($models->first()) == 'stdClass')
        {
            $models = $models->map(function ($array) {
                return new BlankModel($array);
            });
        }

        $this->models = $models;
    }
955174
public function fromArray($objects)
    {
        $this->clear();
        foreach ($objects as $objectData) {
            $this->add($objectData);
        }
    }
846710
public function add($objects)
    {
        if (!is_array($objects))
        {
            $objects = [$objects];
        }
        $operation = new AVRelationOperation($objects, null);
        $this->targetClassName = $operation->_getTargetClass();
        $this->parent->_performOperation($this->key, $operation);
    }
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;
    }
858175
protected function checkUnsupportedTypes(array $objects)
    {
        if ($this->supportedTypes !== null) {
            $unsupportedTypes = array_diff(TypedUtils::uniqueTypes($objects), $this->supportedTypes);
            if (count($unsupportedTypes) > 0) {
                throw new Exception(sprintf(
                    'Encountered unsupported types %s (supported: %s)',
                    implode(', ', $unsupportedTypes),
                    count($this->supportedTypes) > 0 ? implode(', ', $this->supportedTypes) : '*none*'
                ));
            }
        }
    }
118101
private function defineRepositories(array $objects, ContainerBuilder $container)
    {
        foreach ($objects as $object => $services) {
            if (array_key_exists('model', $services)) {
                $repositoryDefinition = $this->getRepositoryDefinition($object, $services, $container);

                $container->setDefinition(
                    $this->getContainerKey('repository', $object),
                    $repositoryDefinition
                )->setPublic(true);
            }
        }
    }
435696
public void setObjectGroups(Map<String, List<String>> objectGroups) {
        this.objectGroups.clear();
        if (objectGroups != null) {
            this.objectGroups.putAll(objectGroups);
        }
    }
472013
public function initialize(array $packages)
    {
        $this->registeredClassNames = $this->registerClassFiles($packages);
        $this->reflectionService->buildReflectionData($this->registeredClassNames);

        $rawCustomObjectConfigurations = $this->configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_OBJECTS);

        $configurationBuilder = new ConfigurationBuilder();
        $configurationBuilder->injectReflectionService($this->reflectionService);
        $configurationBuilder->injectLogger($this->logger);

        $this->objectConfigurations = $configurationBuilder->buildObjectConfigurations($this->registeredClassNames, $rawCustomObjectConfigurations);

        $this->setObjects($this->buildObjectsArray());
    }
1142785
public void setObjectClasses(List<String> objectClasses) {
        int size = objectClasses.size();
        iObjectClasses = new ArrayList<String>(objectClasses.size());
        for (int i = 0; i < size; i++) {
            String objectClass = objectClasses.get(i).toLowerCase();
            if (!iObjectClasses.contains(objectClass)) {
                iObjectClasses.add(objectClass);
            }
        }
    }
368993
public function setClasses($classes)
    {
        if (!is_array($classes)) {
            $classes = $classes ? array($classes) : array();
        }
        $this->modelClasses = $classes;
    }
805481
public static function set(array &$array, ...$keys): void
    {
        if (\count($keys) < 2) {
            throw new \InvalidArgumentException('Method `Collection::set()` is required minimum one key and value');
        }

        $value = array_pop($keys);
        while (\count($keys) > 1) {
            $key = array_shift($keys);
            if (!isset($array[$key]) || !\is_array($array[$key])) {
                $array[$key] = [];
            }
            $array = &$array[$key];
        }
        $array[array_shift($keys)] = $value;
    }
989879
public static function reset($object)
	{
		if (!($object instanceof FileOptions)) {
			throw new \InvalidArgumentException('You have to pass object of class Google\Protobuf\FileOptions.');
		}
		$object->javaPackage = NULL;
		$object->javaOuterClassname = NULL;
		$object->javaMultipleFiles = NULL;
		$object->javaGenerateEqualsAndHash = NULL;
		$object->javaStringCheckUtf8 = NULL;
		$object->optimizeFor = NULL;
		$object->goPackage = NULL;
		$object->ccGenericServices = NULL;
		$object->javaGenericServices = NULL;
		$object->pyGenericServices = NULL;
		$object->deprecated = NULL;
		$object->ccEnableArenas = NULL;
		$object->objcClassPrefix = NULL;
		$object->csharpNamespace = NULL;
		$object->javananoUseDeprecatedPackage = NULL;
		$object->uninterpretedOption = NULL;
	}
467991
public function setData($data)
	{
		if( is_null($data) )
		{
			$data = [];
		}

		if( $data instanceof stdClass )
		{
			$data = [$data];
		}

		if( is_array($data) )
		{
			$data = $this->checkItems($data);
			$this->data = $data;
		}

		$this->data = (array) $data;

		if(empty($this->type) && ! empty($this->data[0]))
		{
			$this->type = $this->data[0]->getType();
		}
	}
1255815
public function setFiles($files = [])
    {
        if (!$files instanceof FileBag) {
            $files = new FileBag($files);
        }

        $this->_files = $files;
    }