Uses of Interface
org.crosswire.jsword.passage.Key

Packages that use Key
org.crosswire.bibledesktop.book This package contains Swing MVC models to help implementing a Swing GUI using JSword classes. 
org.crosswire.bibledesktop.desktop The desktop is the main screen of Bible Desktop. 
org.crosswire.bibledesktop.display This package contains the BookDataDisplay interface which is designed to allow GUI components to choose between the methods they use to display BookData objects. 
org.crosswire.bibledesktop.display.basic This package provides the actual display of BookData. 
org.crosswire.bibledesktop.passage This package contains Swing MVC models to help displaying passages. 
org.crosswire.jsword.book The Book package provides an interface to a real store of data. 
org.crosswire.jsword.book.basic The Basic package contains default and abstract implementations of the main Book classes. 
org.crosswire.jsword.book.filter This data package manages the filtering of book data returned by the various books. 
org.crosswire.jsword.book.filter.gbf A Filter that converts from GBF format data to OSIS format data. 
org.crosswire.jsword.book.filter.osis A Filter that loads OSIS format data into JDOM. 
org.crosswire.jsword.book.filter.plaintext A Filter that converts from plain text format data to OSIS format data. 
org.crosswire.jsword.book.filter.thml A Filter that converts from THML format data to OSIS format data. 
org.crosswire.jsword.book.readings An implementation of BookDriver and Dictionary that read provide access to readings planners. 
org.crosswire.jsword.book.sword An implementation of the Book interfaces that reads from SWORD project books (modules). 
org.crosswire.jsword.book.sword.processing Interface and default implementation for the transformation of raw text into XML. 
org.crosswire.jsword.bridge Command line programs to do useful things. 
org.crosswire.jsword.examples Some examples of how to use the JSword API. 
org.crosswire.jsword.index Abstraction of an Index. 
org.crosswire.jsword.index.lucene An implementation of an Index using Lucene. 
org.crosswire.jsword.index.query The Query package provides JSword with the ability to construct a search request against an Index. 
org.crosswire.jsword.index.search This package helps implementors of the various Book interfaces implement search. 
org.crosswire.jsword.passage The core responsibility of the passage package is to store and collate information about the structure of the Bible - The most important classes are Passage, PassageTally and Strongs
 

Uses of Key in org.crosswire.bibledesktop.book
 

Fields in org.crosswire.bibledesktop.book declared as Key
protected  Key DisplaySelectPane.key
          The current passage.
private  Key DisplaySelectEvent.key
          The new passage
 

Methods in org.crosswire.bibledesktop.book that return Key
 Key MultiBookPane.getKey()
           
 Key DisplaySelectEvent.getKey()
          Get the type of command
 Key BibleViewPane.getKey()
          Accessor for the current passage
 

Methods in org.crosswire.bibledesktop.book with parameters of type Key
private  void BibleViewPane.saveKey(Key key)
          Do the real work of saving to a file
 void MultiBookPane.setBookData(Book[] books, Key key)
           
 void MultiBookPane.setKey(Key key)
          Accessor for the current passage
 void DisplaySelectPane.setKey(Key newKey)
          Set the key
 void BibleViewPane.setKey(Key key)
          Accessor for the current passage
 

Constructors in org.crosswire.bibledesktop.book with parameters of type Key
DisplaySelectEvent(BookProvider source, Key key)
          For when a command has been made
 

Uses of Key in org.crosswire.bibledesktop.desktop
 

Constructors in org.crosswire.bibledesktop.desktop with parameters of type Key
ViewSourcePane(Book[] books, Key key)
           
 

Uses of Key in org.crosswire.bibledesktop.display
 

Methods in org.crosswire.bibledesktop.display that return Key
 Key ProxyBookDataDisplay.getKey()
           
 Key BookDataDisplay.getKey()
          The Book Key that we are displaying, or null if we are not displaying anything
 

Methods in org.crosswire.bibledesktop.display with parameters of type Key
 void ProxyBookDataDisplay.setBookData(Book[] books, Key key)
           
 void BookDataDisplay.setBookData(Book[] books, Key key)
          Set the BookData to be displayed.
 

Uses of Key in org.crosswire.bibledesktop.display.basic
 

Methods in org.crosswire.bibledesktop.display.basic that return Key
 Key TextPaneBookDataDisplay.getKey()
           
 Key TabbedBookDataDisplay.getKey()
           
 Key SplitBookDataDisplay.getKey()
           
 

Methods in org.crosswire.bibledesktop.display.basic with parameters of type Key
private static String TabbedBookDataDisplay.getTabName(Key key)
          Ensure that the tab names are not too long - 25 chars max
 void TextPaneBookDataDisplay.setBookData(Book[] books, Key key)
           
 void TabbedBookDataDisplay.setBookData(Book[] books, Key newkey)
           
 void SplitBookDataDisplay.setBookData(Book[] books, Key key)
          Set the books and/or key to display.
 

Uses of Key in org.crosswire.bibledesktop.passage
 

Fields in org.crosswire.bibledesktop.passage declared as Key
private  Key KeyTreeNode.key
           
private  Key KeyTreeModel.key
          The key that this tree is displaying.
private  Key KeySidebar.key
          The whole key that we are viewing
private  Key KeyChangeEvent.key
          The new key
private  Key KeyListListModel.keys
           
private  Key KeySidebar.partial
          The key that is selected
 

Fields in org.crosswire.bibledesktop.passage with type parameters of type Key
private  List<Key> RangeListModel.ranges
          The list of ranges in the passage.
 

Methods in org.crosswire.bibledesktop.passage that return Key
 Key KeyTreeNode.getKey()
          Accessor for the key
 Key KeyTreeModel.getKey()
          What key is this tree editing
 Key KeySidebar.getKey()
           
 Key KeyChangeEvent.getKey()
          Get the key with its changes
 

Methods in org.crosswire.bibledesktop.passage that return types with arguments of type Key
 Enumeration<Key> KeyTreeNode.children()
           
 

Methods in org.crosswire.bibledesktop.passage with parameters of type Key
 void KeyTreeModel.setKey(Key key)
          Sets the key is this tree editing
private  void KeySidebar.setKey(Key newKey)
           
 

Constructors in org.crosswire.bibledesktop.passage with parameters of type Key
KeyChangeEvent(Object source, Key key)
          For when a key has been changed
KeyListListModel(Key keys)
          Constructor for ListListModel.
KeyTreeModel(Key key)
          Simple ctor
KeyTreeNode(Key key, TreeNode parent)
          Simple ctor
 

Uses of Key in org.crosswire.jsword.book
 

Fields in org.crosswire.jsword.book declared as Key
private  Key BookData.key
          What key was used to create this data
 

Methods in org.crosswire.jsword.book that return Key
 Key Book.createEmptyKeyList()
          Fetch an empty Key to which we can add Keys.
 Key Book.find(SearchRequest request)
          Retrieval: For a given search spec find a list of references to it.
 Key Book.find(String request)
          Retrieval: For a given search spec find a list of references to it.
 Key Book.getGlobalKeyList()
          Get a complete list of index entries.
 Key BookData.getKey()
          The key used to obtain data from one or more books.
 Key Book.getKey(String name)
          Someone has typed in a reference to find, but we need a Key to actually look it up.
 Key Book.getValidKey(String name)
          Get a Key for the name, if possible.
 

Methods in org.crosswire.jsword.book with parameters of type Key
 boolean Book.contains(Key key)
          Returns true if this book contains the specified element.
 Iterator<org.jdom2.Content> Book.getOsisIterator(Key key, boolean allowEmpty)
          Return an iterator that returns each key's OSIS in turn.
 String Book.getRawText(Key key)
          Returns the raw text that getData(Key key) builds into OSIS.
static void DataPolice.report(Book book, Key key, String message)
          Report a message against the current book and key.
 void Book.setAliasKey(Key alias, Key source)
          Store an alias of one key to another.
 void Book.setRawText(Key key, String rawData)
          Store the raw text for the given key.
 

Constructors in org.crosswire.jsword.book with parameters of type Key
BookData(Book[] books, Key key, boolean compare)
          Create BookData for multiple books.
BookData(Book book, Key key)
          Ctor
 

Uses of Key in org.crosswire.jsword.book.basic
 

Methods in org.crosswire.jsword.book.basic that return Key
 Key AbstractPassageBook.createEmptyKeyList()
           
 Key AbstractBook.find(SearchRequest request)
           
 Key AbstractBook.find(String request)
           
 Key AbstractPassageBook.getKey(String text)
           
 Key AbstractPassageBook.getValidKey(String name)
           
 

Methods in org.crosswire.jsword.book.basic with parameters of type Key
 void AbstractPassageBook.addOSIS(Key key, org.jdom2.Element div, List<org.jdom2.Content> osisContent)
          Add the OSIS elements to the div element.
 void AbstractPassageBook.addOSIS(Key key, List<org.jdom2.Content> content, List<org.jdom2.Content> osisContent)
          Add the OSIS elements to the content list.
protected abstract  List<org.jdom2.Content> AbstractBook.getOsis(Key key, RawTextToXmlProcessor noOpRawTextProcessor)
           
 Iterator<org.jdom2.Content> AbstractPassageBook.getOsisIterator(Key key, boolean allowEmpty)
           
 void AbstractPassageBook.setDocument(Key key, BookData bdata)
          For when we want to add writing functionality.
 

Uses of Key in org.crosswire.jsword.book.filter
 

Methods in org.crosswire.jsword.book.filter with parameters of type Key
 List<org.jdom2.Content> Filter.toOSIS(Book book, Key key, String plain)
          Converter from plain (encoded) text to OSIS data
 

Uses of Key in org.crosswire.jsword.book.filter.gbf
 

Methods in org.crosswire.jsword.book.filter.gbf with parameters of type Key
static Tag GBFTagBuilders.getTag(Book book, Key key, String name)
           
private  List<Tag> GBFFilter.parseTags(Book book, Key key, String aRemains)
          Turn the string into a list of tags in the order that they appear in the original string.
 List<org.jdom2.Content> GBFFilter.toOSIS(Book book, Key key, String plain)
           
 void Tag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> osisStack)
          Sub-classes should implement this method to generate OSIS Object
 void GBFTags.DefaultEndTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.BoldStartTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.CrossRefStartTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.EOLTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.FootnoteStartTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.FootnoteEndTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.HeaderStartTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.IgnoredTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.ItalicStartTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.JustifyRightTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.JustifyLeftTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.OTQuoteStartTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.ParagraphTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.PoetryStartTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.PsalmStartTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.RedLetterStartTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.StrongsMorphTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.StrongsWordTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.TextFootnoteTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.TextTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.TitleStartTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 void GBFTags.UnderlineStartTag.updateOsisStack(Book book, Key key, LinkedList<org.jdom2.Content> stack)
           
 

Uses of Key in org.crosswire.jsword.book.filter.osis
 

Methods in org.crosswire.jsword.book.filter.osis with parameters of type Key
private  org.jdom2.Element OSISFilter.cleanTags(Book book, Key key, String plain)
           
 List<org.jdom2.Content> OSISFilter.toOSIS(Book book, Key key, String plain)
           
 

Uses of Key in org.crosswire.jsword.book.filter.plaintext
 

Methods in org.crosswire.jsword.book.filter.plaintext with parameters of type Key
 List<org.jdom2.Content> PlainTextFilter.toOSIS(Book book, Key key, String plain)
           
 

Uses of Key in org.crosswire.jsword.book.filter.thml
 

Fields in org.crosswire.jsword.book.filter.thml declared as Key
private  Key CustomHandler.key
          The book being parsed.
 

Methods in org.crosswire.jsword.book.filter.thml with parameters of type Key
private  org.jdom2.Element THMLFilter.cleanParse(Book book, Key key, String plain)
           
private  org.jdom2.Element THMLFilter.cleanTags(Book book, Key key, String plain)
           
private  org.jdom2.Element THMLFilter.cleanText(Book book, Key key, String plain)
           
private  org.jdom2.Element THMLFilter.parse(Book book, Key key, String plain, String failMessage)
           
 void Tag.processContent(Book book, Key key, org.jdom2.Element ele)
          Do additional processing of the tag after the element has been created.
 void SkipTag.processContent(Book book, Key key, org.jdom2.Element ele)
           
 void ScripRefTag.processContent(Book book, Key key, org.jdom2.Element ele)
           
 void IgnoreTag.processContent(Book book, Key key, org.jdom2.Element ele)
           
 void AbstractTag.processContent(Book book, Key key, org.jdom2.Element ele)
           
 org.jdom2.Element VerseTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element UlTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element UTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element TtTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element TrTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element ThTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element TermTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element TdTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element Tag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
          Make changes to the specified OSIS element given the attributes passed in the source document.
 org.jdom2.Element TableTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element SyncTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element SupTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element SubTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element SmallTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element ScriptureTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element ScripRefTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element STag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element RootTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element QTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element PTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element OlTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element NoteTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element NameTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element LiTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element LTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element ImgTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element ITag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element HTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element ForeignTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element FontTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element DivTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element CitationTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element CenterTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element BrTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element BlockquoteTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element BigTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element BTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element AnonymousTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element AliasTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element AbstractTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element AbbrTag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 org.jdom2.Element ATag.processTag(Book book, Key key, org.jdom2.Element ele, Attributes attrs)
           
 List<org.jdom2.Content> THMLFilter.toOSIS(Book book, Key key, String plain)
           
 

Constructors in org.crosswire.jsword.book.filter.thml with parameters of type Key
CustomHandler(Book book, Key key)
          Simple ctor
 

Uses of Key in org.crosswire.jsword.book.readings
 

Classes in org.crosswire.jsword.book.readings that implement Key
 class ReadingsKey
          For a readings dictionary the keys are dates.
 

Fields in org.crosswire.jsword.book.readings declared as Key
private  Key ReadingsBook.global
          The global key list
 

Fields in org.crosswire.jsword.book.readings with type parameters of type Key
private  Map<Key,String> ReadingsBook.hash
          The store of keys and data
 

Methods in org.crosswire.jsword.book.readings that return Key
 Key ReadingsBook.createEmptyKeyList()
           
 Key ReadingsBook.getGlobalKeyList()
           
 Key ReadingsBook.getKey(String name)
           
 Key ReadingsBook.getPreferred()
           
 Key ReadingsBook.getValidKey(String name)
           
 

Methods in org.crosswire.jsword.book.readings with parameters of type Key
 int ReadingsKey.compareTo(Key obj)
           
 boolean ReadingsBook.contains(Key key)
           
 List<org.jdom2.Content> ReadingsBook.getOsis(Key key, RawTextToXmlProcessor processor)
          Returns an empty list
 Iterator<org.jdom2.Content> ReadingsBook.getOsisIterator(Key key, boolean allowEmpty)
           
 String ReadingsBook.getRawText(Key key)
          Returns an empty string (non-Javadoc)
 void ReadingsBook.setAliasKey(Key alias, Key source)
           
 void ReadingsBook.setRawText(Key key, String rawData)
           
 

Constructors in org.crosswire.jsword.book.readings with parameters of type Key
ReadingsKey(String text, String osisName, Key parent)
          Simple Constructor.
 

Uses of Key in org.crosswire.jsword.book.sword
 

Classes in org.crosswire.jsword.book.sword that implement Key
 class AbstractKeyBackend<T extends OpenFileState>
          A Backend that can be used as a global key list.
 class RawLDBackend<T extends RawLDBackendState>
          An implementation AbstractKeyBackend to read RAW format files.
 class ZLDBackend
          An extension of RawLDBackend to read Z format files.
 

Fields in org.crosswire.jsword.book.sword declared as Key
private  Key SwordGenBook.global
          The global key list
private  Key SwordBook.global
          A cached representation of the global key list.
private  Key SwordGenBook.set
          So we can implement getIndex() easily
 

Fields in org.crosswire.jsword.book.sword with type parameters of type Key
private  Map<String,Key> SwordGenBook.map
          So we can quickly find a Key given the text for the key
 

Methods in org.crosswire.jsword.book.sword that return Key
 Key SwordGenBook.createEmptyKeyList()
           
 Key SwordDictionary.createEmptyKeyList()
           
 Key RawLDBackend.get(int index)
           
 Key ZVerseBackend.getGlobalKeyList()
           
 Key SwordGenBook.getGlobalKeyList()
           
 Key SwordDictionary.getGlobalKeyList()
           
 Key SwordBook.getGlobalKeyList()
           
 Key AbstractBackend.getGlobalKeyList()
          Gets the fast global key list, and if this operation is not supported, throws a UnsupportedOperationException
 Key SwordGenBook.getKey(String text)
           
 Key SwordDictionary.getKey(String text)
           
 Key AbstractKeyBackend.getParent()
           
 Key SwordDailyDevotion.getPreferred()
           
 Key SwordGenBook.getValidKey(String name)
           
 Key SwordDictionary.getValidKey(String name)
           
 Key GenBookBackend.readIndex()
           
 Key AbstractBackend.readIndex()
          Initialize a AbstractBackend before use.
 

Methods in org.crosswire.jsword.book.sword that return types with arguments of type Key
 Iterator<Key> AbstractKeyBackend.iterator()
           
 

Methods in org.crosswire.jsword.book.sword with parameters of type Key
 void AbstractKeyBackend.addAll(Key key)
           
 void SwordBook.addOSIS(Key key, org.jdom2.Element div, List<org.jdom2.Content> osisContent)
           
 void SwordBook.addOSIS(Key key, List<org.jdom2.Content> contentList, List<org.jdom2.Content> osisContent)
           
 int AbstractKeyBackend.compareTo(Key that)
           
 boolean ZVerseBackend.contains(Key key)
           
 boolean SwordGenBook.contains(Key key)
           
 boolean SwordDictionary.contains(Key key)
           
 boolean SwordBook.contains(Key key)
           
 boolean RawBackend.contains(Key key)
           
 boolean GenBookBackend.contains(Key key)
           
 boolean AbstractKeyBackend.contains(Key key)
           
abstract  boolean AbstractBackend.contains(Key key)
          Determine whether this Book contains the key in question
private  void GenBookBackend.doReadIndex(TreeNode parentNode, Key parentKey)
          A helper function to recursively read the entire tree.
private  TreeNode GenBookBackend.find(Key key)
          Given a Key, find the TreeNode for it.
 String AbstractKeyBackend.getName(Key base)
           
 List<org.jdom2.Content> SwordGenBook.getOsis(Key key, RawTextToXmlProcessor processor)
           
 List<org.jdom2.Content> SwordDictionary.getOsis(Key key, RawTextToXmlProcessor processor)
           
protected  List<org.jdom2.Content> SwordBook.getOsis(Key key, RawTextToXmlProcessor processor)
           
 Iterator<org.jdom2.Content> SwordGenBook.getOsisIterator(Key key, boolean allowEmpty)
           
 Iterator<org.jdom2.Content> SwordDictionary.getOsisIterator(Key key, boolean allowEmpty)
           
 String SwordGenBook.getRawText(Key key)
           
 String SwordDictionary.getRawText(Key key)
           
 String SwordBook.getRawText(Key key)
           
 String RawBackend.getRawText(RawBackendState state, Key key)
           
 int RawLDBackend.indexOf(Key that)
           
private  void AbstractBackend.readNormalOsis(Key key, RawTextToXmlProcessor processor, List<org.jdom2.Content> content, T openFileState)
           
private  Verse AbstractBackend.readPassageOsis(Key key, RawTextToXmlProcessor processor, List<org.jdom2.Content> content, T openFileState)
          Reads a passage as OSIS
 String GenBookBackend.readRawContent(GenBookBackendState state, Key key)
           
 String RawBackend.readRawContent(RawBackendState state, Key key)
           
 String RawLDBackend.readRawContent(RawLDBackendState state, Key key)
           
 String StatefulFileBackedBackend.readRawContent(T state, Key key)
           
 String ZVerseBackend.readRawContent(ZVerseBackendState rafBook, Key key)
           
 List<org.jdom2.Content> AbstractBackend.readToOsis(Key key, RawTextToXmlProcessor processor)
          Get the text allotted for the given entry
 void AbstractKeyBackend.removeAll(Key key)
           
 void AbstractKeyBackend.retainAll(Key key)
           
 void GenBookBackend.setAliasKey(GenBookBackendState state, Key alias, Key source)
           
 void SwordGenBook.setAliasKey(Key alias, Key source)
           
 void SwordDictionary.setAliasKey(Key alias, Key source)
           
 void SwordBook.setAliasKey(Key alias, Key source)
           
 void RawBackend.setAliasKey(RawBackendState state, Key alias, Key source)
           
 void RawFileBackend.setAliasKey(RawFileBackendState state, Key alias, Key source)
           
 void StatefulFileBackedBackend.setAliasKey(T state, Key alias, Key source)
          Sets alias for a comment on a verse range I.e.
 void AbstractKeyBackend.setAliasKey(T state, Key alias, Key source)
           
 void ZVerseBackend.setAliasKey(ZVerseBackendState rafBook, Key alias, Key source)
           
 void GenBookBackend.setRawText(GenBookBackendState rafBook, Key key, String text)
           
 void SwordGenBook.setRawText(Key key, String rawData)
           
 void SwordDictionary.setRawText(Key key, String rawData)
           
 void SwordBook.setRawText(Key key, String rawData)
           
 void RawBackend.setRawText(RawBackendState state, Key key, String text)
           
 void RawFileBackend.setRawText(RawFileBackendState state, Key key, String text)
           
 void StatefulFileBackedBackend.setRawText(T state, Key key, String text)
          Set the text allotted for the given verse
 void AbstractKeyBackend.setRawText(T state, Key key, String text)
           
 void ZVerseBackend.setRawText(ZVerseBackendState rafBook, Key key, String text)
           
private  void AbstractBackend.throwFailedKeyException(Key masterKey, Key currentKey, IOException e)
          If non-null, currentKey is used to throw the exception, other, masterKey is used instead, which will be more general.
 

Uses of Key in org.crosswire.jsword.book.sword.processing
 

Methods in org.crosswire.jsword.book.sword.processing with parameters of type Key
 void RawTextToXmlProcessor.postVerse(Key verse, List<org.jdom2.Content> partialDom, String rawText)
          Executes after a verse is read from the raw data.
 void NoOpRawTextProcessor.postVerse(Key verse, List<org.jdom2.Content> partialDom, String rawText)
           
 

Uses of Key in org.crosswire.jsword.bridge
 

Fields in org.crosswire.jsword.bridge declared as Key
private  Key BibleScope.inScope
           
private  Key BibleScope.outScope
           
 

Methods in org.crosswire.jsword.bridge that return Key
 Key BibleScope.getInScope()
          Get a key containing all the verses that are in this Bible.
 Key BibleScope.getOutOfScope()
          Get a key containing all the verses that are not in this Bible.
 

Methods in org.crosswire.jsword.bridge with parameters of type Key
 String BookLookup.locate(Key key)
           
 

Uses of Key in org.crosswire.jsword.examples
 

Methods in org.crosswire.jsword.examples with parameters of type Key
 void StrongsAnalysis.analyze(StrongsMapSet sms, Book book, List<Key> errors, Key wholeBible)
           
 

Method parameters in org.crosswire.jsword.examples with type arguments of type Key
 void StrongsAnalysis.analyze(StrongsMapSet sms, Book book, List<Key> errors, Key wholeBible)
           
 

Uses of Key in org.crosswire.jsword.index
 

Methods in org.crosswire.jsword.index that return Key
 Key Index.find(String query)
          Find the set of references that satisfy the query.
 Key Index.getKey(String name)
          An index must be able to create KeyLists for users in a similar way to the Book that it is indexing.
 

Uses of Key in org.crosswire.jsword.index.lucene
 

Fields in org.crosswire.jsword.index.lucene declared as Key
private  Key VerseCollector.results
           
 

Methods in org.crosswire.jsword.index.lucene that return Key
 Key LuceneIndex.find(String search)
           
 Key LuceneIndex.getKey(String name)
           
 Key LuceneSearcher.search(Query query)
           
 Key LuceneSearcher.search(SearchRequest request)
           
 Key LuceneSearcher.search(String request)
           
 

Methods in org.crosswire.jsword.index.lucene with parameters of type Key
private  void LuceneIndex.generateSearchIndexImpl(Progress job, List<Key> errors, org.apache.lucene.index.IndexWriter writer, Key key, int count)
          Dig down into a Key indexing as we go.
 

Method parameters in org.crosswire.jsword.index.lucene with type arguments of type Key
private  void LuceneIndex.generateSearchIndexImpl(Progress job, List<Key> errors, org.apache.lucene.index.IndexWriter writer, Key key, int count)
          Dig down into a Key indexing as we go.
 

Constructors in org.crosswire.jsword.index.lucene with parameters of type Key
VerseCollector(Versification refSystem, org.apache.lucene.search.Searcher searcher, Key results)
          Create a collector for the searcher that populates results.
 

Uses of Key in org.crosswire.jsword.index.query
 

Methods in org.crosswire.jsword.index.query that return Key
 Key RangeQuery.find(Index index)
           
 Key Query.find(Index index)
          Find the keys that match the query in the index
 Key OrQuery.find(Index index)
           
 Key NullQuery.find(Index index)
           
 Key BlurQuery.find(Index index)
           
 Key BaseQuery.find(Index index)
           
 Key AndQuery.find(Index index)
           
 Key AndNotQuery.find(Index index)
           
 

Uses of Key in org.crosswire.jsword.index.search
 

Methods in org.crosswire.jsword.index.search that return Key
 Key Searcher.search(Query request)
          Take a search request and decipher it into a Passage.
 Key Searcher.search(SearchRequest request)
          Take a search request and decipher it into a Passage.
 

Uses of Key in org.crosswire.jsword.passage
 

Subinterfaces of Key in org.crosswire.jsword.passage
 interface Passage
          A Passage is a specialized Collection of Verses.
 interface VerseKey
          A Versified indicates that a Key has a Versification reference system.
 

Classes in org.crosswire.jsword.passage that implement Key
 class AbstractKeyList
          An implementation of some of the easier methods from Key.
 class AbstractPassage
          This is a base class to help with some of the common implementation details of being a Passage.
 class BitwisePassage
          A Passage that is implemented using a BitSet - one for each verse.
 class DefaultKeyList
          A default implementation of Key.
 class DefaultLeafKeyList
          A simple default implementation of the Key interface.
 class DistinctPassage
          A Passage that is implemented using a TreeSet of Verses.
 class PassageTally
          Similar to a Passage, but that stores a ranking for each of the Verses that it contains.
 class RangedPassage
          A Passage that is implemented using a TreeSet of VerseRanges.
 class ReadOnlyKeyList
          A read-only wrapper around any writable implementation of Key.
(package private)  class ReadOnlyPassage
          This is a simple proxy to a real Passage object that denies all attempts to write to it.
 class RocketPassage
          A RocketPassage is a bit and heavy implementation of Passage that goes fairly quickly once let of the leash.
 class SetKeyList
          A Key that uses a Set of Keys as it's store of data.
(package private)  class SynchronizedPassage
          This is a simple proxy to a real Passage object that makes all accesses synchronized.
 class TreeKey
          A Key that knows where the data is in the real file.
 class Verse
          A Verse is a pointer to a single verse.
 class VerseRange
          A VerseRange is one step between a Verse and a Passage - it is a Verse plus a verseCount.
 

Fields in org.crosswire.jsword.passage declared as Key
private  Key ReadOnlyKeyList.keys
          The Key to which we proxy
private  Key VerseRange.parent
          The parent key.
private  Key TreeKey.parent
          The parent of this key.
private  Key SetKeyList.parent
          The parent of this key
private  Key KeyIterator.Locator.parent
           
private  Key DefaultLeafKeyList.parent
          The parent of this key
private  Key DefaultKeyList.parent
          The parent of this key
private  Key AbstractPassage.parent
          The parent key.
 

Fields in org.crosswire.jsword.passage with type parameters of type Key
private  List<Key> TreeKey.children
          The immediate children of this tree node.
private  Iterator<Key> AbstractPassage.VerseRangeIterator.it
          The Iterator that we are proxying to
private  List<Key> DefaultKeyList.keys
          The store of Keys
private  List<Key> SetKeyList.list
          The Set that we are proxying to
private  Iterator<Key> RangedPassage.VerseIterator.real
          The Iterator that we are proxying to
private  Iterator<Key> RangedPassage.VerseRangeIterator.real
          Where we read our base ranges from
private  Set<Key> RangedPassage.store
          The place the real data is stored
private  SortedSet<Key> DistinctPassage.store
          The place the real data is stored
 

Methods in org.crosswire.jsword.passage that return Key
 Key Key.clone()
          This needs to be declared here so that it is visible as a method on a derived Key.
 Key KeyFactory.createEmptyKeyList()
          Fetch an empty Key to which we can add Keys.
 Key PassageKeyFactory.createEmptyKeyList(Versification v11n)
          Create an empty list of keys for the v11n
 Key VerseRange.get(int index)
           
 Key Verse.get(int index)
           
 Key TreeKey.get(int index)
           
 Key SynchronizedPassage.get(int index)
           
 Key SetKeyList.get(int index)
           
 Key ReadOnlyPassage.get(int index)
           
 Key ReadOnlyKeyList.get(int index)
           
 Key Key.get(int index)
          Gets a key from a specific point in this list of children.
 Key DefaultLeafKeyList.get(int index)
           
 Key DefaultKeyList.get(int index)
           
 Key AbstractPassage.get(int index)
           
 Key KeyFactory.getGlobalKeyList()
          Get a complete list of index entries.
 Key PassageKeyFactory.getGlobalKeyList(Versification v11n)
          Get a Passage containing all the Verses in this Versification.
 Key KeyFactory.getKey(String name)
          Someone has typed in a reference to find, but we need a Key to actually look it up.
 Key PassageKeyFactory.getKey(Versification v11n, String passageReference)
          Convert the passageReference into a Passage.
 Key PassageKeyFactory.getKey(Versification v11n, String passageReference, Key basis)
          Convert the passageReference into a Passage.
 Key VerseRange.getParent()
           
 Key Verse.getParent()
           
 Key TreeKey.getParent()
           
 Key SynchronizedPassage.getParent()
           
 Key SetKeyList.getParent()
           
 Key ReadOnlyPassage.getParent()
           
 Key ReadOnlyKeyList.getParent()
           
 Key KeyIterator.Locator.getParent()
           
 Key Key.getParent()
          All keys have parents unless they are the root of a Key.
 Key DefaultLeafKeyList.getParent()
           
 Key DefaultKeyList.getParent()
           
 Key AbstractPassage.getParent()
           
 Key PreferredKey.getPreferred()
          What Key would this object like us to use?
 Key KeyFactory.getValidKey(String name)
          Get a Key for the name, if possible.
 Key PassageKeyFactory.getValidKey(Versification v11n, String passageReference)
          Convert the passageReference into a Passage or an empty Passage, if there is an error.
 Key PassageKeyFactory.getValidKey(Versification v11n, String passageReference, Key basis)
          Convert the passageReference into a Passage or an empty Passage, if there is an error.
 Key VerseRange.VerseIterator.next()
           
 Key RangedPassage.VerseIterator.next()
           
 Key RangedPassage.VerseRangeIterator.next()
           
 Key PassageTally.VerseIterator.next()
           
 Key PassageTally.OrderedVerseIterator.next()
           
 Key KeyIterator.next()
           
 Key BitwisePassage.VerseIterator.next()
           
private  Key RangedPassage.VerseRangeIterator.replyNext()
          The next object is correct, use that one
private  Key RangedPassage.VerseRangeIterator.splitNext()
          The next object is too big, so cut it up
 

Methods in org.crosswire.jsword.passage that return types with arguments of type Key
 Iterator<Key> VerseRange.iterator()
           
 Iterator<Key> Verse.iterator()
           
 Iterator<Key> TreeKey.iterator()
           
 Iterator<Key> SynchronizedPassage.iterator()
           
 Iterator<Key> SetKeyList.iterator()
           
 Iterator<Key> RocketPassage.iterator()
           
 Iterator<Key> ReadOnlyPassage.iterator()
           
 Iterator<Key> ReadOnlyKeyList.iterator()
           
 Iterator<Key> RangedPassage.iterator()
           
 Iterator<Key> PassageTally.iterator()
          Iterate through the verse elements in the current sort order
 Iterator<Key> DistinctPassage.iterator()
           
 Iterator<Key> DefaultLeafKeyList.iterator()
           
 Iterator<Key> DefaultKeyList.iterator()
           
 Iterator<Key> BitwisePassage.iterator()
           
 Iterator<Key> VerseRange.rangeIterator(RestrictionType restrict)
          Enumerate the subranges in this range
 Iterator<Key> SynchronizedPassage.rangeIterator(RestrictionType restrict)
           
 Iterator<Key> RocketPassage.rangeIterator(RestrictionType restrict)
           
 Iterator<Key> ReadOnlyPassage.rangeIterator(RestrictionType restrict)
           
 Iterator<Key> RangedPassage.rangeIterator(RestrictionType restrict)
           
 Iterator<Key> PassageTally.rangeIterator(RestrictionType restrict)
           
 Iterator<Key> Passage.rangeIterator(RestrictionType restrict)
          Like verseElements() that iterates over VerseRanges instead of Verses.
 Iterator<Key> AbstractPassage.rangeIterator(RestrictionType restrict)
           
 

Methods in org.crosswire.jsword.passage with parameters of type Key
 void SynchronizedPassage.add(Key that)
           
 void ReadOnlyPassage.add(Key that)
           
 void RangedPassage.add(Key obj)
           
 void PassageTally.add(Key that)
          Add/Increment this verses in the rankings
 void Passage.add(Key that)
          Add this Verse/VerseRange to this Passage
 void DistinctPassage.add(Key obj)
           
 void BitwisePassage.add(Key obj)
           
 void PassageTally.add(Key that, int count)
          DONT USE THIS.
 void VerseRange.addAll(Key key)
           
 void Verse.addAll(Key key)
           
 void TreeKey.addAll(Key key)
           
 void SynchronizedPassage.addAll(Key key)
           
 void SetKeyList.addAll(Key key)
           
 void ReadOnlyPassage.addAll(Key key)
           
 void ReadOnlyKeyList.addAll(Key key)
           
 void PassageTally.addAll(Key that)
           
 void Key.addAll(Key key)
          Adds the specified element to this set if it is not already present.
 void DefaultLeafKeyList.addAll(Key key)
           
 void DefaultKeyList.addAll(Key key)
           
 void BitwisePassage.addAll(Key key)
           
 void AbstractPassage.addAll(Key key)
           
protected  void AbstractPassage.addVerses(String refs, Key basis)
          Create a Passage from a human readable string.
private  void PassageTally.alterVerseBase(Key that, int tally)
          Increment/Decrement this verses in the rankings
 int VerseRange.compareTo(Key obj)
           
 int Verse.compareTo(Key obj)
           
 int SynchronizedPassage.compareTo(Key o)
           
 int ReadOnlyPassage.compareTo(Key o)
           
 int ReadOnlyKeyList.compareTo(Key o)
           
 int DefaultLeafKeyList.compareTo(Key obj)
           
 int AbstractPassage.compareTo(Key obj)
           
 int AbstractKeyList.compareTo(Key that)
           
 boolean VerseRange.contains(Key key)
           
 boolean Verse.contains(Key key)
           
 boolean TreeKey.contains(Key key)
           
 boolean SynchronizedPassage.contains(Key key)
           
 boolean SetKeyList.contains(Key key)
           
 boolean ReadOnlyPassage.contains(Key key)
           
 boolean ReadOnlyKeyList.contains(Key key)
           
 boolean RangedPassage.contains(Key obj)
           
 boolean PassageTally.contains(Key that)
          Does this tally contain all the specified verses?
 boolean Passage.contains(Key that)
          Returns true if this collection contains all the specified Verse
 boolean Key.contains(Key key)
          Returns true if this set contains the specified element.
 boolean DistinctPassage.contains(Key obj)
           
 boolean DefaultLeafKeyList.contains(Key key)
           
 boolean DefaultKeyList.contains(Key key)
           
 boolean BitwisePassage.contains(Key obj)
           
 boolean AbstractPassage.contains(Key key)
           
 boolean AbstractKeyList.contains(Key key)
           
abstract  Passage PassageType.createPassage(Versification v11n, String passage, Key basis)
          Create an optimized passage
private  String VerseRange.doGetName(Key base)
           
 Key PassageKeyFactory.getKey(Versification v11n, String passageReference, Key basis)
          Convert the passageReference into a Passage.
 String VerseRange.getName(Key base)
           
 String Verse.getName(Key base)
           
 String SynchronizedPassage.getName(Key base)
           
 String ReadOnlyPassage.getName(Key base)
           
 String ReadOnlyKeyList.getName(Key base)
           
 String Key.getName(Key base)
          Translate the Key into a human readable string, with the assumption that the specified Key has just been output, so if we are in the same region, we do not need to display the region name, and so on.
 String DefaultLeafKeyList.getName(Key base)
           
 String AbstractPassage.getName(Key base)
           
 String AbstractKeyList.getName(Key base)
           
static Passage KeyUtil.getPassage(Key key)
          Cast a Key to a Passage.
static Passage KeyUtil.getPassage(Versification v11n, Key key)
          Deprecated. KeyUtil.getPassage(Key)
 Key PassageKeyFactory.getValidKey(Versification v11n, String passageReference, Key basis)
          Convert the passageReference into a Passage or an empty Passage, if there is an error.
static Verse KeyUtil.getVerse(Key key)
          Cast a Key to a Verse.
static Verse KeyUtil.getVerse(Versification v11n, Key key)
          Deprecated. use KeyUtil.getVerse(Key)
static Versification KeyUtil.getVersification(Key key)
          Get the versification for the key or the default versification.
 int VerseRange.indexOf(Key that)
           
 int Verse.indexOf(Key that)
           
 int TreeKey.indexOf(Key that)
           
 int SynchronizedPassage.indexOf(Key that)
           
 int SetKeyList.indexOf(Key that)
           
 int ReadOnlyPassage.indexOf(Key that)
           
 int ReadOnlyKeyList.indexOf(Key that)
           
 int Key.indexOf(Key that)
          Reverse a Key into the position the key holds in the list of children
 int DefaultLeafKeyList.indexOf(Key that)
           
 int DefaultKeyList.indexOf(Key that)
           
 int AbstractPassage.indexOf(Key that)
           
 void SynchronizedPassage.remove(Key that)
           
 void ReadOnlyPassage.remove(Key that)
           
 void RangedPassage.remove(Key obj)
           
 void PassageTally.remove(Key that)
          Remove these verses from the rankings, ie, set their rank to zero.
 void Passage.remove(Key that)
          Remove this Verse/VerseRange from this Passage
 void DistinctPassage.remove(Key obj)
           
 void BitwisePassage.remove(Key obj)
           
 void VerseRange.removeAll(Key key)
           
 void Verse.removeAll(Key key)
           
 void TreeKey.removeAll(Key key)
           
 void SynchronizedPassage.removeAll(Key key)
           
 void SetKeyList.removeAll(Key key)
           
 void ReadOnlyPassage.removeAll(Key key)
           
 void ReadOnlyKeyList.removeAll(Key key)
           
 void PassageTally.removeAll(Key key)
           
 void Key.removeAll(Key key)
          Removes the specified elements from this set if it is present.
 void DefaultLeafKeyList.removeAll(Key key)
           
 void DefaultKeyList.removeAll(Key key)
           
 void BitwisePassage.removeAll(Key key)
           
 void AbstractPassage.removeAll(Key key)
           
protected static void AbstractKeyList.retain(Key alter, Key base)
          Utility to remove all the keys from alter that are not in base
 void VerseRange.retainAll(Key key)
           
 void Verse.retainAll(Key key)
           
 void SynchronizedPassage.retainAll(Key key)
           
 void ReadOnlyPassage.retainAll(Key key)
           
 void ReadOnlyKeyList.retainAll(Key key)
           
 void RangedPassage.retainAll(Key key)
           
 void Key.retainAll(Key key)
          Removes all but the specified element from this set.
 void DefaultLeafKeyList.retainAll(Key key)
           
 void BitwisePassage.retainAll(Key key)
           
 void AbstractPassage.retainAll(Key key)
           
 void AbstractKeyList.retainAll(Key key)
           
 void VerseRange.setParent(Key parent)
          Set a parent Key.
 void KeyIterator.Locator.setParent(Key parent)
           
 void AbstractPassage.setParent(Key parent)
          Set a parent Key.
 void PassageTally.unAdd(Key that)
          Remove/Decrement this verses in the rankings
static void KeyUtil.visit(Key key, KeyVisitor visitor)
          Walk through a tree visiting the nodes and branches in the tree
 void KeyVisitor.visitBranch(Key key)
          We've found a branch node in a Key tree, and are giving the visitor a chance to do processing based on it.
 void DefaultKeyVisitor.visitBranch(Key key)
           
 void KeyVisitor.visitLeaf(Key key)
          We've found a leaf node in a Key tree, and are giving the visitor a chance to do processing based on it.
 void DefaultKeyVisitor.visitLeaf(Key key)
           
 void AbstractKeyList.NameVisitor.visitLeaf(Key key)
           
 void AbstractKeyList.OsisRefVisitor.visitLeaf(Key key)
           
 void AbstractKeyList.OsisIDVisitor.visitLeaf(Key key)
           
 

Constructors in org.crosswire.jsword.passage with parameters of type Key
BitwisePassage(Versification v11n, String refs, Key basis)
          Create a Verse from a human readable string.
DefaultKeyList(Key parent, String name)
          Simple ctor
DefaultLeafKeyList(String name, String osisName, Key parent)
          Default ctor
DistinctPassage(Versification v11n, String refs, Key basis)
          Create a Verse from a human readable string.
KeyIterator.Locator(Key parent)
           
KeyIterator(Key key)
           
PassageTally(Versification v11n, String refs, Key basis)
          Create a Verse from a human readable string.
RangedPassage(Versification v11n, String refs, Key basis)
          Create a Verse from a human readable string.
ReadOnlyKeyList(Key keys, boolean ignore)
          Simple ctor
RocketPassage(Versification v11n, String refs, Key basis)
          Create a Verse from a human readable string.
SetKeyList(Set<Key> set, Key parent)
          Simple ctor
SetKeyList(Set<Key> set, Key parent, String name)
          Simple ctor
TreeKey(String name, Key parent)
          Setup with the key name and positions of data in the file
 

Constructor parameters in org.crosswire.jsword.passage with type arguments of type Key
AbstractPassage.VerseRangeIterator(Versification v11n, Iterator<Key> it, RestrictionType restrict)
          iterate, amalgamating Verses into VerseRanges
PassageTally.OrderedVerseRangeIterator(Versification v11n, Iterator<Key> vit, int[] board)
          Find the first unused verse
RangedPassage.VerseIterator(Versification v11n, Iterator<Key> it)
          Create a basic iterator that is a proxy for the RangedPassage Passages iterator, with remove() overridden.
RangedPassage.VerseRangeIterator(Iterator<Key> it, RestrictionType restrict)
          Simple ctor
SetKeyList(Set<Key> set)
          Simple ctor
SetKeyList(Set<Key> set, Key parent)
          Simple ctor
SetKeyList(Set<Key> set, Key parent, String name)
          Simple ctor
SetKeyList(Set<Key> set, String name)
          Simple ctor
 


Copyright ? 2003-2011