Move a cell object from one address to another

@param    string        $fromAddress    Current address of the cell to move
@param    string        $toAddress        Destination address of the cell to move
@return    boolean
502101
public function moveCell($fromAddress, $toAddress)
    {
        if ($fromAddress === $this->currentObjectID) {
            $this->currentObjectID = $toAddress;
        }

        $this->deleteQuery->bindValue('id', $toAddress, SQLITE3_TEXT);
        $result = $this->deleteQuery->execute();
        if ($result === false) {
            throw new PHPExcel_Exception($this->DBHandle->lastErrorMsg());
        }

        $this->updateQuery->bindValue('toid', $toAddress, SQLITE3_TEXT);
        $this->updateQuery->bindValue('fromid', $fromAddress, SQLITE3_TEXT);
        $result = $this->updateQuery->execute();
        if ($result === false) {
            throw new PHPExcel_Exception($this->DBHandle->lastErrorMsg());
        }

        return true;
    }
32225
public function setBounds($from, $length = null, $stopOutOfBounds = false) {
        $this->from = $from;
        $this->length = $length;
        $this->outOfBounds = (bool) $stopOutOfBounds;
        return $this;
    }
768653
protected function _getFrom($from, $headers)
    {
        /* Since few MTAs are going to allow this header to be forged unless
         * it's in the MAIL FROM: exchange, we'll use Return-Path instead of
         * From: if it's set. */
        foreach (array_keys($headers) as $hdr) {
            if (strcasecmp($hdr, 'Return-Path') === 0) {
                $from = $headers[$hdr];
                break;
            }
        }

        if (!strlen($from)) {
            throw new Horde_Mail_Exception('No from address provided.');
        }

        $from = new Horde_Mail_Rfc822_Address($from);

        return $from->bare_address_idn;
    }
352757
public function from($from = NULL) {
		if ($from !== NULL) {
			$from = intval($from);
		}

		$this->from = intval($from);
		return $this;
	}
338950
public function transferUnmanaged($toAddress, $numTokens, $privateKey, $tokenAddress = null, $gasPrice = null, $gasLimit = null)
    {
        $parameters = [
            'address_to' => $toAddress,
            'num_tokens' => $numTokens,
            'private_key' => $privateKey,
        ];

        // If $tokenAddress is set, use that instead of the internal tokenUid
        if ($tokenAddress !== null) {
            $parameters['token_address'] = $tokenAddress;
        }
        else {
            $parameters['token_uid'] = $this->tokenUid;
        }

        // Only include gasPrice and gasLimit if they're set
        if ($gasPrice !== null) $parameters['gas_price'] = $gasPrice;
        if ($gasLimit !== null) $parameters['gas_limit'] = $gasLimit;

        $response = $this->apiClient->post('tokens/transfer/unmanaged',
            $parameters
        );

        if (!isset($response['tx_hash'])) throw new \ErrorException('Unexpected API response: ' . print_r($response, true));

        return $response['tx_hash'];
    }
441276
public function renameTable($from, $to)
    {
    	if(!$this->hasTable($from)) {
    		return hst_message('is no has table');
    	}
    	if($this->hasTable($to)) {
    		return hst_message('is has table '.$to);
    	}
        \Schema::connection($this->databaseName)->rename($from, $to);
		return true;
    }
80670
protected function moveSubtreeTo($destLeft, $levelDelta, ConnectionInterface $con = null)
    {
        $left  = $this->getLeftValue();
        $right = $this->getRightValue();

        $treeSize = $right - $left +1;

        if (null === $con) {
            $con = Propel::getServiceContainer()->getWriteConnection(CategoryTableMap::DATABASE_NAME);
        }

        $con->transaction(function () use ($con, $treeSize, $destLeft, $left, $right, $levelDelta) {
            $preventDefault = false;

            // make room next to the target for the subtree
            ChildCategoryQuery::shiftRLValues($treeSize, $destLeft, null, $con);

            if (!$preventDefault) {

                if ($left >= $destLeft) { // src was shifted too?
                    $left += $treeSize;
                    $right += $treeSize;
                }

                if ($levelDelta) {
                    // update the levels of the subtree
                    ChildCategoryQuery::shiftLevel($levelDelta, $left, $right, $con);
                }

                // move the subtree to the target
                ChildCategoryQuery::shiftRLValues($destLeft - $left, $left, $right, $con);
            }

            // remove the empty room at the previous location of the subtree
            ChildCategoryQuery::shiftRLValues(-$treeSize, $right + 1, null, $con);

            // update all loaded nodes
            ChildCategoryQuery::updateLoadedNodes(null, $con);
        });
    }
1355350
public function setFromType($from_type)
    {
        if ($from_type == $this->from_type) return $this;
        $from_type = strtoupper($from_type);
        if (!isset(self::getAddressTypes()[$from_type])) {
            throw new \InvalidArgumentException(sprintf('The "%s" from_type is not a valid address type.', $from_type));
        }

        $this->from_type = $from_type;
        return $this;
    }
804822
public function renameTable(string $from, string $to): bool
    {
        $from = $this->quoter->quoteName($from);
        $to = $this->quoter->quoteName($to);
        $this->db->exec(sprintf('RENAME TABLE %s TO %s;', $from, $to));

        return true;
    }
131120
public function move(string $from, string $to, array $config = []): bool
    {
        list($prefixFrom, $pathFrom) = $this->getPrefixAndPath($from);
        list($prefixTo, $pathTo) = $this->getPrefixAndPath($to);

        if ($prefixFrom === $prefixTo) {
            $fs = $this->getFileSystem($prefixFrom);
            $renamed = $fs->rename($pathFrom, $pathTo);

            unset($prefixFrom, $pathFrom, $prefixTo);

            if ($renamed && isset($config['visibility'])) {
                return $fs->setVisibility($pathTo, $config['visibility']);
            }

            unset($fs, $pathTo);

            return $renamed;
        }

        if ($this->copy($from, $to, $config)) {
            return $this->delete($from);
        }

        return false;
    }
555995
public function setFrom($from)
    {
        if ($from === null) {
            throw new BuildException("this mapper requires a 'from' attribute");
        }

        $index = strrpos($from, '*');

        if ($index === false) {
            $this->fromPrefix = $from;
            $this->fromPostfix = "";
        } else {
            $this->fromPrefix = substr($from, 0, $index);
            $this->fromPostfix = substr($from, $index + 1);
            $this->fromContainsStar = true;
        }
        $this->prefixLength = strlen($this->fromPrefix);
        $this->postfixLength = strlen($this->fromPostfix);
    }
1032198
public function SetFrom($address, $name = '')
    {
        $address = trim($address);
        $name    = trim(preg_replace('/[\r\n]+/', '', $name)); //Strip breaks and trim
        if (!self::ValidateAddress($address)) {
            $this->SetError($this->Lang('invalid_address') . ': ' . $address);
            if ($this->exceptions) {
                throw new phpmailerException($this->Lang('invalid_address') . ': ' . $address);
            }
            echo $this->Lang('invalid_address') . ': ' . $address;
            return false;
        }
        $this->From     = $address;
        $this->FromName = $name;
        return true;
    }
366409
public function moveDirectory( $from, $to, $overwrite = false )
	{
		if ( $overwrite && $this->isDirectory( $to ) )
		{
			$this->deleteDirectory( $to );

			$this->copyDirectory( $from, $to );

			$this->deleteDirectory( $from );

			return true;
		}

		return @rename( $from, $to ) === true;
	}
1188360
public static function rangeFromBoundaries($from, $to)
    {
        $result = null;
        $invalid = false;
        foreach (array('from', 'to') as $param) {
            if (!($$param instanceof AddressInterface)) {
                $$param = (string) $$param;
                if ($$param === '') {
                    $$param = null;
                } else {
                    $$param = static::addressFromString($$param);
                    if ($$param === null) {
                        $invalid = true;
                    }
                }
            }
        }
        if ($invalid === false) {
            $result = static::rangeFromBoundaryAddresses($from, $to);
        }

        return $result;
    }
992026
public function move($from, $to)
    {
        return $this->filesystem->move(
            $this->path($from),
            $this->path($to)
        );
    }
1113088
public function move($from, $to, array $config = [])
    {
        list($prefixFrom, $pathFrom) = $this->getPrefixAndPath($from);
        list($prefixTo, $pathTo) = $this->getPrefixAndPath($to);

        if ($prefixFrom === $prefixTo) {
            $filesystem = $this->getFilesystem($prefixFrom);
            $renamed = $filesystem->rename($pathFrom, $pathTo);

            if ($renamed && isset($config['visibility'])) {
                return $filesystem->setVisibility($pathTo, $config['visibility']);
            }

            return $renamed;
        }

        $copied = $this->copy($from, $to, $config);

        if ($copied) {
            return $this->delete($from);
        }

        return false;
    }
820268
public function processSpringbotAbandonedCart($from, $data)
		{
			$form_data = array(
				'from' => $from,
				'data' => $data
			);
			$this->call('springbot_process_abandoned_cart', $form_data);

			return TRUE;
		}