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

Packages that use Key

Package	Description
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.
org.crosswire.jsword.versification	The core responsibility of the versification package is to understand verse references.

Uses of Key in org.crosswire.jsword.book

Fields in org.crosswire.jsword.book declared as Key

Modifier and Type	Field and Description
private Key	BookData.key What key was used to create this data

Methods in org.crosswire.jsword.book that return Key

Modifier and Type	Method and Description
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.getScope() Get a complete list of entries.
Key	Book.getValidKey(String name) Get a Key for the name, if possible.

Methods in org.crosswire.jsword.book with parameters of type Key

Modifier and Type	Method and Description
boolean	Book.contains(Key key) Returns true if this book contains the specified element.
Iterator<org.jdom2.Content>	Book.getOsisIterator(Key key, boolean allowEmpty, boolean allowGenTitles) 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 String	OSISUtil.getReferences(Book book, Key key, Versification v11n, org.jdom2.Element root) A space separate string containing osisID from the reference element.
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

Constructor and Description
BookData(Book[] books, Key key, boolean compare) Create BookData for multiple books.
BookData(Book book, Key key) Create a BookData.

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

Methods in org.crosswire.jsword.book.basic that return Key

Modifier and Type	Method and Description
Key	AbstractPassageBook.createEmptyKeyList()
Key	AbstractBook.find(SearchRequest request)
Key	AbstractBook.find(String request)
Key	AbstractPassageBook.getKey(String text)
Key	AbstractBook.getScope()
Key	AbstractPassageBook.getValidKey(String name)

Methods in org.crosswire.jsword.book.basic with parameters of type Key

Modifier and Type	Method and Description
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, boolean allowGenTitles)
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

Modifier and Type	Method and Description
List<org.jdom2.Content>	SourceFilter.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

Modifier and Type	Method and Description
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.BookTitleStartTag.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

Modifier and Type	Method and Description
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

Modifier and Type	Method and Description
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

Modifier and Type	Field and Description
private Key	CustomHandler.key The book being parsed.

Methods in org.crosswire.jsword.book.filter.thml with parameters of type Key

Modifier and Type	Method and Description
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

Constructor and Description
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

Modifier and Type	Class and Description
class	ReadingsKey For a readings dictionary the keys are dates.

Fields in org.crosswire.jsword.book.readings declared as Key

Modifier and Type	Field and Description
private Key	ReadingsBook.global The global key list

Fields in org.crosswire.jsword.book.readings with type parameters of type Key

Modifier and Type	Field and Description
private Map<Key,String>	ReadingsBook.hash The store of keys and data

Methods in org.crosswire.jsword.book.readings that return Key

Modifier and Type	Method and Description
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

Modifier and Type	Method and Description
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, boolean allowGenTitles)
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

Constructor and Description
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

Modifier and Type	Class and Description
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

Modifier and Type	Field and Description
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

Modifier and Type	Field and Description
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

Modifier and Type	Method and Description
Key	SwordGenBook.createEmptyKeyList()
Key	SwordDictionary.createEmptyKeyList()
Key	RawLDBackend.get(int index)
Key	ZVerseBackend.getGlobalKeyList()
Key	SwordGenBook.getGlobalKeyList()
Key	SwordDictionary.getGlobalKeyList()
Key	SwordBook.getGlobalKeyList()
Key	RawBackend.getGlobalKeyList()
Key	NullBackend.getGlobalKeyList()
Key	Backend.getGlobalKeyList() Gets the fast global key list, and if this operation is not supported, throws a UnsupportedOperationException
Key	AbstractBackend.getGlobalKeyList()
Key	SwordGenBook.getKey(String text)
Key	SwordDictionary.getKey(String text)
Key	AbstractKeyBackend.getParent()
Key	SwordDailyDevotion.getPreferred()
Key	SwordBook.getScope()
Key	SwordGenBook.getValidKey(String name)
Key	SwordDictionary.getValidKey(String name)
Key	NullBackend.readIndex()
Key	GenBookBackend.readIndex()
Key	Backend.readIndex() Deprecated. no replacement
Key	AbstractBackend.readIndex()

Methods in org.crosswire.jsword.book.sword that return types with arguments of type Key

Modifier and Type	Method and Description
Iterator<Key>	AbstractKeyBackend.iterator()

Methods in org.crosswire.jsword.book.sword with parameters of type Key

Modifier and Type	Method and Description
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	NullBackend.contains(Key key)
boolean	GenBookBackend.contains(Key key)
boolean	Backend.contains(Key key) Determine whether this Book contains the key in question
boolean	AbstractKeyBackend.contains(Key key)
abstract boolean	AbstractBackend.contains(Key key)
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, boolean allowGenTitle)
Iterator<org.jdom2.Content>	SwordDictionary.getOsisIterator(Key key, boolean allowEmpty, boolean allowGenTitles)
String	SwordGenBook.getRawText(Key key)
String	SwordDictionary.getRawText(Key key)
String	SwordBook.getRawText(Key key)
String	NullBackend.getRawText(Key key)
String	Backend.getRawText(Key key) Get the text as it is found in the Book for the given key
String	AbstractBackend.getRawText(Key key)
String	RawBackend.getRawText(RawBackendState state, Key key)
int	ZVerseBackend.getRawTextLength(Key key)
int	RawLDBackend.getRawTextLength(Key key)
int	RawBackend.getRawTextLength(Key key)
int	NullBackend.getRawTextLength(Key key)
int	GenBookBackend.getRawTextLength(Key key)
int	Backend.getRawTextLength(Key key) Determine the size of the raw data for the key in question.
int	AbstractBackend.getRawTextLength(Key key)
int	RawLDBackend.indexOf(Key that)
private void	AbstractBackend.readNormalOsis(Key key, RawTextToXmlProcessor processor, List<org.jdom2.Content> content, T openFileState)
private void	AbstractBackend.readNormalOsisSingleKey(Key key, RawTextToXmlProcessor processor, List<org.jdom2.Content> content, T openFileState) Avoid using iterator for GenBook TreeKeys which would cause a GenBook nodes children to be appended to their parent e.g.
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	NullBackend.readToOsis(Key key, RawTextToXmlProcessor processor)
List<org.jdom2.Content>	Backend.readToOsis(Key key, RawTextToXmlProcessor processor) Get the text allotted for the given entry
List<org.jdom2.Content>	AbstractBackend.readToOsis(Key key, RawTextToXmlProcessor processor)
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	NullBackend.setAliasKey(Key alias, Key source)
void	Backend.setAliasKey(Key alias, Key source)
void	AbstractBackend.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

Modifier and Type	Method and Description
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

Modifier and Type	Field and Description
private Key	BibleScope.inScope
private Key	BibleScope.outScope

Methods in org.crosswire.jsword.bridge that return Key

Modifier and Type	Method and Description
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

Modifier and Type	Method and Description
String	BookLookup.locate(Key key)

Uses of Key in org.crosswire.jsword.examples

Methods in org.crosswire.jsword.examples with parameters of type Key

Modifier and Type	Method and Description
void	StrongsAnalysis.analyze(StrongsMapSet sms, Book book, List<Key> errors, Key wholeBible)
private static void	GatherAllReferences.readBook(Book book, Key set) Perform a test read on an iterator over a set of keys
private static void	GatherAllReferences.readKey(Book book, Key key, int[] stats) Perform a test read on a single key
private static void	ReadEverything.testReadMultiple(Book book, Key set) Perform a test read on an iterator over a set of keys
private static void	ReadEverything.testReadSingle(Book book, Key key, int entry) Perform a test read on a single key

Method parameters in org.crosswire.jsword.examples with type arguments of type Key

Modifier and Type	Method and Description
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

Modifier and Type	Method and Description
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

Modifier and Type	Field and Description
private Key	VerseCollector.results

Methods in org.crosswire.jsword.index.lucene that return Key

Modifier and Type	Method and Description
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

Modifier and Type	Method and Description
private void	LuceneIndex.generateSearchIndexImpl(Progress job, List<Key> errors, org.apache.lucene.index.IndexWriter writer, Key key, int count, IndexPolicy policy) Dig down into a Key indexing as we go.

Method parameters in org.crosswire.jsword.index.lucene with type arguments of type Key

Modifier and Type	Method and Description
private void	LuceneIndex.generateSearchIndexImpl(Progress job, List<Key> errors, org.apache.lucene.index.IndexWriter writer, Key key, int count, IndexPolicy policy) Dig down into a Key indexing as we go.

Constructors in org.crosswire.jsword.index.lucene with parameters of type Key

Constructor and Description
VerseCollector(Versification v11n, 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

Modifier and Type	Method and Description
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

Modifier and Type	Method and Description
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

Modifier and Type	Interface and Description
interface	Passage A Passage is a specialized Collection of Verses.
interface	VerseKey<T extends VerseKey> A VerseKey indicates that a Key has a Versification reference system.

Classes in org.crosswire.jsword.passage that implement Key

Modifier and Type	Class and Description
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

Modifier and Type	Field and Description
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

Modifier and Type	Field and Description
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 SortedSet<Key>	DistinctPassage.store The place the real data is stored

Methods in org.crosswire.jsword.passage that return Key

Modifier and Type	Method and Description
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	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	PassageTally.VerseIterator.next()
Key	PassageTally.OrderedVerseIterator.next()
Key	KeyIterator.next()
Key	BitwisePassage.VerseIterator.next()

Methods in org.crosswire.jsword.passage that return types with arguments of type Key

Modifier and Type	Method and Description
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()

Methods in org.crosswire.jsword.passage with parameters of type Key

Modifier and Type	Method and Description
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)
Passage	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.
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 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

Constructor and Description
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

Constructor and Description
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
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

Uses of Key in org.crosswire.jsword.versification

Methods in org.crosswire.jsword.versification with parameters of type Key

Modifier and Type	Method and Description
private List<QualifiedKey>	VersificationToKJVMapper.getQualifiedKeys(Key leftKey)