Examples of Document

• aQute.bnd.properties.Document
• buhi.Document
  @author HP
• ca.carleton.gcrc.couch.app.Document
• com.CompPad.model.Document
  This is a class for managing a "CompPad" document which is the thing that the expressions are attached to. @author brenda
• com.allanbank.mongodb.bson.Document
• com.aspose.words.Document
• com.bluetangstudio.searchcloud.client.model.Document
  The basic storage unit in Search Cloud.
• com.btaz.datautil.xml.model.Document
  The Document builder class has two major purposes: - make it easy to build a model from XmlStax parser events - make it easy to build a model for unit test purposes User: msundell
• com.btaz.util.reader.xml.model.Document
  The Document builder class has two major purposes: - make it easy to build a model from XmlStax parser events - make it easy to build a model for unit test purposes User: msundell
• com.denimgroup.threadfix.data.entities.Document
• com.digitalpebble.classification.Document
• com.dotcms.repackage.org.apache.lucene.document.Document
• com.dotcms.repackage.org.dom4j.Document
• com.dotcms.repackage.org.jdom.Document
• com.dotcms.repackage.org.jsoup.nodes.Document
• com.dotcms.repackage.org.w3c.dom.Document
• com.eibus.xml.nom.Document
• com.facebook.swift.parser.model.Document
• com.filenet.api.core.Document
  Stub interface to allow the connector to build fully.
• com.flaptor.indextank.index.Document
• com.flaptor.indextank.rpc.Document
• com.fourspaces.couchdb.Document
  Everything in CouchDB is a Document. In this case, the document is an object backed by a JSONObject. The Document is also aware of the database that it is connected to. This allows the Document to reload it's properties when needed. The only special fields are "_id", "_rev", "_revisions", and "_view_*".

  All document have an _id and a _rev. If this is a new document those fields are populated when they are saved to the CouchDB server.

  _revisions is only populated if the document has been retrieved via database.getDocumentWithRevisions(); So, if this document wasn't, then when you call document.getRevisions(), it will go back to the server to reload itself via database.getDocumentWithRevisions().

  The Document can be treated like a JSONObject, eventhough it doesn't extend JSONObject (it's final).

  You can also get/set values by calling document.get(key), document.put(key,value), just like a Map.

  You can get a handle on the backing JSONObject by calling document.getJSONObject(); If this hasn't been loaded yet, it will load the data itself using the given database connection.

  If you got this Document from a view, you are likely missing elements. To load them you can call document.load(). @author mbreese

• com.gcrm.domain.Document
• com.github.sommeri.less4j.core.ast.Document
• com.google.appengine.api.search.Document
• com.google.code.mojo.license.document.Document
  Date: 16-Feb-2008
  Author: Mathieu Carbou (mathieu.carbou@gmail.com)
• com.google.collide.shared.document.Document
  Document model for the code editor. The document is modeled using a linked list of lines. (This allows for very fast line insertions and still good performance for other common editor operations.) During a text change, listeners will be called in this order:

  • {@link Anchor.ShiftListener}
  • {@link Anchor.RemoveListener}
  • {@link LineCountListener}
  • {@link LineListener}
  • {@link TextListener}
• com.google.enterprise.connector.spi.Document
  rt(prop != null); doSomething(prop); } @since 1.0
• com.google.gwt.dom.client.Document
  A Document is the root of the HTML hierarchy and holds the entire content. Besides providing access to the hierarchy, it also provides some convenience methods for accessing certain sets of information from the document.
• com.google.gwt.xml.client.Document
  Document objects represent XML documents. Each Document can contain exactly one Element node, and any number of other node types.
• com.haulmont.yarg.formatters.impl.xlsx.Document
• com.hp.hpl.sparta.Document
  An XML Document.

  Copyright (C) 2002 Hewlett-Packard Company. This file is part of Sparta, an XML Parser, DOM, and XPath library. This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

  @see GNU Lesser General Public License @version $Date: 2003/11/01 05:42:18 $ $Revision: 1.12 $ @author Eamonn O'Brien-Strain @see org.w3c.dom.Document
• com.intellij.openapi.editor.Document
  Represents the contents of a text file loaded into memory, and possibly opened in an IDEA text editor. Line breaks in the document text are always normalized as single \n characters, and are converted to proper format when the document is saved. @see Editor#getDocument() @see com.intellij.psi.PsiDocumentManager @see com.intellij.openapi.fileEditor.FileDocumentManager @see EditorFactory#createDocument(CharSequence)
• com.intersys.gds.Document
  Document is the main GDS building block. It wraps a HashMap as a Document object. Key value is always a String, while values can be of arbitrary types currently supported by the GDS engine. On the database side, a Document is always stored in a serialized form. GDS uses ValueList to serialize Java objects. key is the DocumentMap key which uniquely identifies a Document. For example, the following "Person" Document, given here as a JSON string: { "name" : "John Smith" , "dob" : "12-10-1975", "ssn" : "105-01-9843" } will be stored as a single global node: ^Person(key)=$LB("John Smith","12-10-1975","105-01-9843"). Document key values are not stored along with the data (values). Schema is captured in ^Schema global, while indices are stored in ^Index global. In both cases, globals are subscripted by the Document name. For example, Person Document schema would be stored in ^Schema("Person") and Person indices would be stored in ^Index("Person").
• com.itedge.solutionmanager.domain.impl.Document
• com.itextpdf.text.Document
  tion of the document with a certain size and certain margins Document document = new Document(PageSize.A4, 50, 50, 50, 50); try { // creation of the different writers HtmlWriter.getInstance(document , System.out); PdfWriter.getInstance(document , new FileOutputStream("text.pdf")); // we add some meta information to the document document.addAuthor("Bruno Lowagie"); document.addSubject("This is the result of a Test."); // we open the document for writing document.open(); document.add(new Paragraph("Hello world")); } catch(DocumentException de) { System.err.println(de.getMessage()); } document.close();
• com.jagpdf.Document
• com.jgaap.util.Document
  Code for storing and processing individual documents of any type.
• com.liferay.portal.kernel.search.Document
• com.liferay.portal.kernel.xml.Document
• com.lightcrafts.ui.editor.Document
  A Document is the public face of an image editor. It ties together an image, an engine which processes it, and an editor component for user interaction. It provides access to various pieces of package-private functionality to interact with application context, such as save/restore, undo/redo, frames, menus, printing and export.
• com.lowagie.text.Document
  tion of the document with a certain size and certain margins Document document = new Document(PageSize.A4, 50, 50, 50, 50); try { // creation of the different writers HtmlWriter.getInstance(document , System.out); PdfWriter.getInstance(document , new FileOutputStream("text.pdf")); // we add some meta information to the document document.addAuthor("Bruno Lowagie"); document.addSubject("This is the result of a Test."); // we open the document for writing document.open(); document.add(new Paragraph("Hello world")); } catch(DocumentException de) { System.err.println(de.getMessage()); } document.close();
• com.mozilla.grouperfish.model.Document
  Simple multi-field text document. Each document has at least id and (full) text.
• com.nanolaba.surtur.core.Document
  $Revision: 1 $ $Author: andriishin $ $Date: 2011-01-09 11:49:06 -0600 (Sun, 09 Jan 2011) $
• com.openkm.ws.client.Document
• com.projity.document.Document
• com.secondstack.training.spring.extjs.domain.Document
  Created with IntelliJ IDEA. User: Adrian Date: 10/01/13 Time: 14:39 To change this template use File | Settings | File Templates.
• com.stoyanr.todo.model.Document
• com.testdomain.Document
• com.volantis.mcs.dom.Document

  Warning: This is a facade provided for use by user code, not for implementation by user code. User implementations of this interface are highly likely to be incompatible with future releases of the product at both binary and source levels.

  @mock.generate
• com.wesabe.grendel.entities.Document
  A document with an abritrary body, stored as an encrypted+signed OpenPGP message. @author coda
• de.ailis.jollada.model.Document
  COLLADA document. @author Klaus Reimer (k@ailis.de)
• de.filiadata.lucene.spider.generated.msoffice2000.word.Document
• de.micromata.opengis.kml.v_2_2_0.Document

  ...

  A Document is a container for features and styles. This element is required if your KML file uses shared styles. It is recommended that you use shared styles, which require the following steps:

  Define all Styles in a Document. Assign a unique ID to each Style. Within a given Feature or StyleMap, reference the Style's ID using a element.

  Do not put shared styles within a Folder.

  Each Feature must explicitly reference the styles it uses in a element. For a Style that applies to a Document (such as ListStyle), the Document itself must explicitly reference the . For example:

  Note that shared styles are not inherited by the Features in the Document.

  The following example illustrates use of a shared style.

  Syntax:

  <Document id="ID"> <!-- inherited from Feature element --> <name>...</name>                      <!-- string --> <visibility>1</visibility>            <!-- boolean --> <open>0</open>                        <!-- boolean --> <atom:author>...<atom:author>         <!-- xmlns:atom --> <atom:link>...</atom:link>            <!-- xmlns:atom --> <address>...</address>                <!-- string --> <xal:AddressDetails>...</xal:AddressDetails>  <!-- xmlns:xal -->
    <phoneNumber>...</phoneNumber>        <!-- string -->
    <Snippet maxLines="2">...</Snippet>   <!-- string --> <description>...</description>        <!-- string --> <AbstractView>...</AbstractView>      <!-- Camera or LookAt --> <TimePrimitive>...</TimePrimitive> <styleUrl>...</styleUrl>              <!-- anyURI --> <StyleSelector>...</StyleSelector> <Region>...</Region> <Metadata>...</Metadata>              <!-- deprecated in KML 2.2 --> <ExtendedData>...</ExtendedData>      <!-- new in KML 2.2 --> <!-- specific to Document --> <!-- 0 or more Schema elements --> <!-- 0 or more Feature elements --> </Document>

  Extends: @see : Contains: @see : @see : @see :
• de.pdark.decentxml.Document
• de.sciss.app.Document
  The Document interface is an attempt to create common classes and interfaces (the package de.sciss.app) which can be shared by different programmes, such as Meloncillo or FScape, without having to make adjustments in different places each time a modification is made. This interface describes the most prominent methods needed for a general application document. @author Hanns Holger Rutz @version 0.11, 24-Jun-06
• de.xanders.data.system.dao.Document
• domain.Document
• edu.harvard.hul.ois.jhove.Document
• edu.pitt.dbmi.nlp.noble.coder.model.Document
  This class represents an object that represents an input document @author tseytlin
• edu.stanford.nlp.dcoref.Document
• edu.ucla.sspace.text.Document
  An abstraction for a document that allows document processors to access text in a uniform manner.
• electric.xml.Document
• elemental.dom.Document
  oper.mozilla.org/en/Using_the_W3C_DOM_Level_1_Core">DOM tree, including elements such as <body> and <table> ) and provides functionality global to the document (such as obtaining the page's URL and creating new elements in the document).

  A document object can be obtained from various APIs:

  • Most commonly, you work with the document the script is running in by using document in document's scripts. (The same document can also be referred to as window.document.)
  • The document of an iframe via the iframe's contentDocument property.
  • The responseXML of an XMLHttpRequest object.
  • The document, that given node or element belongs to, can be retrieved using the node's ownerDocument property.
  • ...and more.

  Depending on the kind of the document (e.g. HTML or XML) different APIs may be available on the document object. This theoretical availability of APIs is usually described in terms of implementing interfaces defined in the relevant W3C DOM specifications:

  • All document objects implement the DOM Core Document and Node interfaces, meaning that the "core" properties and methods are available for all kinds of documents.
  • In addition to the generalized DOM Core document interface, HTML documents also implement the HTMLDocument interface, which is a more specialized interface for dealing with HTML documents (e.g., document.cookie, document.alinkColor).
  • XUL documents (available to Mozilla add-on and application developers) implement their own additions to the core Document functionality.

  Methods or properties listed here that are part of a more specialized interface have an asterisk (*) next to them and have additional information in the  Availability column.

  Note that some APIs listed below are not available in all browsers for various reasons:

  • Obsolete: on its way of being removed from supporting browsers.
  • Non-standard: either an experimental feature not (yet?) agreed upon by all vendors, or a feature targeted specifically at the code running in a specific browser (e.g. Mozilla has a few DOM APIs created for its add-ons and application development).
  • Part of a completed or an emerging standard, but not (yet?) implemented in all browsers or implemented in the newest versions of the browsers.

  Detailed browser compatibility tables are located at the pages describing each property or method.

• elemental.html.Document
• es.ipsa.atril.doc.user.Document
• fi.luomus.commons.xml.Document
  Document used with XMLWriter and XMLReader. Contains root node. @see Node
• galoot.types.Document
• gate.Document
• hu.jokeman.xparser.cldc11.document.nodes.Document
• hu.jokeman.xparser.impl.document.nodes.Document
• it.eng.spagobi.engines.documentcomposition.configuration.DocumentCompositionConfiguration.Document
• it.unimi.di.big.mg4j.document.Document
• it.unimi.dsi.mg4j.document.Document
  An indexable document.

  Instance of this class represent a single document. Documents provide access to possibly several fields, which represent units of information that should be indexed separately.

  Each field is accessible by a call to {@link #content(int)}. Note, however, that unless specified otherwise field content must be accessed in increasing order. You can skip some field, but the contract of this class does not require that you can access fields in random order (although implementations may provide this feature). Moreover, the data provided by a call to {@link #content(int)} (e.g., a {@link java.io.Reader} for {@link it.unimi.dsi.mg4j.document.DocumentFactory.FieldType#TEXT TEXT} fields) may become invalidat the next call (similarly to the behaviour of {@link it.unimi.dsi.mg4j.document.DocumentCollection#document(int)}). The same holds for {@link #wordReader(int)}.

  After obtaining a document, it is your responsibility to {@linkplain java.io.Closeable#close() close} it.

  It is advisable, although not strictly required, that documents have a toString() equal to their title.

• javax.swing.text.Document
  nicode.org/">unicode characters. The sequence of characters displayed in a text component is generally referred to as the component's content.

  To refer to locations within the sequence, the coordinates used are the location between two characters. As the diagram below shows, a location in a text document can be referred to as a position, or an offset. This position is zero-based.

  

  In the example, if the content of a document is the sequence "The quick brown fox," as shown in the preceding diagram, the location just before the word "The" is 0, and the location after the word "The" and before the whitespace that follows it is 3. The entire sequence of characters in the sequence "The" is called a range.

  The following methods give access to the character data that makes up the content.

  • {@link #getLength()}
  • {@link #getText(int,int)}
  • {@link #getText(int,int,javax.swing.text.Segment)}

  Structure

  Text is rarely represented simply as featureless content. Rather, text typically has some sort of structure associated with it. Exactly what structure is modeled is up to a particular Document implementation. It might be as simple as no structure (i.e. a simple text field), or it might be something like diagram below.

  

  The unit of structure (i.e. a node of the tree) is referred to by the Element interface. Each Element can be tagged with a set of attributes. These attributes (name/value pairs) are defined by the AttributeSet interface.

  The following methods give access to the document structure.

  • {@link #getDefaultRootElement()}
  • {@link #getRootElements()}

  Mutations

  All documents need to be able to add and remove simple text. Typically, text is inserted and removed via gestures from a keyboard or a mouse. What effect the insertion or removal has upon the document structure is entirely up to the implementation of the document.

  The following methods are related to mutation of the document content:

  • {@link #insertString(int,java.lang.String,javax.swing.text.AttributeSet)}
  • {@link #remove(int,int)}
  • {@link #createPosition(int)}

  Notification

  Mutations to the Document must be communicated to interested observers. The notification of change follows the event model guidelines that are specified for JavaBeans. In the JavaBeans event model, once an event notification is dispatched, all listeners must be notified before any further mutations occur to the source of the event. Further, order of delivery is not guaranteed.

  Notification is provided as two separate events, DocumentEvent, and UndoableEditEvent. If a mutation is made to a Document through its api, a DocumentEvent will be sent to all of the registered DocumentListeners. If the Document implementation supports undo/redo capabilities, an UndoableEditEvent will be sent to all of the registered UndoableEditListeners. If an undoable edit is undone, a DocumentEvent should be fired from the Document to indicate it has changed again. In this case however, there should be no UndoableEditEvent generated since that edit is actually the source of the change rather than a mutation to the Document made through its api.

  

  Referring to the above diagram, suppose that the component shown on the left mutates the document object represented by the blue rectangle. The document responds by dispatching a DocumentEvent to both component views and sends an UndoableEditEvent to the listening logic, which maintains a history buffer.

  Now suppose that the component shown on the right mutates the same document. Again, the document dispatches a DocumentEvent to both component views and sends an UndoableEditEvent to the listening logic that is maintaining the history buffer.

  If the history buffer is then rolled back (i.e. the last UndoableEdit undone), a DocumentEvent is sent to both views, causing both of them to reflect the undone mutation to the document (that is, the removal of the right component's mutation). If the history buffer again rolls back another change, another DocumentEvent is sent to both views, causing them to reflect the undone mutation to the document -- that is, the removal of the left component's mutation.

  The methods related to observing mutations to the document are:

  • addDocumentListener(DocumentListener)
  • removeDocumentListener(DocumentListener)
  • addUndoableEditListener(UndoableEditListener)
  • removeUndoableEditListener(UndoableEditListener)

  Properties

  Document implementations will generally have some set of properties associated with them at runtime. Two well known properties are the StreamDescriptionProperty, which can be used to describe where the Document came from, and the TitleProperty, which can be used to name the Document. The methods related to the properties are:

  • {@link #getProperty(java.lang.Object)}
  • {@link #putProperty(java.lang.Object,java.lang.Object)}

  For more information on the Document class, see The Swing Connection and most particularly the article, The Element Interface. @author Timothy Prinzing @see javax.swing.event.DocumentEvent @see javax.swing.event.DocumentListener @see javax.swing.event.UndoableEditEvent @see javax.swing.event.UndoableEditListener @see Element @see Position @see AttributeSet

• jease.cms.domain.Document
  A File which allows to extract the content as plain text and is therefore indexable for full text search.
• jodd.lagarto.dom.Document
  Document node is always a root node. Holds various DOM-related configuration and information.
• kameleon.document.Document
  Represents the document with all its information.

  A document consists of a list of paragraphs and document properties. The paragraphs are stored in the same order as the would appear in a normal document. @author Fromentin Xavier, Schnell Michaël, Dervin Cyrielle, Brabant Quentin @version 1.0 @see ElementPropertiesDefaultNames

• ketUI.Document
  The top-level model of a collection of equations including associated graphical user interface components, methods to load and save documents as well as to initialize such documents.
• list.Document
• lotus.domino.Document
• lupos.rif.model.Document
• mf.org.w3c.dom.Document
  3.org/TR/2004/REC-DOM-Level-3-Core-20040407'>Document Object Model (DOM) Level 3 Core Specification.
• name.pehl.totoe.xml.client.Document
  The Document interface represents the entire XML document. Conceptually, it is the root of the document tree, and provides the primary access to the document's data. @author $Author$ @version $Date$ $Revision: 78$
• net.csdn.mongo.Document
  User: WilliamZhu Date: 12-10-16 Time: 下午8:11

  The +Document+ class is the Parent Class of All MongoDB model, this means any MongoDB model class should extends this class.

  Once your class extends Document,you get all ODM(Object Data Mapping ) and +net.csdn.mongo.Criteria+ (A convenient DSL) power.

  Example setup:

  ```java public class Person extends Document{ static{ storeIn("persons") } } ```

• net.fortytwo.twitlogic.persistence.beans.Document
  two.net).
• net.sf.clairv.index.document.Document
  A document is an indexable record. @author qiuyin
• net.sf.jhylafax.fax.Document
  Representation of a document.
• net.sf.jpluck.jxl.Document
• net.sf.jpluck.plucker.Document
• net.sourceforge.ganttproject.document.Document
  This interface abstracts the details of file access. Implementations of this interface provide methods to open streams to a project file, indepent of storage location (filesystem / WebDAV). @author Michael Haeusler (michael at akatose.de)
• net.stinfoservices.pacifiq.server.model.Document
  Represents a Document. @author STI
• net.yacy.document.Document
• nu.validator.saxtree.Document
  A document. @version $Id$ @author hsivonen
• nu.xom.Document

  The Document class represents a complete XML document including its root element, prolog, and epilog.

  @author Elliotte Rusty Harold @version 1.1b5
• org.adoptopenjdk.lambda.tutorial.exercise4.Document
• org.amdatu.search.Document
• org.apache.abdera.model.Document

  The top level artifact of the Feed Object Model. The Parser component processes data from an InputStream and returns a Document instance. The type of Document returned depends on the XML format being parsed. The Feed Object Model supports four basic types of documents: FeedDocument, EntryDocument, ServiceDocument (Atom Publishing Protocol Introspection Documents) and XmlDocument (any arbitrary XML).

• org.apache.accumulo.examples.wikisearch.sample.Document
• org.apache.camel.component.salesforce.dto.generated.Document
  Salesforce DTO for SObject Document
• org.apache.chemistry.opencmis.client.api.Document
  CMIS Document.

  Domain Model 2.4

• org.apache.chemistry.opencmis.inmemory.storedobj.api.Document
  A document is a concrete object (meaning it can be stored) and has content. It also has a path (is contained in a parent folder) @author Jens
• org.apache.ctakes.ytex.uima.model.Document
  Mapped to document table. Contains document text (from JCas.getDocumentText()). Contains gzipped xmi CAS. @author vijay
• org.apache.ecs.Document
  This class creates a Document container, for convience. @version $Id: Document.java,v 1.7 2000/04/10 16:59:19 jonbolt Exp $ @author Stephan Nagy @author Jon S. Stevens
• org.apache.fop.afp.modca.Document
  The document is the highest level of the MO:DCA data-stream document component hierarchy. Documents can be made up of pages, and the pages, which are at the intermediate level, can be made up of objects. Objects are at the lowest level, and can be bar codes, graphics, images, and presentation text. At each level of the hierarchy certain sets of MO:DCA data structures, called structured fields, are permissible. The document, pages and objects are bounded by structured fields that define their beginnings and their ends. These structured fields, called begin-end pairs, provide an envelope for the data-stream components. This feature enables a processor of the data stream that is not fully compliant with the architecture to bypass those objects that are beyond its scope, and to process the data stream to the best of its abilities. A presentation document is one that has been formatted and is intended for presentation, usually on a printer or display device. A data stream containing a presentation document should produce the same document content in the same format on different printers or display devices dependent, however, on the capabilities of each of the printers or display devices. A presentation document can reference resources that are to be included as part of the document to be presented.
• org.apache.jackrabbit.ocm.testmodel.auto.Document
• org.apache.jackrabbit.ocm.testmodel.interfaces.Document
• org.apache.jackrabbit.vault.util.diff.Document
  A document represents a list of elements and have a source.
• org.apache.jetspeed.om.page.Document

  Document

  @author Scott T. Weaver @version $Id: Document.java 551606 2007-06-28 16:07:53Z taylor $
• org.apache.lenya.cms.publication.Document
  A CMS document.
• org.apache.lucene.document.Document
  Documents are the unit of indexing and search. A Document is a set of fields. Each field has a name and a textual value. A field may be {@link Fieldable#isStored() stored} with the document, in whichcase it is returned with search hits on the document. Thus each document should typically contain one or more stored fields which uniquely identify it.

  Note that fields which are not {@link Fieldable#isStored() stored} arenot available in documents retrieved from the index, e.g. with {@link ScoreDoc#doc}, {@link Searcher#doc(int)} or {@link IndexReader#document(int)}.

• org.apache.metamodel.data.Document
  Represents a document, ie. an object to be turned into a {@link Row} using a{@link DocumentConverter} and to be sourced by a {@link DocumentSource}. A document does not require any schema. A document will hold key/value pairs where keys are always strings, but values may be arbitrary values.
• org.apache.pivot.wtk.text.Document
  Node representing the root of an element hierarchy.
• org.apache.poi.hslf.record.Document
  Master container for Document. There is one of these for every slideshow, and it holds lots of definitions, and some summaries. @author Nick Burch
• org.apache.rat.api.Document
• org.apache.tapestry.dom.Document
  The root node of a DOM.
• org.apache.tapestry5.dom.Document
  The root node of a DOM.
• org.apache.tuscany.sca.domain.search.impl.Document
  @version $Rev: 804871 $ $Date: 2009-08-16 23:24:15 -0700 (Sun, 16 Aug 2009) $
• org.apache.type_test.types1.Document
  3.org/2001/XMLSchema>string"> <attribute name="ID" type="{http://www.w3.org/2001/XMLSchema}string" /> </extension> </simpleContent> </complexType>
• org.asciidoctor.ast.Document
• org.brain.pojos.Document
  Document entity. @author MyEclipse Persistence Tools
• org.carrot2.core.Document
  A document that to be processed by the framework. Each document is a collection of fields carrying different bits of information, e.g. {@link #TITLE} or{@link #CONTENT_URL}.
• org.codehaus.preon.el.Document
  The interface implemented by objects receiving the human-readable representation of an {@link Expression}. @author Wilfred Springer
• org.docx4j.wml.Document
  3.org/2001/XMLSchema}anyType"> <sequence> <element name="background" type="{http://schemas.openxmlformats.org/wordprocessingml/2006/main}CT_Background" minOccurs="0"/> <element ref="{http://schemas.openxmlformats.org/wordprocessingml/2006/main}body" minOccurs="0"/> </sequence> <attribute ref="{http://schemas.openxmlformats.org/markup-compatibility/2006}Ignorable"/> </restriction> </complexContent> </complexType>
• org.dom4j.Document

  Document defines an XML Document.

  @author James Strachan @version $Revision: 1.14 $
• org.eaxy.Document
• org.eclipse.jface.text.Document
  Default document implementation. Uses a {@link org.eclipse.jface.text.GapTextStore} wrappedinside a {@link org.eclipse.jface.text.CopyOnWriteTextStore} as text store.

  The used line tracker considers the following strings as line delimiters: "\n", "\r", "\r\n". In case of a text replacement across line delimiter boundaries and with different line delimiters, the line tracker might have to be repaired. Use {@link #isLineInformationRepairNeeded(int,int,String)} before doing the text replace if youhave the need to discover such a situation.

  The document is ready to use. It has a default position category for which a default position updater is installed.

  Performance: The implementation should perform reasonably well for typical source code documents. It is not designed for very large documents of a size of several megabytes. Space-saving implementations are initially used for both the text store and the line tracker; the first modification after a {@link #set(String) set} incurs the cost to transform thedocument structures to efficiently handle updates.

  See {@link GapTextStore} and TreeLineTracker for algorithmic behavior of the useddocument structures.

  @see org.eclipse.jface.text.GapTextStore @see org.eclipse.jface.text.CopyOnWriteTextStore
• org.eclipse.xtext.xdoc.xdoc.Document
  A representation of the model object 'Document'.

  The following features are supported:

  • {@link org.eclipse.xtext.xdoc.xdoc.Document#getSubtitle Subtitle}
  • {@link org.eclipse.xtext.xdoc.xdoc.Document#getAuthors Authors}
  • {@link org.eclipse.xtext.xdoc.xdoc.Document#getChapters Chapters}
  • {@link org.eclipse.xtext.xdoc.xdoc.Document#getLangDefs Lang Defs}
  • {@link org.eclipse.xtext.xdoc.xdoc.Document#getGlossary Glossary}
  • {@link org.eclipse.xtext.xdoc.xdoc.Document#getParts Parts}

  @see org.eclipse.xtext.xdoc.xdoc.XdocPackage#getDocument() @model @generated
• org.elasticsearch.index.mapper.ParseContext.Document
• org.galagosearch.core.parse.Document
• org.geomajas.plugin.printing.document.Document
  A renderable document. @author Jan De Moerloose
• org.hibernate.ogm.datastore.couchdb.dialect.backend.json.impl.Document
  Every Json document in CouchDB contains, The field '_id' representing the id of the document and '_rev' representing the revision number of the document @author Andrea Boriero <dreborier@gmail.com>
• org.hibernate.search.test.Document
• org.hibernate.test.instrument.domain.Document
  @author Gavin King
• org.icepdf.core.pobjects.Document
• org.infinispan.loaders.jpa.entity.Document
  @author Ray Tsang
• org.infinispan.schematic.document.Document
  Primary read-only interface for an in-memory representation of JSON/BSON objects. @author Randall Hauch (C) 2011 Red Hat Inc. @since 5.1
• org.infoset.xml.Document
• org.internna.iwebmvc.model.Document
  Class to represent an uploaded document. @author Jose Noheda @since 1.0
• org.internna.iwebmvc.model.core.Document
• org.jboss.arquillian.graphene.page.document.Document
  The JavaScript document object and its methods @author Lukas Fryc
• org.jdom.Document
  An XML document. Methods allow access to the root element as well as the {@link DocType} and other document-level information. @version $Revision: 1.85 $, $Date: 2007/11/10 05:28:58 $ @author Brett McLaughlin @author Jason Hunter @author Jools Enticknap @author Bradley S. Huffman
• org.jdom2.Document
  @author Lucian Chirita (lucianc@users.sourceforge.net) @version $Id: Document.java 3030 2009-08-27 11:12:48Z teodord $
• org.jsoup.nodes.Document
  A HTML Document. @author Jonathan Hedley, jonathan@hedley.net
• org.kapott.hbci.sepa.jaxb.pain_001_001_02.Document
  3.org/2001/XMLSchema}anyType"> <sequence> <element name="pain.001.001.02" type="{urn:sepade:xsd:pain.001.001.02}pain.001.001.02"/> </sequence> </restriction> </complexContent> </complexType>
• org.kapott.hbci.sepa.jaxb.pain_001_002_02.Document
  3.org/2001/XMLSchema}anyType"> <sequence> <element name="pain.001.001.02" type="{urn:swift:xsd:$pain.001.002.02}pain.001.001.02"/> </sequence> </restriction> </complexContent> </complexType>
• org.kapott.hbci.sepa.jaxb.pain_001_002_03.Document
  3.org/2001/XMLSchema}anyType"> <sequence> <element name="CstmrCdtTrfInitn" type="{urn:iso:std:iso:20022:tech:xsd:pain.001.002.03}CustomerCreditTransferInitiationV03"/> </sequence> </restriction> </complexContent> </complexType>
• org.kapott.hbci.sepa.jaxb.pain_001_003_03.Document
  3.org/2001/XMLSchema}anyType"> <sequence> <element name="CstmrCdtTrfInitn" type="{urn:iso:std:iso:20022:tech:xsd:pain.001.003.03}CustomerCreditTransferInitiationV03"/> </sequence> </restriction> </complexContent> </complexType>
• org.kapott.hbci.sepa.jaxb.pain_008_001_01.Document
  3.org/2001/XMLSchema}anyType"> <sequence> <element name="pain.008.001.01" type="{urn:sepade:xsd:pain.008.001.01}pain.008.001.01"/> </sequence> </restriction> </complexContent> </complexType>
• org.kapott.hbci.sepa.jaxb.pain_008_002_01.Document
  3.org/2001/XMLSchema}anyType"> <sequence> <element name="pain.008.001.01" type="{urn:swift:xsd:$pain.008.002.01}pain.008.001.01"/> </sequence> </restriction> </complexContent> </complexType>
• org.kapott.hbci.sepa.jaxb.pain_008_002_02.Document
  3.org/2001/XMLSchema}anyType"> <sequence> <element name="CstmrDrctDbtInitn" type="{urn:iso:std:iso:20022:tech:xsd:pain.008.002.02}CustomerDirectDebitInitiationV02"/> </sequence> </restriction> </complexContent> </complexType>
• org.kapott.hbci.sepa.jaxb.pain_008_003_02.Document
  3.org/2001/XMLSchema}anyType"> <sequence> <element name="CstmrDrctDbtInitn" type="{urn:iso:std:iso:20022:tech:xsd:pain.008.003.02}CustomerDirectDebitInitiationV02"/> </sequence> </restriction> </complexContent> </complexType>
• org.kuali.rice.krad.document.Document
• org.kxml2.kdom.Document
  The document consists of some legacy events and a single root element. This class basically adds some consistency checks to Node.
• org.lilystudio.smarty4j.statement.Document
  文档语句，它表示整个文档节点树的根节点。 @version 1.0.0, 2010/10/01 @author 欧阳先伟 @since Smarty 1.0
• org.mifosplatform.infrastructure.documentmanagement.domain.Document
• org.mongodb.Document
• org.mybatis.generator.api.dom.xml.Document
  @author Jeff Butler
• org.nexml.model.Document
• org.objectweb.type_test.types1.Document
  @author Lucian Chirita (lucianc@users.sourceforge.net) @version $Id: Document.java 3030 2009-08-27 11:12:48Z teodord $
• org.odftoolkit.simple.Document
  This abstract class is representing one of the possible ODF documents
• org.openbel.framework.common.model.Document
  }

  @author Anthony Bargnesi {@code }
• org.openntf.domino.Document
  The Interface Document.
• org.openoffice.gdocs.util.Document
• org.openoffice.xmerge.Document

  A Document represents any Document to be converted and the resulting Document from any conversion.

  It is created by the PluginFactory object's {@link org.openoffice.xmerge.PluginFactory#createOfficeDocument createOfficeDocument} method or the {@link org.openoffice.xmerge.PluginFactory#createDeviceDocument createDeviceDocument} method.

  @author Herbie Ong @see org.openoffice.xmerge.PluginFactory
• org.osm.jsoup.nodes.Document
• org.outerj.daisy.repository.Document
• org.pdfclown.documents.Document
  fanochizzolini.it) @version 0.1.0
• org.pentaho.ui.xul.dom.Document
• org.primefaces.cookbook.model.chapter8.Document
  Document @author Oleg Varaksin / last modified by $Author: $ @version $Revision: 1.0 $
• org.springframework.data.elasticsearch.annotations.Document
• org.springframework.data.mongodb.core.mapping.Document
• org.springmodules.examples.workflow.osworkflow.model.Document
  @author robh
• org.spw.model.Document
  Entity class Document @author PSe
• org.stringtree.http.Document
• org.structr.rest.serialization.html.Document
  @author Christian Morgner
• org.tautua.markdownpapers.ast.Document
• org.terrier.indexing.Document
  This interface encapsulates the concept of a document during indexing. Implementors of this interface as responsible for parsing and tokenising a document (eg parse the HTML tags, output the text terms found). @author Craig Macdonald, Vassilis Plachouras
• org.thrudb.thrudex.Document
• org.thymeleaf.dom.Document
  @author Daniel Fernández @since 2.0.0
• org.w3c.dom.Document
  The Document interface represents the entire HTML or XML document. Conceptually, it is the root of the document tree, and provides the primary access to the document's data.

  Since elements, text nodes, comments, processing instructions, etc. cannot exist outside the context of a Document , the Document interface also contains the factory methods needed to create these objects. The Node objects created have a ownerDocument attribute which associates them with the Document within whose context they were created.

• org.waveprotocol.wave.model.document.Document
  A mutable view of a wave document. A document comprises a DOM-style tree of nodes, which are elements with attributes or text, and key-value annotation pairs over ranges of those nodes. Locations within the document are given by integer offsets or {@code Point}s, referencing a space between two nodes. Unlike traditional DOMs, the node types are not mutable objects; all mutations are applied through this interface. The node types are represented by the vacuous {@code Doc.E} for elements,{@code Doc.T} for text nodes, and {@code Doc.N} for both. These are typeparameters to {@link MutableDocument}, which is the Generic version of this interface. @see MutableDocument @see ReadableAnnotationSet @author danilatos@google.com (Daniel Danilatos)
• org.xapian.Document
• org.zkoss.idom.Document
  Represents Document which is also W3C/DOM's document, ie, org.w3c.dom.Document. @author tomyeh @see Element
• pivot.wtk.text.Document
  Node representing the root of an element hierarchy. @author gbrown
• project.entities.documents.Document
• split.srx.Document
• test.wsdl.interop3.compound1.xsd.Document
• uk.ac.cam.ha293.tweetlabel.types.Document
• uk.ac.osswatch.simal.model.jena.Document
• uk.ac.ucl.panda.utility.structure.Document
  Documents are the unit of indexing and search. A Document is a set of fields. Each field has a name and a textual value. A field may be {@link Fieldable#isStored() stored} with the document, in whichcase it is returned with search hits on the document. Thus each document should typically contain one or more stored fields which uniquely identify it.

  Note that fields which are not {@link Fieldable#isStored() stored} arenot available in documents retrieved from the index, e.g. with {@link Hits#doc(int)}, {@link Searcher#doc(int)} or {@link IndexReader#document(int)}.

• utn.frsf.gabinete.fw.generator.html.Document
• versusSNP.Document

Examples of uk.ac.ucl.panda.utility.structure.Document

Examples of utn.frsf.gabinete.fw.generator.html.Document

Examples of versusSNP.Document