Register the defined domain bindings.

@param Collection $bindings
970590
protected function registerBindings(Collection $bindings)
    {
        $bindings->each(function ($concretion, $abstraction) {
            $this->app->bind($abstraction, $concretion);
        });
    }
664584
public function seeSessionHasValues(array $bindings)
    {
        foreach ($bindings as $key => $value) {
            if (is_int($key)) {
                $this->seeInSession($value);
            } else {
                $this->seeInSession($key, $value);
            }
        }
    }
1336744
public function prepareRawStatement(string $statement, array $bindings): void
    {
        $this->statement = $statement;
        if (empty($bindings)) {
            return;
        }

        foreach ($bindings as $key => $value) {
            $this->addBindingValue($key, $value);
        }
    }
213475
public static function register(array $directives)
    {
        collect($directives)->each(function ($item, $key) {
            Blade::directive($key, $item);
        });
    }
763492
public function bind($bindings, $type = [])
	{
		$idx = 1;

		$this->bindings = $bindings;

		foreach ($bindings as $binding)
		{
			// We use bindValue here because that allows us to pass in plain old strings
			$this->statement->bindValue(
				$idx,
				$binding,
				isset($type[$idx]) ? $this->translateType($type[$idx]) : $this->inferType($binding)
			);

			$idx++;
		}

		return $this;
	}
1125084
protected function loadComponent($bindings, $name)
    {
        $aliases = array_values($bindings);
        $abstracts = array_keys($bindings);
        
        foreach ($abstracts as $index => $abstract) {
            $this->app->singleton(
                $abstract,
                $this->{"load{$name}Component"}()
            );
            
            $this->app->alias(
                $abstract,
                $aliases[$index]
            );
        }
    }
1145014
private function registerAnnotations(array $annotations)
    {
        $kernel = $this
            ->container
            ->get('kernel');

        foreach ($annotations as $annotation) {
            AnnotationRegistry::registerFile($kernel
                ->locateResource($annotation)
            );
        }
    }
1232873
public function registerMediaDomain($extensions, DomainInterface $mediaDomain)
    {
        foreach ((array) $extensions as $extensions) {
            $this->mediaDomainsMap[strtolower($extensions)] = $mediaDomain;
        }
    }
1065461
protected function registerBindings()
    {
        $this->app->singleton(PageHeaderDirective::class, PageHeaderDirective::class);
        $this->app->singleton(TooltipDirective::class, TooltipDirective::class);
        $this->app->singleton(SearchEngine::class, LocalSearch::class);
    }
629937
protected function registerBindings()
    {
        foreach ($this->bindings as $concrete => $abstracts) {
            if (!is_array($abstracts)) {
                $this->app->bind($abstracts, $concrete);
                continue;
            }

            $first = array_shift($abstracts);

            $this->app->bind($first, $concrete);

            foreach ($abstracts as $abstract) {
                $this->app->alias($first, $abstract);
            }
        }
    }
957004
public function registerDirective(DirectiveInterface ...$directives)
    {
        foreach ($directives as $directive) {
            $this->directives[$directive->getKey()] = $directive;

            if ($directive instanceof MultiValueDirectiveInterface) {
                if ($directive instanceof ComplexDirectiveInterface) {
                    $this->values[$directive->getKey()]['default'] = $directive->toArray();
                } elseif ($directive instanceof ScalarDirectiveInterface) {
                    $this->values[$directive->getKey()]['default'] = $directive->getValue();
                }
            } else if ($directive instanceof ScalarDirectiveInterface) {
                $this->values[$directive->getKey()] = $directive->getValue();
            } else {
                $this->values[$directive->getKey()] = $directive->toArray();
            }
        }

        return $this;
    }
428229
protected function initCatalogsForManyLocales($locales, $domain) {
		foreach ($locales as $locale) {
			$this->initCatalogsForSingleLocale($locale, $domain);
		}
	}
515098
public function register($types)
    {
        foreach ($types as $type => $definition) {
            $this->register($type, $definition);
        }

        return $this;
    }
832924
protected function putBindings($clause, array $bindings)
    {
        if (!empty($bindings)) {
            $this->bindings[$clause] = array_merge($this->bindings[$clause], $bindings);
        }
    }
1216753
public function mergeWheres($wheres, $bindings)
    {
        $this->wheres = array_merge((array) $this->wheres, (array) $wheres);

        $this->bindings['where'] = array_values(array_merge($this->bindings['where'], (array) $bindings));
    }
933278
public function values(array $bindings) {
        $references = array();
        foreach ($bindings as $k => $v) {
            $references[] = ":$k";
        }

        $this->sql .= 'VALUES (' . implode(', ', $references) . ') ';
        $this->params = array_merge($this->params, array_combine($references, array_values($bindings)));
        return $this;
    }
1123357
public function registerMailLayouts(array $definitions)
    {
        if (!$this->registeredLayouts) {
            $this->registeredLayouts = [];
        }

        $this->registeredLayouts = $definitions + $this->registeredLayouts;
    }