Merge this Miner's REPLACE into the given Miner.

@param Miner $Miner
to merge into
@return Miner
14224
public function mergeReplaceInto(Miner $Miner)
    {
        $this->mergeOptionsInto($Miner);
        
        if ($this->replace) {
            $Miner->replace($this->getReplace());
        }
        
        return $Miner;
    }
1230029
public function merge($array)
    {
        if ($this->isInstanceOf($array, $this)) {
            $array = $array->val();
        }

        $this->val(array_merge($this->val(), $array));

        return $this;
    }
41618
private function makeReplace($output){
		$replaced = $output;

		foreach($this->_direct_replace as $key => $val){
			$needle = '{' . strtoupper(trim($key, '{} ')) . '}';

			$replaced = str_replace($needle, $val, $replaced);
		}

		return $replaced;
	}
543546
protected function convertBlockFromHash($hash)
    {
        if (isset($hash['items'])) {
            $items = array();

            foreach ($hash['items'] as $item) {
                $items[] = $this->convertItemFromHash($item);
            }

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

        return new Block($hash);
    }
868364
protected function mergePools($pools)
    {
        $mergedPool = [];

        foreach ($pools as $pool) {
            foreach ($pool->getCharacters() as $character) {
                $mergedPool[] = $character;
            }
        }

        return $mergedPool;
    }
196128
public function mergeWith(Address $address): self
    {
        return new static(...\array_merge($this->ipv4, $address->ipv4), ...\array_merge($this->ipv6, $address->ipv6));
    }
925633
public static function self($verify = false)
    {
        $driver = __config()->hashing->driver;
        if ($driver === 'bcrypt') {
            self::$driver = new BcryptHashing(['cost' => __config()->hashing->bcrypt->cost]);
        } elseif ($driver === 'argon2i') {
            self::$driver = new ArgonHashing([
                'memory'  => __config()->hashing->argon->memory,
                'time'    => __config()->hashing->argon->time,
                'threads' => __config()->hashing->argon->threads,
                'verify'  => $verify,
            ]);
        } elseif ($driver === 'argon2id') {
            self::$driver = new Argon2IdHashing([
                'memory'  => __config()->hashing->argon->memory,
                'time'    => __config()->hashing->argon->time,
                'threads' => __config()->hashing->argon->threads,
                'verify'  => $verify,
            ]);
        } else {
            throw new \Exception('We\'re sorry, The hashing driver '.$driver.' not supported.', 500);
        }
    }
441012
public function merge(Set $rules): self
    {
        $this->rules = array_merge($this->rules, $rules->rules);
        return $this;
    }
1099434
protected function deepMergeInto(Hash $into, Hash $other)
    {
        foreach ($other as $key => $value) {
            if (is_object($value)
                && $value instanceof self
                && $into->hasKey($key)
            ) {
                $value = $this->deepMergeInto($into[$key], $value);
            }

            $into[$key] = $value;
        }

        return $into;
    }
199348
protected function merge()
    {
        if (null === $this->merge) {
            $this->merge = new MergeBuilder($this);
        }

        return $this->merge;
    }
1177982
public function fromHash( $hash )
    {
        if ( !is_array( $hash ) )
        {
            return new Value( [] );
        }
        $metas = [];
        foreach ( $hash as $hashItem )
        {
            if ( !is_array( $hashItem ) )
            {
                continue;
            }
            $meta = new Meta();
            $meta->setName( $hashItem["meta_name"] );
            $meta->setContent( $hashItem["meta_content"] );
            $metas[] = $meta;
        }

        return new Value( $metas );
    }
152645
public function mergeLimitInto(Miner $Miner)
    {
        if ($this->limit) {
            $Miner->limit($this->getLimit(), $this->getLimitOffset());
        }

        return $Miner;
    }
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();
}
430972
public function replaceManager(User $from, User $to)
    {
        $teams = $this->teamRepo->findByTeamManager($from);

        if (count($teams) > 0) {
            foreach ($teams as $team) {
                $team->setTeamManager($to);
            }

            $this->om->flush();
        }

        return count($teams);
    }
670711
public function addReplace($replace, $version = '*', $overwrite = false)
    {
        if (!isset($this->getReplace()->$replace) || $overwrite) {
            $this->getReplace()->$replace = $version;
        }

        return $this;
    }
1125126
public function replace(self $find, self $replace){
		return new static(\str_replace($find, $replace, $this->_Value), $this->_Encoding);
	}
477094
public function merge($headers) {

        foreach ($headers as $key => $value) {
            $this->set($key, $value);
        }

        return $this;

    }