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 swing section is in charge of turning the XML from the source section into a screen view. 
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.proxy This package contains an implementation of BookDataDisplay that proxies to another BookDataDisplay to make implementing nested BookDataDisplays easier. 
org.crosswire.bibledesktop.display.splitlist This package contains an implementation of BookDataDisplay that adds a side panel to a child implementation of BookDataDisplay. 
org.crosswire.bibledesktop.display.tab This package contains an implementation of BookDataDisplay (based on ProxyBookDataDisplay for simplicity) that adds scrollbars to a child implementation of BookDataDisplay. 
org.crosswire.bibledesktop.display.textpane This package contains an implementation of BookDataDisplay that displays the OSIS after transforming it to HTML (using XSL) in a Swing JTextPane. 
org.crosswire.bibledesktop.passage This package contains Swing MVC models to help implementing a Swing GUI using JSword classes. 
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.index Abstraction of an Index. 
org.crosswire.jsword.index.lucene An implemenation of SearchEngine 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
private  Key DisplaySelectEvent.key
          The new passage
private  Key DisplaySelectPane.key
          The current passage.
 

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

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 book, Key key)
           
 void BibleViewPane.setKey(Key key)
          Accessor for the current passage
 void DisplaySelectPane.setKey(Key newKey)
           
 void MultiBookPane.setKey(Key key)
          Accessor for the current passage
 

Constructors in org.crosswire.bibledesktop.book with parameters of type Key
DisplaySelectEvent(Object source, Key key, Book book)
          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 book, Key key)
           
 

Uses of Key in org.crosswire.bibledesktop.display
 

Methods in org.crosswire.bibledesktop.display that return Key
 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 BookDataDisplay.setBookData(Book book, Key key)
          Set the BookData to be displayed.
 

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

Methods in org.crosswire.bibledesktop.display.proxy that return Key
 Key ProxyBookDataDisplay.getKey()
           
 

Methods in org.crosswire.bibledesktop.display.proxy with parameters of type Key
 void ProxyBookDataDisplay.setBookData(Book book, Key key)
           
 

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

Fields in org.crosswire.bibledesktop.display.splitlist declared as Key
private  Key SplitBookDataDisplay.key
          The whole passage that we are viewing
 

Methods in org.crosswire.bibledesktop.display.splitlist that return Key
 Key SplitBookDataDisplay.getKey()
           
 

Methods in org.crosswire.bibledesktop.display.splitlist with parameters of type Key
 void SplitBookDataDisplay.setBookData(Book book, Key key)
           
 

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

Methods in org.crosswire.bibledesktop.display.tab that return Key
 Key TabbedBookDataDisplay.getKey()
           
 

Methods in org.crosswire.bibledesktop.display.tab 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 TabbedBookDataDisplay.setBookData(Book book, Key newkey)
           
 

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

Fields in org.crosswire.bibledesktop.display.textpane declared as Key
private  Key TextPaneBookDataDisplay.key
          The current key
 

Methods in org.crosswire.bibledesktop.display.textpane that return Key
 Key TextPaneBookDataDisplay.getKey()
           
 

Methods in org.crosswire.bibledesktop.display.textpane with parameters of type Key
 void TextPaneBookDataDisplay.setBookData(Book book, Key key)
           
 

Uses of Key in org.crosswire.bibledesktop.passage
 

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

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

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

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
private static Key DataPolice.key
          the last known item
 

Methods in org.crosswire.jsword.book that return Key
 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 BookData.getKey()
          What key was used to create this data.
 

Methods in org.crosswire.jsword.book with parameters of type Key
 BookData Book.getData(Key key)
          Retrieval: Add to the given document some mark-up for the specified Verses.
 String Book.getRawData(Key key)
          Returns the raw text that getData(Key key) builds into OSIS.
static void DataPolice.setKey(Key key)
          Set the current item to enhance error reports
 

Constructors in org.crosswire.jsword.book with parameters of type Key
BookData(org.jdom.Element osis, Book book, Key key)
          Ctor
BookData(SAXEventProvider provider, Book book, Key key)
          Create a BibleData from a SAXEventProvider
 

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.getGlobalKeyList()
           
 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.jdom.Element div, List osisContent)
          Add the OSIS elements to the div element.
 BookData AbstractPassageBook.getData(Key key)
           
 String AbstractPassageBook.getRawData(Key key)
           
protected abstract  String AbstractPassageBook.getText(Key key)
          Read the unfiltered data for a given key
 

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

Methods in org.crosswire.jsword.book.filter with parameters of type Key
 List 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 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 GBFFilter.toOSIS(Book book, Key key, String plain)
           
 

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.jdom.Element OSISFilter.cleanTags(Book book, Key key, String plain)
           
 List 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 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 key for the data.
 

Methods in org.crosswire.jsword.book.filter.thml with parameters of type Key
private  org.jdom.Element THMLFilter.cleanParse(Book book, Key key, String plain)
           
private  org.jdom.Element THMLFilter.cleanTags(Book book, Key key, String plain)
           
private  org.jdom.Element THMLFilter.cleanText(Book book, Key key, String plain)
           
private  org.jdom.Element THMLFilter.parse(Book book, Key key, String plain, String failMessage)
           
 List 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
 

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
 BookData ReadingsBook.getData(Key key)
           
 String ReadingsBook.getRawData(Key key)
           
 

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
(package private)  class IndexKey
          A Key that knows where the data is in the real file.
 

Fields in org.crosswire.jsword.book.sword declared as Key
private  Key SwordDictionary.global
          The global key list
private  Key SwordGenBook.global
          The global key list
private  Key ZLDBackend.keys
           
private  Key SwordDictionary.set
          So we can implement getIndex() easily
private  Key SwordGenBook.set
          So we can implement getIndex() easily
 

Methods in org.crosswire.jsword.book.sword that return Key
 Key SwordDictionary.createEmptyKeyList()
           
 Key SwordGenBook.createEmptyKeyList()
           
 Key SwordDictionary.getGlobalKeyList()
           
 Key SwordGenBook.getGlobalKeyList()
           
 Key SwordDictionary.getKey(String text)
           
 Key SwordGenBook.getKey(String text)
           
 Key SwordDailyDevotion.getPreferred()
           
private  Key SwordDictionary.getStrongsKey(String txt)
           
 Key SwordDictionary.getValidKey(String name)
           
 Key SwordGenBook.getValidKey(String name)
           
abstract  Key AbstractBackend.readIndex()
          Initialise a AbstractBackend before use.
 Key GZIPBackend.readIndex()
           
 Key GenBookBackend.readIndex()
           
 Key LZSSBackend.readIndex()
           
 Key RawBackend.readIndex()
           
 Key RawLDBackend.readIndex()
           
 Key ZLDBackend.readIndex()
           
 

Methods in org.crosswire.jsword.book.sword with parameters of type Key
 void SwordBook.addOSIS(Key key, org.jdom.Element div, List osisContent)
           
static void SwordUtil.clean1252(Key key, byte[] data)
          Remove rogue characters in the source.
static void SwordUtil.clean1252(Key key, byte[] data, int length)
          Remove rogue characters in the source.
static String SwordUtil.decode(Key key, byte[] data, int length, String charset)
          Transform a byte array into a string given the encoding.
static String SwordUtil.decode(Key key, byte[] data, String charset)
          Transform a byte array into a string given the encoding.
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.
 BookData SwordDictionary.getData(Key key)
           
 BookData SwordGenBook.getData(Key key)
           
 String SwordDictionary.getRawData(Key key)
           
 String SwordGenBook.getRawData(Key key)
           
abstract  String AbstractBackend.getRawText(Key key)
          Get the bytes alotted for the given verse
 String GZIPBackend.getRawText(Key key)
           
 String GenBookBackend.getRawText(Key key)
           
 String LZSSBackend.getRawText(Key key)
           
 String RawBackend.getRawText(Key key)
           
 String RawLDBackend.getRawText(Key key)
           
 String ZLDBackend.getRawText(Key key)
           
protected  String SwordBook.getText(Key key)
          Read the unfiltered data for a given key
 

Constructors in org.crosswire.jsword.book.sword with parameters of type Key
IndexKey(String text, int offset, int size, Key parent)
          Setup with the key name and positions of data in the file
 

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
 

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 errors, org.apache.lucene.index.IndexWriter writer, Key key, int count)
          Dig down into a Key indexing as we go.
 

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

Methods in org.crosswire.jsword.index.query that return Key
 Key AndNotQuery.find(Index index)
           
 Key AndQuery.find(Index index)
           
 Key BaseQuery.find(Index index)
           
 Key BlurQuery.find(Index index)
           
 Key NullQuery.find(Index index)
           
 Key OrQuery.find(Index index)
           
 Key Query.find(Index index)
           
 Key RangeQuery.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.
 

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 Passage 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 AbstractPassage.parent
          The parent key.
private  Key DefaultKeyList.parent
          The parent of this key
private  Key DefaultLeafKeyList.parent
          The parent of this key
private  Key SetKeyList.parent
          The parent of this key
private  Key TreeKey.parent
          The parent of this key.
private  Key Verse.parent
          The parent key.
private  Key VerseRange.parent
          The parent key.
 

Methods in org.crosswire.jsword.passage that return Key
 Key KeyFactory.createEmptyKeyList()
          Fetch an empty Key to which we can add Keys.
 Key PassageKeyFactory.createEmptyKeyList()
           
 Key AbstractPassage.get(int index)
           
 Key DefaultKeyList.get(int index)
           
 Key DefaultLeafKeyList.get(int index)
           
 Key Key.get(int index)
          Gets a key from a specific point in this list of children.
 Key ReadOnlyKeyList.get(int index)
           
 Key ReadOnlyPassage.get(int index)
           
 Key SetKeyList.get(int index)
           
 Key SynchronizedPassage.get(int index)
           
 Key TreeKey.get(int index)
           
 Key Verse.get(int index)
           
 Key VerseRange.get(int index)
           
 Key KeyFactory.getGlobalKeyList()
          Get a complete list of index entries.
 Key PassageKeyFactory.getGlobalKeyList()
           
 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(String name)
           
 Key AbstractPassage.getParent()
           
 Key DefaultKeyList.getParent()
           
 Key DefaultLeafKeyList.getParent()
           
 Key Key.getParent()
          All keys have parents unless they are the root of a Key.
 Key ReadOnlyKeyList.getParent()
           
 Key ReadOnlyPassage.getParent()
           
 Key SetKeyList.getParent()
           
 Key SynchronizedPassage.getParent()
           
 Key TreeKey.getParent()
           
 Key Verse.getParent()
           
 Key VerseRange.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(String name)
           
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 with parameters of type Key
 void BitwisePassage.add(Key obj)
           
 void DistinctPassage.add(Key obj)
           
 void Passage.add(Key that)
          Add this Verse/VerseRange to this Passage
 void PassageTally.add(Key that)
          Add/Increment this verses in the rankings
 void RangedPassage.add(Key obj)
           
 void ReadOnlyPassage.add(Key that)
           
 void SynchronizedPassage.add(Key that)
           
 void PassageTally.add(Key that, int count)
          DONT USE THIS.
 void AbstractPassage.addAll(Key key)
           
 void BitwisePassage.addAll(Key key)
           
 void DefaultKeyList.addAll(Key key)
           
 void DefaultLeafKeyList.addAll(Key key)
           
 void Key.addAll(Key key)
          Adds the specified element to this set if it is not already present.
 void PassageTally.addAll(Key that)
           
 void ReadOnlyKeyList.addAll(Key key)
           
 void ReadOnlyPassage.addAll(Key key)
           
 void SetKeyList.addAll(Key key)
           
 void SynchronizedPassage.addAll(Key key)
           
 void TreeKey.addAll(Key key)
           
 void Verse.addAll(Key key)
           
 void VerseRange.addAll(Key key)
           
private  void PassageTally.alterVerseBase(Key that, int tally)
          Increment/Decrement this verses in the rankings
 boolean AbstractKeyList.contains(Key key)
           
 boolean AbstractPassage.contains(Key key)
           
 boolean BitwisePassage.contains(Key obj)
           
 boolean DefaultKeyList.contains(Key key)
           
 boolean DefaultLeafKeyList.contains(Key key)
           
 boolean DistinctPassage.contains(Key obj)
           
 boolean Key.contains(Key key)
          Returns true if this set contains the specified element.
 boolean Passage.contains(Key that)
          Returns true if this collection contains all the specified Verse
 boolean PassageTally.contains(Key that)
          Does this tally contain all the specified verses?
 boolean RangedPassage.contains(Key obj)
           
 boolean ReadOnlyKeyList.contains(Key key)
           
 boolean ReadOnlyPassage.contains(Key key)
           
 boolean SetKeyList.contains(Key key)
           
 boolean SynchronizedPassage.contains(Key key)
           
 boolean TreeKey.contains(Key key)
           
 boolean Verse.contains(Key key)
           
 boolean VerseRange.contains(Key key)
           
 String AbstractKeyList.getName(Key base)
           
 String AbstractPassage.getName(Key base)
           
 String DefaultLeafKeyList.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 ReadOnlyKeyList.getName(Key base)
           
 String ReadOnlyPassage.getName(Key base)
           
 String SynchronizedPassage.getName(Key base)
           
 String Verse.getName(Key base)
           
 String VerseRange.getName(Key base)
           
static Passage KeyUtil.getPassage(Key key)
          Not all keys represent passages, but we ought to be able to get something close to a passage from anything that does passage like work.
static Verse KeyUtil.getVerse(Key key)
          Not all keys represent verses, but we ought to be able to get something close to a verse from anything that does verse like work.
 int AbstractPassage.indexOf(Key that)
           
 int DefaultKeyList.indexOf(Key that)
           
 int DefaultLeafKeyList.indexOf(Key that)
           
 int Key.indexOf(Key that)
          Reverse a Key into the position the key holds in the list of children
 int ReadOnlyKeyList.indexOf(Key that)
           
 int ReadOnlyPassage.indexOf(Key that)
           
 int SetKeyList.indexOf(Key that)
           
 int SynchronizedPassage.indexOf(Key that)
           
 int TreeKey.indexOf(Key that)
           
 int Verse.indexOf(Key that)
           
 int VerseRange.indexOf(Key that)
           
 void BitwisePassage.remove(Key obj)
           
 void DistinctPassage.remove(Key obj)
           
 void Passage.remove(Key that)
          Remove this Verse/VerseRange from this Passage
 void PassageTally.remove(Key that)
          Remove these verses from the rankings, ie, set their rank to zero.
 void RangedPassage.remove(Key obj)
           
 void ReadOnlyPassage.remove(Key that)
           
 void SynchronizedPassage.remove(Key that)
           
 void AbstractPassage.removeAll(Key key)
           
 void BitwisePassage.removeAll(Key key)
           
 void DefaultKeyList.removeAll(Key key)
           
 void DefaultLeafKeyList.removeAll(Key key)
           
 void Key.removeAll(Key key)
          Removes the specified elements from this set if it is present.
 void PassageTally.removeAll(Key key)
          Remove/Decrement these verses in the rankings
 void ReadOnlyKeyList.removeAll(Key key)
           
 void ReadOnlyPassage.removeAll(Key key)
           
 void SetKeyList.removeAll(Key key)
           
 void SynchronizedPassage.removeAll(Key key)
           
 void TreeKey.removeAll(Key key)
           
 void Verse.removeAll(Key key)
           
 void VerseRange.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 AbstractKeyList.retainAll(Key key)
           
 void AbstractPassage.retainAll(Key key)
           
 void BitwisePassage.retainAll(Key key)
           
 void DefaultLeafKeyList.retainAll(Key key)
           
 void Key.retainAll(Key key)
          Removes all but the specified element from this set.
 void RangedPassage.retainAll(Key key)
           
 void ReadOnlyKeyList.retainAll(Key key)
           
 void ReadOnlyPassage.retainAll(Key key)
           
 void SynchronizedPassage.retainAll(Key key)
           
 void Verse.retainAll(Key key)
           
 void VerseRange.retainAll(Key key)
           
 void AbstractPassage.setParent(Key parent)
          Set a parent Key.
 void Verse.setParent(Key parent)
          Set a parent Key.
 void VerseRange.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 DefaultKeyVisitor.visitBranch(Key key)
           
 void KeyVisitor.visitBranch(Key key)
          We've found a branch node in a Key tree, and are giving the visitor a change to do processing based on it.
 void AbstractKeyList.NameVisitor.visitLeaf(Key key)
           
 void AbstractKeyList.OsisRefVisitor.visitLeaf(Key key)
           
 void AbstractKeyList.OsisIDVisitor.visitLeaf(Key key)
           
 void DefaultKeyVisitor.visitLeaf(Key key)
           
 void KeyVisitor.visitLeaf(Key key)
          We've found a leaf node in a Key tree, and are giving the visitor a change to do processing based on it.
 

Constructors in org.crosswire.jsword.passage with parameters of type Key
DefaultKeyList(Key parent, String name)
          Simple ctor
DefaultLeafKeyList(String name, String osisName, Key parent)
          Default ctor
ReadOnlyKeyList(Key keys, boolean ignore)
          Simple ctor
SetKeyList(Set set, Key parent)
          Simple ctor
SetKeyList(Set set, Key parent, String name)
          Simple ctor
TreeKey(String name, Key parent)
          Setup with the key name and positions of data in the file
 


Copyright ยจ 2003-2006