Remove paging from Binder
771055
def removePaging(self,):
        
        root = self.etree
        t_paging = root.find('paging')

        try:
            root.remove(t_paging)
            return True
        except (Exception,) as e:
            print(e)

        return False
1007005
def limit options = {}
      # Remove this key if we come from limit_page method.
      page = options.delete :page
      query = options.dup
      collection = new_collection scoped_query( options = {
        :limit => options[:limit],
        :offset => options[:offset],
        :order => [options[:order]]
      }.merge( query ) )
      options.merge! :count => calculate_total_records( query ), :page => page
      collection.paginator = DataMapper::Paginator::Main.new options
      collection
    end
106544
def _clean_bindings(self, bindings):
        
        return list(filter(lambda b: not isinstance(b, QueryExpression), bindings))
1179135
public void remove(DocumentFilter.FilterBypass fb, int offset, int length)
        throws BadLocationException {
        // FRICKIN' HACK!!!!! For some reason, deleting a string at offset 0
        // does not get done properly, so first replace and remove after parsing
        if (offset == 0 && length != fb.getDocument().getLength()) {
            fb.replace(0, length, "\n", lexer.defaultStyle);
            
            // start on either side of the removed text
            parseDocument(offset, 2);
            fb.remove(offset, 1);
        }
        else {
            fb.remove(offset, length);
            
            // start on either side of the removed text
            if (offset + 1 < fb.getDocument().getLength()) {
                parseDocument(offset, 1);
            }
            else if (offset - 1 > 0) {
                parseDocument(offset - 1, 1);
            }
            else {
                // empty text
                mlTextRunSet.clear();
            }
        }

    }
1198440
static Xdr removeRecordMarking(byte[] bytes) {
        Xdr toReturn = new Xdr(bytes.length);
        Xdr input = new Xdr(bytes);

        long fragSize;
        boolean lastFragment = false;

        input.setOffset(0);
        int inputOff = input.getOffset();

        while (!lastFragment) {

            fragSize = input.getUnsignedInt();
            lastFragment = isLastFragment(fragSize);
            fragSize = maskFragmentSize(fragSize);

            toReturn.putBytes(input.getBuffer(), input.getOffset(), (int) fragSize);
            inputOff += fragSize;
            input.setOffset(inputOff);
        }

        // get xid
        int off = toReturn.getOffset();
        toReturn.setOffset(0);
        int xid = toReturn.getInt();
        toReturn.setXid(xid);
        toReturn.setOffset(off);

        return toReturn;
    }
124744
private function removeNonMappedPages()
    {
        /** @var PageInterface[] $staticPages */
        $staticPages = $this->pageRepository->findBy(['static' => true], ['left' => 'DESC']);
        foreach ($staticPages as $page) {
            if (null === $this->findRouteDefinitionByRouteName($page->getRoute())) {
                $this->outputPageAction($page->getName(), 'removed');
                $this->pageOperator->delete($page);
            }
        }
    }
949285
def remove_mapping(agent, prefix, ip):
    """"""
    return _broadcast(agent, RemoveMappingManager,
                      RecordType.record_A, prefix, ip)
302292
function unregister() {
      for (var p = d.wrapper.parentNode; p && p != document.body; p = p.parentNode) {}
      if (p) setTimeout(unregister, 5000);
      else off(window, "resize", onResize);
    }
344117
public function clearPagePaths()
    {
        $em = Database::connection()->getEntityManager();
        $paths = $this->getPagePaths();
        foreach ($paths as $path) {
            $em->remove($path);
        }
        $em->flush();
    }
502000
private void removeUseless() {
    Set<Map.Entry<String, PropertyNode>> entries = _children.entrySet();
    for (Iterator<Map.Entry<String, PropertyNode>> it = entries.iterator(); it.hasNext(); ) {
      Map.Entry<String, PropertyNode> entry = it.next();
      PropertyNode child = entry.getValue();
      child.removeUseless();
      if (child.isUseless()) {
        it.remove();
      }
    }
  }
801648
def unlink(self, definition, doc1, doc2) :
        ""
        links = self.database[definition].fetchByExample( {"_from": doc1._id,"_to" : doc2._id}, batchSize = 100)
        for l in links :
            self.deleteEdge(l)
230936
private PDDocument removeText(PDPage page) throws IOException {

        PDFStreamParser parser = new PDFStreamParser(page);
        parser.parse();
        List<Object> tokens = parser.getTokens();
        List<Object> newTokens = new ArrayList<>();
        for (Object token : tokens) {
            if (token instanceof Operator) {
                Operator op = (Operator) token;
                if (op.getName().equals("TJ") || op.getName().equals("Tj")) {
                    //remove the one argument to this operator
                    newTokens.remove(newTokens.size() - 1);
                    continue;
                }
            }
            newTokens.add(token);
        }

        PDDocument document = new PDDocument();
        document.addPage(page);

        PDStream newContents = new PDStream(document);
        OutputStream out = newContents.createOutputStream(COSName.FLATE_DECODE);
        ContentStreamWriter writer = new ContentStreamWriter(out);
        writer.writeTokens(newTokens);
        out.close();
        page.setContents(newContents);

        return document;

    }
809872
@Override
	public SqlContextFactory removeQueryAutoParameterBinder(final Consumer<SqlContext> binder) {
		queryAutoParameterBinders.remove(binder);
		queryAutoParameterBinder = queryAutoParameterBinders.stream().reduce((first, second) -> first.andThen(second))
				.orElse(null);
		return this;
	}
577900
public void remove()
  {
    if (tc.isEntryEnabled()) 
      SibTr.entry(tc, "remove");
    
    browserIterator.remove();
    
    if (tc.isEntryEnabled()) 
      SibTr.exit(tc, "remove");
  }
272663
def _forget_page(self, page):
        """"""
        pid = id(page)
        if pid in self._page_refs:
            self._page_refs[pid] = None
1099304
protected void removeBy(BaseCell data) {
        VirtualLayoutManager layoutManager = getLayoutManager();
        if (data != null && mGroupBasicAdapter != null && layoutManager != null) {
            int removePosition = mGroupBasicAdapter.getPositionByItem(data);
            if (removePosition >= 0) {
                int cardIdx = mGroupBasicAdapter.findCardIdxFor(removePosition);
                Card card = mGroupBasicAdapter.getCardRange(cardIdx).second;
                card.removeCellSilently(data);
                List<LayoutHelper> layoutHelpers = layoutManager.getLayoutHelpers();
                LayoutHelper emptyLayoutHelper = null;
                if (layoutHelpers != null && cardIdx >= 0 && cardIdx < layoutHelpers.size()) {
                    for (int i = 0, size = layoutHelpers.size(); i < size; i++) {
                        LayoutHelper layoutHelper = layoutHelpers.get(i);
                        int start = layoutHelper.getRange().getLower();
                        int end = layoutHelper.getRange().getUpper();
                        if (end < removePosition) {
                            //do nothing
                        } else if (start <= removePosition && removePosition <= end) {
                            int itemCount = layoutHelper.getItemCount() - 1;
                            if (itemCount > 0) {
                                layoutHelper.setItemCount(itemCount);
                                layoutHelper.setRange(start, end - 1);
                            } else {
                                emptyLayoutHelper = layoutHelper;
                            }
                        } else if (removePosition < start) {
                            layoutHelper.setRange(start - 1, end - 1);
                        }
                    }
                    if (emptyLayoutHelper != null) {
                        final List<LayoutHelper> newLayoutHelpers = new LinkedList<>(layoutHelpers);
                        newLayoutHelpers.remove(emptyLayoutHelper);
                        layoutManager.setLayoutHelpers(newLayoutHelpers);
                    }
                    mGroupBasicAdapter.removeComponent(data);
                }
            }
        }
    }
395238
def limit_page page = nil, options = {}
      if page.is_a?( Hash )
        options = page
      else
        options[:page] = page.to_i
      end

      options[:page] = options[:page].to_i > 0 ? options[:page] : DataMapper::Paginator.default[:page]
      options[:limit] = options[:limit].to_i || DataMapper::Paginator.default[:limit]
      options[:offset] = options[:limit] * ( options[:page] - 1 )
      options[:order] = options[:order] || DataMapper::Paginator.default[:order]
      limit options
    end