Add the passed destinations to the report.

@param array $destinations The list of destinations.

@return void

@throws \InvalidArgumentException When any of the passed objects is not of type DestinationInterface.
331471
private function addDestinations(array $destinations)
    {
        foreach ($destinations as $destination) {
            if (!$destination instanceof DestinationInterface) {
                throw new \InvalidArgumentException(get_class($destination) . ' is not a valid destination');
            }

            $this->destinations[] = $destination;
        }
    }
116553
public function setMappings(array $mappings) {
        $this->mappings = [];

        foreach ($mappings as $contentType => $dataClass) {
            $this->addMapping($contentType, $dataClass);
        }
    }
937023
public function addParameters(array $params)
    {
        if (!is_array($params)) {
            throw new \InvalidArgumentException('$params has to be an array');
        }
        $this->parameters = array_merge($this->parameters, $params);
    }
838464
public function addTables( $tables, $prefix = NULL )
	{
		if( !is_array( $tables ) )
			throw new InvalidArgumentException( 'An Array should be given.' );
		$tables	= (array) $tables;
		foreach( $tables as $table )
			$this->addTable( $table, $prefix );
	}
530670
public function addExcludePaths(array $paths) : void
    {
        $this->excludePaths = array_unique(array_merge($this->excludePaths, $paths));
    }
650776
protected function addPolygonNoTransform($points)
    {
        $pointCount = count($points);
        $this->ctx->moveTo($points[0]->x, $points[0]->y);
        for ($i = 1; $i < $pointCount; $i++) {
            $this->ctx->lineTo($points[$i]->x, $points[$i]->y);
        }
        $this->ctx->closePath();
    }
731012
public function addPoints(array $points)
    {
        $this->points = array_merge($this->points, $points);

        $endPoint = $this->points[count($this->points) - 1];
        $this->posX = $endPoint[0];
        $this->posY = $endPoint[1];
    }
870381
public function fit(array $values) : void
    {
        if (empty($values)) {
            throw new InvalidArgumentException('Strategy must be fit with'
                . ' at least 1 value.');
        }

        $categories = array_values(array_unique($values));

        $this->categories = $categories;
        $this->k = count($categories);
    }
657639
public function addGroupings( $groupings )
	{
		if( !is_array( $groupings ) )
			throw new InvalidArgumentException( 'An Array should be given.' );
		foreach( $groupings as $grouping )
			$this->addGrouping( $grouping );
	}
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));
			}
		}
	}
1154379
public function setPaths($paths)
    {
        if ($paths instanceof SplStack) {
            $this->paths = $paths;
        } elseif (is_array($paths)) {
            $this->clearPaths();
            $this->addPaths($paths);
        } else {
            throw new Exception\InvalidArgumentException(
                "Invalid argument provided for \$paths, expecting either an array or SplStack object"
            );
        }

        return $this;
    }
673949
public function setup(array $formatters)
    {
        foreach ($formatters as $formatterName => $formatter) {
            if (!$formatter instanceof TrackingParameterFormatterInterface) {
                throw new InvalidConfigurationException(
                    sprintf('Invalid tracking parameter formatter "%s".', $formatterName)
                );
            }
        }

        $this->formatters = $formatters;
    }
372708
public function addNew(array $routes): bool
    {
        foreach ($routes as $route) {
            $this->manager->add($this->manager->createPermission('/' . trim($route, ' /')));
        }

        $this->invalidate();

        return true;
    }
150156
public function addAbbreviations($values)
    {
        if (is_array($values)) {
            $values = new ArrayProvider($values);
        } elseif (!($values instanceof ValueProvider)) {
            throw new InvalidArgumentException('Values argument must either be an array or an instance of '.ValueProvider::class);
        }

        $this->abbreviationProviders[] = $values;
    }
884284
public function addParticipants(array $participants)
    {
        if (count($participants)) {
            foreach ($participants as $user_id) {
                Participant::firstOrCreate([
                    'user_id' => $user_id,
                    'thread_id' => $this->id,
                ]);
            }
        }
    }
1174825
public function addServers(array $servers)
    {
        foreach ($servers as $server) {
            $this->addServer(
                $server[0],
                $server[1],
                isset($server[2]) ? $server[2] : null
            );
        }
    }
1368612
public function addLogs( $logs ) {
		if( !is_array( $logs ) && !$logs instanceof LogList ) {
			throw new InvalidArgumentException( '$logs needs to either be an array or a LogList object' );
		}
		if( $logs instanceof LogList ) {
			$logs = $logs->toArray();
		}
		foreach( $logs as $log ) {
			$this->addLog( $log );
		}
	}