Checks if the given paths are all of the given type.

@param  array   $paths
@param  string  $type
@return boolean
325497
protected function are($paths, $type)
    {
        foreach ($paths as $path) {
            if (! $this->is($path, $type)) {
                return false;
            }
        }
        return (count($paths) == 0) ? false : true;
    }
1102189
private function getFullPath($type, $path)
    {
        return sprintf('%s/%s/%s', $this->config['web_root_dir'], $this->config[$type . '_path'], $path);
    }
395982
protected function validateTypeCache($type, $files)
    {
        // If the files isn't cached we have to cache the file
        $hash = $this->getTypeHash($type);
        if (!isset($this->cachedFiles[$hash])) {
            return false;
        } 
        
        $data = $this->cachedFiles[$hash];
        $checksums = $data['checksums'];

        // Are all files existing?
        foreach ($files as $file) {
            if (!file_exists($file->getFileName())) {
                return false;
            }
            
            $fileHash = $this->getHash($file->getFileName());
            $contentHash = md5_file($file->getFileName());
            if (!isset($checksums[$fileHash]) || $contentHash !== $checksums[$fileHash]) {
                return false;
            }
        }
        
        return true;
    }
1082947
public function addAll(Paths $paths) {
		foreach ($paths as $p) {
			$path = $this->get($p->getPath());
			foreach ($p->getMethods() as $method) {
				$path->setOperation($method, $p->getOperation($method));
			}
		}
	}
212504
public function prevTypeIsAnyOf(array $types): bool
    {
        return isset($this->tokens[$this->position - 2]) && $this->tokens[$this->position - 2]->typeEqualsAnyOf($types);
    }
1078576
public function withIncludedPaths(iterable $paths): EncoderInterface
    {
        \assert(
            \call_user_func(
                function (array $paths): bool {
                    $pathsOk = true;
                    foreach ($paths as $path) {
                        $pathsOk = $pathsOk === true && \is_string($path) === true && empty($path) === false;
                    }

                    return $pathsOk;
                },
                $paths
            )
        );

        $this->includePaths = $paths;

        return $this;
    }
418263
public function nextIfAnyOf(array $types): bool
    {
        if (!$this->current->typeEqualsAnyOf($types)) {
            return false;
        }

        $this->next();
        return true;
    }
408260
public function lookaheadTypeIsAnyOf(array $types): bool
    {
        return isset($this->tokens[$this->position]) && $this->tokens[$this->position]->typeEqualsAnyOf($types);
    }
1196061
public static function hasOuterArray(string $type) : bool
    {
        $type = self::normalise($type, true);

        return (substr($type, -2) === '[]');
    }
679440
public function exists($type)
    {
        foreach ($this->loaders as $loader) {
            if ($loader->exists($type)) {
                return true;
            }
        }

        return false;
    }
1247677
public function has($path) {
        $target = &$this->all;
        foreach (explode('.', $path) as $key) {
            if (array_key_exists($key, $target)) {
                $target = &$target[$key];
            } else return false;
        }
        return true;
    }
328958
private function checkType($type)
    {
        $isInType = true;

        foreach ($this->getKeys() as $key) {
            if (gettype($key) !== $type) {
                $isInType = false;
                break;
            }
        }

        return $isInType;
    }
67163
public function containsOneOf(array $types)
	{
		foreach($this->tokens as $token)
		{
			if($token->isOneOf($types))
			{
				return true;
			}
		}
		
		return false;
	}
430771
public function validate($path, array $mimeTypes = [])
    {
        if (empty($mimeTypes)) {
            $mimeTypes = $this->mimeTypes;
        }

        return in_array(self::getType($path), $mimeTypes);
    }
1129379
private function PathPartRegistered( array & $a_path_part, array & $a_paths ) : bool {
    
        foreach ( $a_paths as $a_path ) {
        
            if ( $this->IsPathPart( $a_path_part, $a_path ) ) return true;
        
        }
    
        return false;
        
    }
250174
public static function has(array $values, $path)
    {
        $defaultValue = __METHOD__ . '::' . random_int(16, 32);

        return static::get($values, $path, $defaultValue) !== $defaultValue;
    }
67051
protected function convertTo($type, array $files) {
		$res = [];
		foreach($files as $name=>$file) {
			if(is_array($file))
				$res[$name] = $this->convertTo($type, $file);
			else
				$res[$name][$type] = $file;
		}

		return $res;
	}