Merge this Miner's INSERT into the given Miner.

@param  Miner $Miner to merge into
@return Miner
978626
public function mergeInsertInto(Miner $Miner)
    {
        $this->mergeOptionsInto($Miner);

        if ($this->insert) {
            if ($this->isInto) {
                $Miner->insertInto($this->getInsert());
            } else {
                $Miner->insert($this->getInsert());
            }
        }

        return $Miner;
    }
1274060
public function runner($runner)
    {
        if ($runner instanceof Runner) {
            $this->runner = $runner;
        } else {
            $this->runner = $this->getRunner($runner);
        }

        return $this;
    }
1221417
public function merge(CollectionInterface ...$collections): CollectionInterface
    {
        $temp = [$this->data];

        foreach ($collections as $index => $collection) {
            if (!$collection instanceof static) {
                throw new CollectionMismatchException(
                    \sprintf('Collection with index %d must be of type %s', $index, static::class)
                );
            }

            $temp[] = $collection->toArray();
        }

        return new static(\array_merge(...$temp));
    }
284292
public function merge ()
	{
		$args = func_get_args();
		$a    = new SObject();

		// TODO: fix for actual Object

		foreach ($args as $arg) {
			if (is_an_array($arg)) {
				if ($arg instanceof self) {
					$arg = $arg->to_array();
				}

				foreach ($arg as $key => $value) {
					$key = strtolower($key);

					if (!$a->offsetExists($key)) {
						$a->offsetSet($key, $value);
					}
				}
			} else {
				/* XXX: Do we really support this? Object instances are
				 *      supposed to be hashes, Vector instances can be appended
				 *      to. */
				$a->storage []= $arg;
			}
		}

		return $a;
	}
1075726
public static function merge(...$options) {
            $o = [];

            foreach ($options as $opt) {
                if ($opt instanceof Options) {
                    $o = array_merge($o, $opt->toArray());
                } elseif (is_array($opt)) {
                    $o = array_merge($o, $opt);
                }
            }

            return new self(Util::trimNulls($o));
        }
199348
protected function merge()
    {
        if (null === $this->merge) {
            $this->merge = new MergeBuilder($this);
        }

        return $this->merge;
    }
441012
public function merge(Set $rules): self
    {
        $this->rules = array_merge($this->rules, $rules->rules);
        return $this;
    }
498161
public function into($table)
    {
        $this->_dirty();
        $this->_type = 'insert';
        $this->_parts['insert'][0] = $table;

        return $this;
    }
869253
public function getDBQueryBuilder(Context $context = null)
    {
        if ($this->dbQueryBuilder == null) {
            $this->dbQueryBuilder            = new Miner();
        }
        $this->dbQueryBuilder->context = $context;

        return $this->dbQueryBuilder;
    }
1170797
public function add(Block ...$blocks)
    {
        foreach ($blocks as $block) {
            $this->blocks[] = $block;
        }

        return $this;
    }
1025917
public function merge(CollectionInterface $collection)
    {
        $this->items = array_merge(
            $this->getItems(),
            $collection->getItems()
        );

        return $this;
    }
159217
public function mergeWith(self $objects): self
    {
        $clone = clone $this;
        foreach ($objects->objects as $reference => $object) {
            $clone->objects[$reference] = $object;
            $clone->array[$reference] = $object->getInstance();
        }
        
        return $clone;
    }
1009207
public function mergeDeleteInto(Miner $Miner)
    {
        $this->mergeOptionsInto($Miner);

        if ($this->isDeleteTableFrom()) {
            $Miner->delete();
        } else {
            foreach ($this->delete as $delete) {
                $Miner->delete($delete);
            }
        }

        return $Miner;
    }
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();
}
196128
public function mergeWith(Address $address): self
    {
        return new static(...\array_merge($this->ipv4, $address->ipv4), ...\array_merge($this->ipv6, $address->ipv6));
    }
752259
public function merge($entity) {
    // add to merged
    if (!$this->merged->contains($entity)) {
      $this->merged->add($entity);
    }
    
    // remove from removed,detached
    // nicht remove from persisted
    if ($this->removed->contains($entity)) {
      $this->removed->removeElement($entity);
    }
    if ($this->detached->contains($entity)) {
      $this->detached->removeElement($entity);
    }
    
    if ($this->delegate) {
      return parent::persist($entity);
    }
  }
153659
public function mergeSetInto(Miner $Miner)
    {
        foreach ($this->set as $set) {
            $Miner->set($set['column'], $set['value'], $set['quote']);
        }

        return $Miner;
    }