Move the page number by a given offset. Beware to not let any hole
        in the page numbers when doing this. Make sure also that the wanted
        number is available.
        Will also change the page number of the current object.
488704
def change_index(self, offset=0):
        
        src = {}
        src["box"] = self.__get_box_path()
        src["img"] = self.__get_img_path()
        src["thumb"] = self._get_thumb_path()

        page_nb = self.page_nb

        page_nb += offset

        logger.info("--> Moving page %d (+%d) to index %d"
                    % (self.page_nb, offset, page_nb))

        self.page_nb = page_nb

        dst = {}
        dst["box"] = self.__get_box_path()
        dst["img"] = self.__get_img_path()
        dst["thumb"] = self._get_thumb_path()

        for key in src.keys():
            if self.fs.exists(src[key]):
                if self.fs.exists(dst[key]):
                    logger.error("Error: file already exists: %s" % dst[key])
                    assert(0)
                self.fs.rename(src[key], dst[key])
465458
private void moveVertical(int offset) {
        if (offset < 0) {
            moveUp(Math.abs(offset));
        } else if (offset > 0) {
            moveDown(offset);
        }
    }
307388
def move_cursor(row = nil)
      if row
        if (prev_item = items[current_row])
          main.draw_item prev_item
        end
        page = row / max_items
        switch_page page if page != current_page
        main.activate_pane row / maxy
        @current_row = row
      else
        @current_row = 0
      end

      item = items[current_row]
      main.draw_item item, current: true
      main.display current_page

      header_l.draw_current_file_info item
      @current_row
    end
124145
public void seek(int offset) throws IOException {
    if (!(offset >= bufferOffset && offset < bufferOffset + maxBufferSize)) {
      writeBuffer();
      newBuffer(offset);
      aFile.seek(offset);
    }
    position = offset;
  }
659172
def seek(self, offset, whence=0):
        '''
        
        '''
        if whence == 0:
            self._pos = self._start_pos + offset
        elif whence == 1:
            self._pos += offset
        else:
            self._pos = (self._end_pos - 1) + offset
660307
public function moveToRoot()
    {
        $db = Database::connection();
        $db->executeQuery('update Pages set cParentID = 0 where cID = ?', [$this->getCollectionID()]);
        $this->cParentID = 0;
        $this->rescanSystemPageStatus();
    }
1278675
protected function calculateOffset()
    {
        if (empty($this->page) || empty($this->perPage)) {
            throw new \RuntimeException('Cannot calculate offset. Insufficient data');
        }

        $this->offset = ($this->page - 1) * $this->perPage;
    }
1362977
private void move1() {
        if (node == null)
            return;

        if (position >= reference.size()) {
            node = null;
            return;
        }

        node = node.links[reference.codeAt(position++)];
    }
1343705
private void updatePage() {
		// retrieve page
		final int retrievalPage = page == LAST_PAGE ? pageCount : page;
		final List<Row> rows;
		try {
			rows = client.getExecutor().retrieveResultPage(resultDescriptor.getResultId(), retrievalPage);
		} catch (SqlExecutionException e) {
			close(e);
			return;
		}

		// convert page
		final List<String[]> stringRows = rows
				.stream()
				.map(CliUtils::rowToString)
				.collect(Collectors.toList());

		// update results
		if (previousResultsPage == retrievalPage) {
			// only use the previous results if the current page number has not changed
			// this allows for updated results when the key space remains constant
			previousResults = results;
		} else {
			previousResults = null;
			previousResultsPage = retrievalPage;
		}

		results = stringRows;

		// check if selected row is still valid
		if (selectedRow != NO_ROW_SELECTED) {
			if (selectedRow >= results.size()) {
				selectedRow = NO_ROW_SELECTED;
			}
		}

		// reset view
		resetAllParts();
	}
578520
def move_by_offset(self, xoffset, yoffset):
        
        if self._driver.w3c:
            self.w3c_actions.pointer_action.move_by(xoffset, yoffset)
            self.w3c_actions.key_action.pause()
        else:
            self._actions.append(lambda: self._driver.execute(
                Command.MOVE_TO, {
                    'xoffset': int(xoffset),
                    'yoffset': int(yoffset)}))
        return self
1328289
void moveBlock()
    {
        int offset = _bufferOffset + _pos - _keepSizeBefore;
        // we need one additional byte, since movePos moves on 1 byte.
        if (offset > 0)
        {
            offset--;
        }

        int numBytes = _bufferOffset + _streamPos - offset;

        // check negative offset ????
        System.arraycopy(_bufferBase, offset, _bufferBase, 0, numBytes);
        _bufferOffset -= offset;
    }
492583
private void move(Resource ext) throws PageException {
	Resource trg;
	Resource trgDir;
	try {
	    trg = getExtensionFile(config, ext, id, name, version);
	    trgDir = trg.getParentResource();
	    trgDir.mkdirs();
	    if (!ext.getParentResource().equals(trgDir)) {
		if (trg.exists()) trg.delete();
		ResourceUtil.moveTo(ext, trg, true);
		this.extensionFile = trg;
	    }
	}
	catch (Exception e) {
	    throw Caster.toPageException(e);
	}
    }
614946
private void moveTo(long blkNum, int slot) {
		moveFrom = currentPage.currentBlk().number(); // for deletion
		BlockId blk = new BlockId(currentPage.currentBlk().fileName(), blkNum);
		ccMgr.readLeafBlock(blk);
		currentPage.close();
		currentPage = new BTreePage(blk, NUM_FLAGS, schema, tx);
		currentSlot = slot;
	}
488393
@Override
	public void nextPage() {
		if (!paged) {			
			this.firstPage();
			paged = true;
		} else if (!isLast()) {
			offset = (getPageNumber() + 1) * pageSize;

			execute();
		}
	}
168252
def _nextPage(self, offset):
        """"""
        self.logger.debug("Iterator crecord=%s" % str(self.crecord))

        params = {
            'q': self.q,
            'rows': '0',
            'facet': 'true',
            'facet.field': self.field,
            'facet.limit': str(self.pagesize),
            'facet.offset': str(offset),
            'facet.zeros': 'false',
            'wt': 'python',
        }
        if self.fq is not None:
            params['fq'] = self.fq
        request = urllib.parse.urlencode(params, doseq=True)
        rsp = self.client.doPost(
            self.client.solrBase + '', request, self.client.formheaders
        )
        data = eval(rsp.read())
        try:
            self.res = data['facet_counts']['facet_fields'][self.field]
            self.logger.debug(self.res)
        except Exception:
            self.res = []
        self.index = 0
375176
function changePage(pageNumber) {
      var emit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

      if (pageNumber > 0 && this.total > this.currentPerPage * (pageNumber - 1)) {
        this.prevPage = this.currentPage;
        this.currentPage = pageNumber;
        if (emit) this.pageChanged();
      }
    }
1039944
def _next_page(self, offset):
        """"""
        self._log.debug("Iterator c_record={}".format(self.c_record))
        page_size = self.page_size
        if (offset + page_size) > self.max_records:
            page_size = self.max_records - offset
        param_dict = self.query_dict.copy()
        param_dict.update(
            {
                'start': str(offset),
                'rows': str(page_size),
                'explainOther': '',
                'hl.fl': '',
            }
        )
        self.res = self.client.search(**param_dict)
        self._num_hits = int(self.res['response']['numFound'])