Example #1
0
 @Override
 public int compareTo(Document that, boolean enforceFieldOrder) {
   if (that == null) return 1;
   if (this.size() != that.size()) {
     return this.size() - that.size();
   }
   int diff = 0;
   if (enforceFieldOrder) {
     Iterator<CharSequence> thisIter = this.keySet().iterator(); // ordered
     Iterator<CharSequence> thatIter = that.keySet().iterator(); // ordered
     while (thisIter.hasNext() && thatIter.hasNext()) {
       String thisKey = thisIter.next().toString();
       String thatKey = thatIter.next().toString();
       diff = thisKey.compareTo(thatKey);
       if (diff != 0) return diff;
       diff = compare(this.get(thisKey), that.get(thatKey));
       if (diff != 0) return diff;
     }
     if (thisIter.hasNext()) return 1;
     if (thatIter.hasNext()) return -1;
   } else {
     // We don't care about order, so just go through by this Document's fields ...
     for (Map.Entry<CharSequence, Value> entry : fields.entrySet()) {
       CharSequence key = entry.getKey();
       diff = compare(this.get(key), that.get(key));
       if (diff != 0) return diff;
     }
     if (that.size() > this.size()) return 1;
   }
   return 0;
 }
Example #2
0
  public int compare(Document doc1, Document doc2) {
    for (DocumentComparatorOrderBy orderBy : _columns) {
      String value1 = doc1.get(orderBy.getName());
      String value2 = doc2.get(orderBy.getName());

      if (!orderBy.isAsc()) {
        String temp = value1;

        value1 = value2;
        value2 = temp;
      }

      int result = 0;

      if ((value1 != null) && (value2 != null)) {
        if (orderBy.isCaseSensitive()) {
          result = value1.compareTo(value2);
        } else {
          result = value1.compareToIgnoreCase(value2);
        }
      }

      if (result != 0) {
        return result;
      }
    }

    return 0;
  }
  /** Tests Element.is() and Element.as(). */
  public void testIsAndAs() {
    assertTrue(Node.is(Document.get()));

    JavaScriptObject text = Document.get().createTextNode("foo");
    assertTrue(Node.is(text));

    // Node.is(null) is allowed and should return false.
    assertFalse(Node.is(null));
  }
Example #4
0
  private void runQuery() {
    boolean inc = true;
    Document documentIn = null, documentOut = null;
    Set<String> queryKeys = query.getKeys();
    Set<String> projectionKeys = projection.getKeys();
    Iterator<Document> it = collection.documents.iterator();

    while (it.hasNext()) {
      inc = true;
      documentIn = it.next();

      for (String key : queryKeys)
        if (!documentIn.containsKey(key) || !documentIn.get(key).equals(query.get(key))) {
          inc = false;
          break;
        }

      if (!inc) continue;

      documentOut = documentIn;

      for (String key : projectionKeys) {
        if (documentOut.containsKey(key)) {
          System.out.println("projKey: (" + key.getClass() + ") " + key);
          System.out.println(
              "projVal: (" + projection.get(key).getClass() + ") " + projection.get(key));
          if ((projection.get(key) instanceof Long && (Long) projection.get(key) == 0)
              || (projection.get(key) instanceof Boolean && (Boolean) projection.get(key) == false))
            documentOut.remove(key);
        }
      }
      documents.add(documentOut);
    }
  }
  /** childNodes, hasChildNodes. */
  public void testChildNodeList() {
    Document doc = Document.get();
    BodyElement body = doc.getBody();

    // <div>foo<button/>bar</div>
    DivElement div = doc.createDivElement();
    Text txt0 = doc.createTextNode("foo");
    ButtonElement btn0 = doc.createButtonElement();
    Text txt1 = doc.createTextNode("bar");

    body.appendChild(div);
    div.appendChild(txt0);
    div.appendChild(btn0);
    div.appendChild(txt1);

    NodeList<Node> children = div.getChildNodes();
    assertEquals(3, children.getLength());
    assertEquals(txt0, children.getItem(0));
    assertEquals(btn0, children.getItem(1));
    assertEquals(txt1, children.getItem(2));

    assertEquals(3, div.getChildCount());
    assertEquals(txt0, div.getChild(0));
    assertEquals(btn0, div.getChild(1));
    assertEquals(txt1, div.getChild(2));

    assertFalse(txt0.hasChildNodes());
    assertTrue(div.hasChildNodes());
  }
  /** setAttribute, getAttribute, hasAttributes, hasAttribute. */
  public void testAttributes() {
    Document doc = Document.get();
    DivElement div = doc.createDivElement();

    div.setAttribute("id", "myId");
    assertEquals("myId", div.getAttribute("id"));
  }
Example #7
0
  public void addItems(Iterable<TItemInput> items, boolean top) {
    TableSectionElement tbody = Document.get().createTBodyElement();
    for (TItemInput item : items) tbody.appendChild(codec_.getRowForItem(item));
    if (top) addToTop(tbody);
    else getElement().appendChild(tbody);

    codec_.onRowsChanged(tbody);
  }
Example #8
0
 public static Video wrap(VideoElement e) {
   assert Document.get().getBody().isOrHasChild(e);
   Video v = new Video(e);
   v.maybeInitMediaEvents();
   // The two lines below seems to be good practice to avoid memory leaks...
   v.onAttach();
   RootPanel.detachOnWindowClose(v);
   return v;
 }
  /** nodeType. */
  public void testNodeType() {
    Document doc = Document.get();
    DivElement div = doc.createDivElement();
    Text txt0 = doc.createTextNode("foo");

    assertEquals(Node.DOCUMENT_NODE, doc.getNodeType());
    assertEquals(Node.ELEMENT_NODE, div.getNodeType());
    assertEquals(Node.TEXT_NODE, txt0.getNodeType());
  }
Example #10
0
  public S screenCenter() {
    int width = this.outerWidth();
    int height = this.outerHeight();

    int left = (Window.getClientWidth() - width) >> 1;
    int top = (Window.getClientHeight() - height) >> 1;

    int computedLeft =
        Math.max(Window.getScrollLeft() + left, 0) - Document.get().getBodyOffsetLeft();
    int computedTop = Math.max(Window.getScrollTop() + top, 0) - Document.get().getBodyOffsetTop();

    Element element = this.getElement();
    element.getStyle().setPropertyPx("left", computedLeft);
    element.getStyle().setPropertyPx("top", computedTop);
    element.getStyle().setPosition(Position.ABSOLUTE);

    return (S) this;
  }
 private HeadElement getHead() {
   if (head == null) {
     Element elt = Document.get().getElementsByTagName("head").getItem(0);
     assert elt != null
         : "The host HTML page does not have a <head> element"
             + " which is required by StyleInjector";
     head = HeadElement.as(elt);
   }
   return head;
 }
 private void printHits(PrintWriter out, ScoreDoc[] hits, IndexSearcher searcher)
     throws IOException {
   out.println(hits.length + " total results\n");
   for (int i = 0; i < hits.length; i++) {
     if (i < 10 || (i > 94 && i < 105)) {
       Document d = searcher.doc(hits[i].doc);
       out.println(i + " " + d.get(ID_FIELD));
     }
   }
 }
 private void checkHits(ScoreDoc[] hits, int expectedCount, IndexSearcher searcher)
     throws IOException {
   assertEquals("total results", expectedCount, hits.length);
   for (int i = 0; i < hits.length; i++) {
     if (i < 10 || (i > 94 && i < 105)) {
       Document d = searcher.doc(hits[i].doc);
       assertEquals("check " + i, String.valueOf(i), d.get(ID_FIELD));
     }
   }
 }
  /** nodeName, nodeValue. */
  public void testNodeNameAndValue() {
    Document doc = Document.get();
    DivElement div = doc.createDivElement();
    Text txt0 = doc.createTextNode("foo");

    assertEquals("div", div.getNodeName().toLowerCase());

    assertEquals("foo", txt0.getNodeValue());
    txt0.setNodeValue("bar");
    assertEquals("bar", txt0.getNodeValue());
  }
  /** appendChild, insertBefore, removeChild, replaceChild. */
  public void testAppendRemoveReplace() {
    Document doc = Document.get();
    BodyElement body = doc.getBody();

    // <div>foo<button/>bar</div>
    DivElement div = doc.createDivElement();
    Text txt0 = doc.createTextNode("foo");
    ButtonElement btn0 = doc.createButtonElement();
    Text txt1 = doc.createTextNode("bar");

    body.appendChild(div);
    div.appendChild(txt0);
    div.appendChild(btn0);
    div.appendChild(txt1);

    // appendChild, insertBefore
    ButtonElement btn1 = doc.createButtonElement();

    // <div>foo<btn0/>bar<btn1/></div>
    div.appendChild(btn1);
    assertEquals(btn1, div.getLastChild());

    // <div>foo<button/>bar<button/></div>
    div.insertBefore(btn1, txt1);
    assertEquals(4, div.getChildNodes().getLength());
    assertEquals(btn1, div.getChildNodes().getItem(2));

    // removeChild
    // <div>foo<btn0/>bar</div> (back to original)
    div.removeChild(btn1);
    assertEquals(3, div.getChildNodes().getLength());

    // replaceChild
    // <div>foo<btn1/>bar</div>
    div.replaceChild(btn1, btn0);
    assertEquals(btn1, txt0.getNextSibling());
    assertEquals(btn1, txt1.getPreviousSibling());

    // insertAfter
    // <div>foo<btn1/><btn0/>bar</div>
    div.insertAfter(btn0, btn1);
    assertEquals(btn0, btn1.getNextSibling());

    // insertFirst
    // <div><btn1/>foo<btn0/>bar</div>
    div.insertFirst(btn1);
    assertEquals(btn1, div.getFirstChild());

    // removeFromParent
    // <div>foo<btn0/>bar</div>
    btn1.removeFromParent();
    assertNull(btn1.getParentElement());
    assertEquals(txt0, div.getFirstChild());
  }
Example #16
0
 @Override
 public int compareToUsingSimilarFields(Document that) {
   if (that == null) return 1;
   int diff = 0;
   // We don't care about order, so just go through by this Document's fields ...
   for (Map.Entry<CharSequence, Value> entry : fields.entrySet()) {
     CharSequence key = entry.getKey();
     diff = compareNonNull(this.get(key), that.get(key));
     if (diff != 0) return diff;
   }
   return 0;
 }
  private static String _getSearchEngineId(Document document) {
    String entryClassName = document.get("entryClassName");

    Indexer indexer = IndexerRegistryUtil.getIndexer(entryClassName);

    String searchEngineId = indexer.getSearchEngineId();

    if (_log.isDebugEnabled()) {
      _log.debug("Search engine ID for " + indexer.getClass() + " is " + searchEngineId);
    }

    return searchEngineId;
  }
  /** getParentElement. */
  public void testGetParentDoesntCycle() {
    Element element = Document.get().getBody();
    int i = 0;
    while (i < 10 && element != null) {
      element = element.getParentElement();
      i++;
    }

    // If we got here we looped "forever" or passed, as no exception was thrown.
    if (i == 10) {
      fail("Cyclic parent structure detected.");
    }

    // If we get here, we pass, because we encountered no errors going to the
    // top of the parent hierarchy.
  }
Example #19
0
  public FastSelectTable(
      ItemCodec<TItemInput, TItemOutput, TItemOutput2> codec,
      String selectedClassName,
      boolean focusable,
      boolean allowMultiSelect) {
    codec_ = codec;
    selectedClassName_ = selectedClassName;
    allowMultiSelect_ = allowMultiSelect;

    table_ = Document.get().createTableElement();
    if (focusable) table_.setTabIndex(0);
    table_.setCellPadding(0);
    table_.setCellSpacing(0);
    table_.setBorder(0);
    table_.getStyle().setCursor(Cursor.DEFAULT);
    setElement(table_);

    addMouseDownHandler(
        new MouseDownHandler() {
          public void onMouseDown(MouseDownEvent event) {
            if (event.getNativeButton() != NativeEvent.BUTTON_LEFT) return;

            event.preventDefault();

            NativeWindow.get().focus();
            DomUtils.setActive(getElement());

            Element cell = getEventTargetCell((Event) event.getNativeEvent());
            if (cell == null) return;
            TableRowElement row = (TableRowElement) cell.getParentElement();
            if (codec_.isValueRow(row)) handleRowClick(event, row);
          }
        });
    addClickHandler(
        new ClickHandler() {
          public void onClick(ClickEvent event) {
            event.preventDefault();
          }
        });

    addKeyDownHandler(
        new KeyDownHandler() {
          public void onKeyDown(KeyDownEvent event) {
            handleKeyDown(event);
          }
        });
  }
Example #20
0
 private void write(String key, Document document, DocumentType type, ValueList valueList) {
   Set<String> keySet = type.types.keySet();
   for (String keyName : keySet) {
     ElementType elType = type.types.get(keyName);
     Object value = document.get(keyName);
     if (value == null) {
       valueList.append((String) null);
       continue;
     }
     if (elType.isBasicType()) {
       valueList.append(value);
       // for now only datatypes can be indexed
       indexMap = allIndices.get(keyName);
       if (indexMap != null) {
         setIndex(keyName, value, key);
       }
     } else if ((elType.type == ElementType.TYPE_REFERENCE)
         || (elType.type == ElementType.TYPE_REFERENCE_ARRAY)) {
       String dbid =
           writeReference(
               key, (Document) value, elType.nestedType, elType.reference, elType.referenceKey);
       valueList.append(dbid);
     } else if (value instanceof Document) {
       writeDocument(key, (Document) value, elType.nestedType, valueList, scratchList);
     } else if (value instanceof Document[]) {
       scratchList.clear();
       writeList.clear();
       for (int j = 0; j < ((Document[]) value).length; j++) {
         writeDocument(key, ((Document[]) value)[j], elType.nestedType, scratchList, writeList);
       }
       valueList.append(scratchList);
     } else if (elType.type == ElementType.TYPE_STRING_ARRAY) {
       writeStringArray((String[]) value);
     } else if ((elType.type == ElementType.TYPE_INTEGER_ARRAY)
         || (elType.type == ElementType.TYPE_INTEGER_WRAPPER_ARRAY)) {
       writeIntArray(value, elType.type);
     } else if ((elType.type == ElementType.TYPE_LONG_ARRAY)
         || (elType.type == ElementType.TYPE_LONG_WRAPPER_ARRAY)) {
       writeLongArray(value, elType.type);
     } else if ((elType.type == ElementType.TYPE_DOUBLE_ARRAY)
         || (elType.type == ElementType.TYPE_DOUBLE_WRAPPER_ARRAY)) {
       writeDoubleArray(value, elType.type);
     } else { // if (type == ElementType.TYPE_BACK_REFERENCE) {
       valueList.append(value);
     }
   }
 }
Example #21
0
 private String writeReference(
     String key, Document document, DocumentType type, String reference, String refKey) {
   String referenceKey = document.get(refKey).toString();
   NodeReference refGlobal = getReferenceGlobal(reference);
   refGlobal.appendSubscript(referenceKey);
   if (refGlobal.exists()) {
     return referenceKey;
   }
   referenceTempList.clear();
   NodeReference oldIndexGlobal = indexGlobal;
   indexGlobal = getIndexGlobal(reference);
   write(key, document, type, referenceTempList);
   // document.setDBID(name,key);
   indexGlobal = oldIndexGlobal;
   refGlobal.set(referenceTempList);
   return referenceKey; // document.getDBID();
 }
  /** hasParentElement, getParentElement. */
  public void testNodeParentElement() {
    Document doc = Document.get();
    BodyElement body = doc.getBody();
    DivElement div = doc.createDivElement();
    Text text = doc.createTextNode("foo");

    // An unattached node should have no parent element.
    assertFalse(text.hasParentElement());
    assertFalse(div.hasParentElement());
    assertNull(text.getParentElement());
    assertNull(div.getParentElement());

    // Test attached cases.
    body.appendChild(div);
    div.appendChild(text);
    assertTrue(div.hasParentElement());
    assertTrue(text.hasParentElement());
    assertEquals(body, div.getParentElement());
    assertEquals(div, text.getParentElement());
  }
  /** ownerDocument. */
  @DoNotRunWith(Platform.HtmlUnitBug)
  public void testOwnerDocument() {
    Document doc = Document.get();
    BodyElement body = doc.getBody();

    // <div>foo<button/>bar</div>
    DivElement div = doc.createDivElement();
    Text txt0 = doc.createTextNode("foo");
    ButtonElement btn0 = doc.createButtonElement();
    Text txt1 = doc.createTextNode("bar");

    body.appendChild(div);
    div.appendChild(txt0);
    div.appendChild(btn0);
    div.appendChild(txt1);

    // ownerDocument
    assertEquals(doc, div.getOwnerDocument());
    assertEquals(doc, txt0.getOwnerDocument());
  }
  /** isOrHasChild. */
  public void testIsOrHasChild() {
    Document doc = Document.get();
    DivElement div = doc.createDivElement();
    DivElement childDiv = doc.createDivElement();
    Text text = doc.createTextNode("foo");

    assertFalse(div.isOrHasChild(childDiv));
    assertFalse(div.isOrHasChild(text));
    assertFalse(childDiv.isOrHasChild(text));

    assertTrue(div.isOrHasChild(div));
    assertTrue(text.isOrHasChild(text));

    div.appendChild(childDiv);
    childDiv.appendChild(text);
    assertTrue(div.isOrHasChild(childDiv));
    assertTrue(div.isOrHasChild(text));

    assertFalse(childDiv.isOrHasChild(div));
    assertFalse(text.isOrHasChild(childDiv));
    assertFalse(text.isOrHasChild(div));

    BodyElement body = doc.getBody();
    body.appendChild(div);
    assertTrue(body.isOrHasChild(body));
    assertTrue(body.isOrHasChild(div));
    assertTrue(body.isOrHasChild(childDiv));
    assertTrue(body.isOrHasChild(text));

    assertTrue(div.isOrHasChild(div));
    assertTrue(div.isOrHasChild(childDiv));
    assertTrue(div.isOrHasChild(text));

    assertFalse(childDiv.isOrHasChild(div));
    assertFalse(text.isOrHasChild(div));
  }
  /** getParentNode, firstChild, lastChild, nextSibling, previousSibling. */
  public void testParentAndSiblings() {
    Document doc = Document.get();
    BodyElement body = doc.getBody();

    // <div>foo<button/>bar</div>
    DivElement div = doc.createDivElement();
    Text txt0 = doc.createTextNode("foo");
    ButtonElement btn0 = doc.createButtonElement();
    Text txt1 = doc.createTextNode("bar");

    body.appendChild(div);
    div.appendChild(txt0);
    div.appendChild(btn0);
    div.appendChild(txt1);

    assertEquals(div, btn0.getParentNode());

    assertEquals(txt0, div.getFirstChild());
    assertEquals(txt1, div.getLastChild());
    assertEquals(btn0, txt0.getNextSibling());
    assertEquals(btn0, txt1.getPreviousSibling());
    assertEquals(null, txt0.getPreviousSibling());
    assertEquals(null, txt1.getNextSibling());
  }
 private StyleElement createElement(String contents) {
   StyleElement style = Document.get().createStyleElement();
   style.setPropertyString("language", "text/css");
   setContents(style, contents);
   return style;
 }
  // private static int[] oldToNew(IndexReader reader, Searcher searcher) throws IOException {
  private static DocScore[] newToOld(IndexReader reader, Searcher searcher) throws IOException {
    int readerMax = reader.maxDoc();
    DocScore[] newToOld = new DocScore[readerMax];

    // use site, an indexed, un-tokenized field to get boost
    // byte[] boosts = reader.norms("site"); TODO MC
    /* TODO MC */
    Document docMeta;
    Pattern includes = Pattern.compile("\\|");
    String value = NutchConfiguration.create().get(INCLUDE_EXTENSIONS_KEY, "");
    String includeExtensions[] = includes.split(value);
    Hashtable<String, Boolean> validExtensions = new Hashtable<String, Boolean>();
    for (int i = 0; i < includeExtensions.length; i++) {
      validExtensions.put(includeExtensions[i], true);
      System.out.println("extension boosted " + includeExtensions[i]);
    }
    /* TODO MC */

    for (int oldDoc = 0; oldDoc < readerMax; oldDoc++) {
      float score;
      if (reader.isDeleted(oldDoc)) {
        // score = 0.0f;
        score = -1f; // TODO MC
      } else {
        // score = Similarity.decodeNorm(boosts[oldDoc]); TODO MC
        /* TODO MC */
        docMeta = searcher.doc(oldDoc);
        if (validExtensions.get(docMeta.get("subType"))
            == null) { // searched extensions will have higher scores
          score = -0.5f;
        } else {
          score = Integer.parseInt(docMeta.get("inlinks"));
          /*
          if (score==0) {
          	score=0.001f; // TODO MC - to not erase
          }
          */
        }
        /* TODO MC */
        // System.out.println("Score for old document "+oldDoc+" is "+score+" and type
        // "+docMeta.get("subType")); // TODO MC debug remove
      }
      DocScore docScore = new DocScore();
      docScore.doc = oldDoc;
      docScore.score = score;
      newToOld[oldDoc] = docScore;
    }

    System.out.println("Sorting " + newToOld.length + " documents.");
    Arrays.sort(newToOld);
    // HeapSorter.sort(newToOld); // TODO MC - due to the lack of space

    /* TODO MC
    int[] oldToNew = new int[readerMax];
    for (int newDoc = 0; newDoc < readerMax; newDoc++) {
      DocScore docScore = newToOld[newDoc];
      //oldToNew[docScore.oldDoc] = docScore.score > 0.0f ? newDoc : -1; // TODO MC
      oldToNew[docScore.oldDoc] = newDoc; // TODO MC
    }
    */

    /* TODO MC *
    for (int newDoc = 0; newDoc < readerMax; newDoc++) {
    	DocScore docScore = newToOld[newDoc];
    	System.out.println("Score for new document "+newDoc+" is "+docScore.score); // TODO MC debug remove
    }
    * TODO MC */

    // return oldToNew; TODO MC
    return newToOld; // TODO MC
  }
Example #28
0
 public boolean accept(Object object) {
   Document doc = (Document) object;
   return (Float.parseFloat(doc.get(EARQ.fScore)) >= scoreLimit);
 }
  public void testBinaryFieldInIndex() throws Exception {
    Fieldable binaryFldStored =
        new Field("binaryStored", binaryValStored.getBytes(), Field.Store.YES);
    Fieldable binaryFldCompressed =
        new Field("binaryCompressed", binaryValCompressed.getBytes(), Field.Store.COMPRESS);
    Fieldable stringFldStored =
        new Field(
            "stringStored", binaryValStored, Field.Store.YES, Field.Index.NO, Field.TermVector.NO);
    Fieldable stringFldCompressed =
        new Field(
            "stringCompressed",
            binaryValCompressed,
            Field.Store.COMPRESS,
            Field.Index.NO,
            Field.TermVector.NO);

    try {
      // binary fields with store off are not allowed
      new Field("fail", binaryValCompressed.getBytes(), Field.Store.NO);
      fail();
    } catch (IllegalArgumentException iae) {;
    }

    Document doc = new Document();

    doc.add(binaryFldStored);
    doc.add(binaryFldCompressed);

    doc.add(stringFldStored);
    doc.add(stringFldCompressed);

    /** test for field count */
    assertEquals(4, doc.fields.size());

    /** add the doc to a ram index */
    RAMDirectory dir = new RAMDirectory();
    IndexWriter writer =
        new IndexWriter(dir, new StandardAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
    writer.addDocument(doc);
    writer.close();

    /** open a reader and fetch the document */
    IndexReader reader = IndexReader.open(dir);
    Document docFromReader = reader.document(0);
    assertTrue(docFromReader != null);

    /** fetch the binary stored field and compare it's content with the original one */
    String binaryFldStoredTest = new String(docFromReader.getBinaryValue("binaryStored"));
    assertTrue(binaryFldStoredTest.equals(binaryValStored));

    /** fetch the binary compressed field and compare it's content with the original one */
    String binaryFldCompressedTest = new String(docFromReader.getBinaryValue("binaryCompressed"));
    assertTrue(binaryFldCompressedTest.equals(binaryValCompressed));

    /** fetch the string field and compare it's content with the original one */
    String stringFldStoredTest = docFromReader.get("stringStored");
    assertTrue(stringFldStoredTest.equals(binaryValStored));

    /** fetch the compressed string field and compare it's content with the original one */
    String stringFldCompressedTest = docFromReader.get("stringCompressed");
    assertTrue(stringFldCompressedTest.equals(binaryValCompressed));

    /** delete the document from index */
    reader.deleteDocument(0);
    assertEquals(0, reader.numDocs());

    reader.close();
  }
Example #30
0
 public void click() {
   NativeEvent clickEvent =
       Document.get().createClickEvent(1, 0, 0, 0, 0, false, false, false, false);
   DomEvent.fireNativeEvent(clickEvent, hasHandlers_);
 }