Merge this Miner's INTOVALUES into the given Miner.

@param  Miner $Miner to merge into
@return Miner
340895
public function mergeIntoValues(Miner $Miner)
    {
        if ($this->intoValues) {
            $Miner->intoValues($this->intoValues);
        }

        return $Miner;
    }
280676
def merge_hashes(hashes)
      hashes.inject({}) { |n, h| n.weave(h, true) }
    end
206693
public function merge(Collection $collection) : self
    {
        $return = clone $this;
        $return->elements = array_merge($return->elements, $collection->elements);

        return $return;
    }
2414
public static function member_from_autologinhash($hash, $login = false)
    {
        /** @var Member $member */
        $member = static::get()->filter([
            'AutoLoginHash' => $hash,
            'AutoLoginExpired:GreaterThan' => DBDatetime::now()->getValue(),
        ])->first();

        if ($login && $member) {
            Injector::inst()->get(IdentityStore::class)->logIn($member);
        }

        return $member;
    }
1149487
protected function convertZoneFromHash($hash)
    {
        if (isset($hash['blocks'])) {
            $blocks = array();

            foreach ($hash['blocks'] as $block) {
                $blocks[] = $this->convertBlockFromHash($block);
            }

            $hash['blocks'] = $blocks;
        }

        return new Zone($hash);
    }
834929
public function merge($values): Set
    {
        $merged = $this->copy();

        foreach ($values as $value) {
            $merged->add($value);
        }

        return $merged;
    }
147214
function Miner(options) {
  if (!(this instanceof Miner))
    return new Miner(options);

  AsyncObject.call(this);

  this.options = new MinerOptions(options);
  this.network = this.options.network;
  this.logger = this.options.logger.context('miner');
  this.workers = this.options.workers;
  this.chain = this.options.chain;
  this.mempool = this.options.mempool;
  this.addresses = this.options.addresses;
  this.locker = this.chain.locker;
  this.cpu = new CPUMiner(this);

  this.address = null;

  this.init();
}
723494
protected static function mergeArrays($target, $source)
    {
        foreach ($source as $node => $values) {
            if (!array_key_exists($node, $target)) {
                $target[$node] = $values;
            } elseif (is_array($values)) {
                $target[$node] = self::mergeArrays($target[$node], $values);
            } else {
                $target[$node] = $values;
            }
        }

        return $target;
    }
1248454
public function merge(Condition $condition)
    {
        $this->expressions = array_merge($this->expressions, $condition->toArray());

        return $this;
    }
299065
public function fill($newValue): self
    {
        foreach ($this->values as $index => $value) {
            $this->values[$index] = $newValue;
        }

        return $this;
    }
393009
public function merge( LogDataInterface $log ) {

		$log_data = [
			self::MESSAGE => $log->message(),
			self::LEVEL   => $log->level(),
			self::CHANNEL => $log->channel(),
			self::CONTEXT => $log->context(),
		];

		return $this->merge_array( $log_data );
	}
565318
function CPUMiner(miner) {
  if (!(this instanceof CPUMiner))
    return new CPUMiner(miner);

  AsyncObject.call(this);

  this.miner = miner;
  this.network = this.miner.network;
  this.logger = this.miner.logger.context('cpuminer');
  this.workers = this.miner.workers;
  this.chain = this.miner.chain;
  this.locker = new Lock();
  this.locker2 = new Lock();

  this.running = false;
  this.stopping = false;
  this.own = false;
  this.job = null;
  this.stopJob = null;

  this._init();
}
988930
public function merge(array $values)
    {
        foreach ($values as $key => $value) {
            $this->set($key, $value, ['strict' => false]);
        }

        return $this;
    }
645789
public function fromHash($hash)
    {
        if ($hash === null) {
            return $this->getEmptyValue();
        }

        $countries = array();
        foreach ($hash as $country) {
            foreach ($this->countriesInfo as $countryInfo) {
                switch ($country) {
                    case $countryInfo['Name']:
                    case $countryInfo['Alpha2']:
                    case $countryInfo['Alpha3']:
                        $countries[$countryInfo['Alpha2']] = $countryInfo;
                        continue 3;
                }
            }

            throw new InvalidValue($country);
        }

        return new Value($countries);
    }
927788
protected function resolveValue(array $config, string $hash)
    {
        if (! isset($config['uses'])) {
            return $config['default'] ?? null;
        }

        if (! \is_array($config['uses'])) {
            return $this->getValue($this->getContent(), $config['uses'], $hash);
        }

        $values = [];

        foreach ($config['uses'] as $use) {
            $values[] = $this->getValue($this->getContent(), $use, $hash);
        }

        return $values;
    }
489848
public function merge(array $values, $invert = false) {
		$obj = $this->preserveInstance ? $this : clone $this;
		$obj->config = ($invert) ? array_merge($values, $this->config) : array_merge($this->config, $values);
		return $obj;
	}
487397
public static function merge( $target )
    {
        $_arrays = static::clean( func_get_args() );
        $_target = static::clean( array_shift( $_arrays ) );

        foreach ( $_arrays as $_array )
        {
            $_target = array_merge(
                $_target,
                static::clean( $_array )
            );

            unset( $_array );
        }

        unset( $_arrays );

        return $_target;
    }