keduvocvokabelnreader.cpp
keduvocwqlreader.cpp
keduvocxdxfreader.cpp
- sharedkvtmlfiles.cpp )
+ sharedkvtmlfiles.cpp
+ )
kde4_add_library(keduvocdocument SHARED ${keduvocdocument_LIB_SRCS})
***************************************************************************/
#include "keduvocarticle.h"
+#include "keduvocwordflags.h"
#include <QtCore/QMap>
#include <KDebug>
class KEduVocArticle::Private
{
public:
- QMap <int, QString> m_articles;
+ QMap <KEduVocWordFlags, QString> m_articles;
};
KEduVocArticle::KEduVocArticle()
KEduVocArticle::KEduVocArticle( const QString &fem_def, const QString &fem_indef, const QString &mal_def, const QString &mal_indef, const QString &neu_def, const QString &neu_indef )
:d( new Private )
{
- setArticle( mal_def, Singular, Definite, Masculine );
- setArticle( fem_def, Singular, Definite, Feminine );
- setArticle( neu_def, Singular, Definite, Neutral );
+ setArticle( mal_def, KEduVocWordFlag::Singular | KEduVocWordFlag::Definite | KEduVocWordFlag::Masculine );
+ setArticle( fem_def, KEduVocWordFlag::Singular | KEduVocWordFlag::Definite | KEduVocWordFlag::Feminine );
+ setArticle( neu_def, KEduVocWordFlag::Singular | KEduVocWordFlag::Definite | KEduVocWordFlag::Neuter );
- setArticle( mal_indef, Singular, Indefinite, Masculine );
- setArticle( fem_indef, Singular, Indefinite, Feminine );
- setArticle( neu_indef, Singular, Indefinite, Neutral );
+ setArticle( mal_indef, KEduVocWordFlag::Singular | KEduVocWordFlag::Indefinite | KEduVocWordFlag::Masculine );
+ setArticle( fem_indef, KEduVocWordFlag::Singular | KEduVocWordFlag::Indefinite | KEduVocWordFlag::Feminine );
+ setArticle( neu_indef, KEduVocWordFlag::Singular | KEduVocWordFlag::Indefinite | KEduVocWordFlag::Neuter );
}
KEduVocArticle::~KEduVocArticle()
}
-QString KEduVocArticle::article(ArticleNumber number, ArticleDefiniteness definite, ArticleGender gender)
+QString KEduVocArticle::article(const KEduVocWordFlags& flags)
{
- if ( d->m_articles.contains( indexOf(number, definite, gender) ) ) {
- return d->m_articles.value( indexOf(number, definite, gender) );
- }
- return QString();
+ return d->m_articles.value(flags);
}
-void KEduVocArticle::setArticle(const QString & article, ArticleNumber number, ArticleDefiniteness definite, ArticleGender gender)
+void KEduVocArticle::setArticle(const QString & article, const KEduVocWordFlags& flags)
{
- setArticle(article, indexOf(number, definite, gender));
+ d->m_articles[flags] = article;
}
-void KEduVocArticle::setArticle(const QString & article, int index)
-{
- d->m_articles[index] = article;
-}
-
-int KEduVocArticle::indexOf(ArticleNumber number, ArticleDefiniteness definite, ArticleGender gender)
-{
- return number + (definite * (Plural+1)) + (gender * (Plural+1) * (Indefinite+1));
-}
bool KEduVocArticle::isArticle(const QString & article) const
{
#include <QtCore/QStringList>
+#include "keduvocwordflags.h"
+
+class KEduVocWordType;
/**
* Class representing the articles of a language
*
{
public:
- enum ArticleNumber {
- Singular,
- Dual,
- Plural
- };
-
- enum ArticleGender {
- Masculine,
- Feminine,
- Neutral
- };
-
- enum ArticleDefiniteness {
- Definite,
- Indefinite
- };
/**
*/
KEduVocArticle &operator= ( const KEduVocArticle& other );
+ QString article(const KEduVocWordFlags&);
- QString article(ArticleNumber number, ArticleDefiniteness definite, ArticleGender gender);
-
- void setArticle(const QString& article, ArticleNumber number, ArticleDefiniteness definite, ArticleGender gender);
-
- void setArticle(const QString& article, int index);
+ void setArticle(const QString& article, const KEduVocWordFlags&);
bool isArticle(const QString& article) const;
bool isEmpty();
- static int indexOf(ArticleNumber number, ArticleDefiniteness definite, ArticleGender gender);
-
class Private;
Private * const d;
};
</article>
*/
{
- // singular
- for ( KEduVocArticle::ArticleNumber num = KEduVocArticle::Singular; num <= KEduVocArticle::Plural; num = KEduVocArticle::ArticleNumber(num+1) ) {
+ QMap<int, KEduVocWordFlag::Flags> numbers;
+ numbers[0] = KEduVocWordFlag::Singular;
+ numbers[1] = KEduVocWordFlag::Dual;
+ numbers[2] = KEduVocWordFlag::Plural;
+ QMap<int, KEduVocWordFlag::Flags> genders;
+ genders[0] = KEduVocWordFlag::Masculine;
+ genders[1] = KEduVocWordFlag::Feminine;
+ genders[2] = KEduVocWordFlag::Neuter;
+ QMap<int, KEduVocWordFlag::Flags> defs;
+ defs[0] = KEduVocWordFlag::Definite;
+ defs[1] = KEduVocWordFlag::Indefinite;
+
+
+ for ( int num = 0; num <= 2; ++num) {
QDomElement numberElement = articleElement.firstChildElement( KVTML_GRAMMATICAL_NUMBER[num] );
if (!numberElement.isNull()) {
// definite
- for ( KEduVocArticle::ArticleDefiniteness def = KEduVocArticle::Definite; def <= KEduVocArticle::Indefinite; def = KEduVocArticle::ArticleDefiniteness(def+1) ) {
+ for ( int def = 0; def <= 1; ++def ) {
QDomElement defElement = numberElement.firstChildElement( KVTML_GRAMMATICAL_DEFINITENESS[def] );
if (!defElement.isNull()) {
// male
- for ( KEduVocArticle::ArticleGender gen = KEduVocArticle::Masculine; gen <= KEduVocArticle::Neutral; gen = KEduVocArticle::ArticleGender(gen+1) ) {
+ for ( int gen = 0; gen <= 2; ++gen ) {
QDomElement genderElement = defElement.firstChildElement( KVTML_GRAMMATICAL_GENDER[gen] );
if (!genderElement.isNull()) {
- m_doc->identifier(identifierNum).article().setArticle( genderElement.text(), KEduVocArticle::indexOf(num, def, gen) );
+ m_doc->identifier(identifierNum).article().setArticle( genderElement.text(), numbers[num] | defs[def] | genders[gen]);
}
}
}
if ( !specialType.isEmpty() ) {
// get the localized version
if ( specialType == KVTML_SPECIALWORDTYPE_NOUN ) {
- wordTypeContainer->setWordType(KEduVocWordType::Noun);
+ wordTypeContainer->setWordType(KEduVocWordFlag::Noun);
}
if ( specialType == KVTML_SPECIALWORDTYPE_VERB ) {
- wordTypeContainer->setWordType(KEduVocWordType::Verb);
+ wordTypeContainer->setWordType(KEduVocWordFlag::Verb);
}
if ( specialType == KVTML_SPECIALWORDTYPE_ADVERB ) {
- wordTypeContainer->setWordType(KEduVocWordType::Adverb);
+ wordTypeContainer->setWordType(KEduVocWordFlag::Adverb);
}
if ( specialType == KVTML_SPECIALWORDTYPE_ADJECTIVE ) {
- wordTypeContainer->setWordType(KEduVocWordType::Adjective);
+ wordTypeContainer->setWordType(KEduVocWordFlag::Adjective);
}
if ( specialType == KVTML_SPECIALWORDTYPE_NOUN_MALE ) {
- wordTypeContainer->setWordType(KEduVocWordType::NounMale);
+ wordTypeContainer->setWordType(KEduVocWordFlag::Noun | KEduVocWordFlag::Masculine);
}
if ( specialType == KVTML_SPECIALWORDTYPE_NOUN_FEMALE ) {
- wordTypeContainer->setWordType(KEduVocWordType::NounFemale);
+ wordTypeContainer->setWordType(KEduVocWordFlag::Noun | KEduVocWordFlag::Feminine);
}
if ( specialType == KVTML_SPECIALWORDTYPE_NOUN_NEUTRAL ) {
- wordTypeContainer->setWordType(KEduVocWordType::NounNeutral);
+ wordTypeContainer->setWordType(KEduVocWordFlag::Noun| KEduVocWordFlag::Neuter);
}
} // special type
bool KEduVocKvtml2Writer::writeArticle( QDomElement &articleElement, int language )
{
///@todo only write if not empty
- for (int num = KEduVocArticle::Singular; num <= KEduVocArticle::Plural; num++)
+ QMap<int, KEduVocWordFlag::Flags> numbers;
+ numbers[0] = KEduVocWordFlag::Singular;
+ numbers[1] = KEduVocWordFlag::Dual;
+ numbers[2] = KEduVocWordFlag::Plural;
+ QMap<int, KEduVocWordFlag::Flags> genders;
+ genders[0] = KEduVocWordFlag::Masculine;
+ genders[1] = KEduVocWordFlag::Feminine;
+ genders[2] = KEduVocWordFlag::Neuter;
+ QMap<int, KEduVocWordFlag::Flags> defs;
+ defs[0] = KEduVocWordFlag::Definite;
+ defs[1] = KEduVocWordFlag::Indefinite;
+
+ for (int num = 0; num <= 2; num++)
{
QDomElement numberElement = m_domDoc.createElement( KVTML_GRAMMATICAL_NUMBER[num] );
- for (int def = KEduVocArticle::Definite; def <= KEduVocArticle::Indefinite; def++) {
+ for (int def = 0; def <= 1; def++) {
QDomElement defElement = m_domDoc.createElement( KVTML_GRAMMATICAL_DEFINITENESS[def] );
- for (int gen = KEduVocArticle::Masculine; gen <= KEduVocArticle::Neutral; gen++)
+ for (int gen = 0; gen <= 2; gen++)
{
- QString articleString = m_doc->identifier(language).article().article( KEduVocArticle::ArticleNumber(num), KEduVocArticle::ArticleDefiniteness(def), KEduVocArticle::ArticleGender(gen) );
+ QString articleString = m_doc->identifier(language).article().article(numbers[num] | genders[gen] | defs[def]);
if ( !articleString.isEmpty() ) {
defElement.appendChild( newTextElement( KVTML_GRAMMATICAL_GENDER[gen], articleString ) );
}
QDomElement typeDefinitionElement = m_domDoc.createElement( KVTML_CONTAINER );
typeDefinitionElement.appendChild( newTextElement( KVTML_NAME, wordType->name() ) );
- switch (wordType->wordType()) {
- case KEduVocWordType::Noun:
- typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_NOUN ) );
- break;
- case KEduVocWordType::NounMale:
- typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_NOUN_MALE ) );
- break;
- case KEduVocWordType::NounFemale:
- typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_NOUN_FEMALE ) );
- break;
- case KEduVocWordType::NounNeutral:
- typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_NOUN_NEUTRAL ) );
- break;
- case KEduVocWordType::Verb:
+ if (wordType->wordType().testFlag(KEduVocWordFlag::Noun))
+ {
+ if (wordType->wordType().testFlag(KEduVocWordFlag::Masculine))
+ typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_NOUN_MALE ) );
+
+ else if (wordType->wordType().testFlag(KEduVocWordFlag::Feminine))
+ typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_NOUN_FEMALE ) );
+
+ else if (wordType->wordType().testFlag(KEduVocWordFlag::Neuter))
+ typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_NOUN_NEUTRAL ) );
+ else
+ typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_NOUN ) );
+ }
+ else if (wordType->wordType().testFlag(KEduVocWordFlag::Verb))
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_VERB ) );
- break;
- case KEduVocWordType::Adjective:
+
+ else if (wordType->wordType().testFlag(KEduVocWordFlag::Adjective))
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_ADJECTIVE ) );
- break;
- case KEduVocWordType::Adverb:
+
+ else if (wordType->wordType().testFlag(KEduVocWordFlag::Adverb))
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_ADVERB ) );
- break;
- default:
- // no special type, no tag
- break;
- }
// child entries
parent->appendChildContainer(wordType);
m_userdefinedTypeCounter++;
}
- static_cast<KEduVocWordType*>(parent->childContainer(4))->setWordType(KEduVocWordType::Adjective);
- static_cast<KEduVocWordType*>(parent->childContainer(5))->setWordType(KEduVocWordType::Adverb);
+ static_cast<KEduVocWordType*>(parent->childContainer(4))->setWordType(KEduVocWordFlag::Adjective);
+ static_cast<KEduVocWordType*>(parent->childContainer(5))->setWordType(KEduVocWordFlag::Adverb);
KEduVocWordType* numeral = static_cast<KEduVocWordType*>(parent->childContainer(8));
KEduVocWordType* wordType = new KEduVocWordType(
i18nc( "@item:inlistbox A subtype of the grammatical word type: Numeral Ordinal (first, second, third, ...)","Ordinal" ), numeral);
+ wordType->setWordType(KEduVocWordFlag::Adjective);
numeral->appendChildContainer(wordType);
wordType = new KEduVocWordType(
i18nc( "@item:inlistbox A subtype of the grammatical word type: Numeral Cardinal (one, two, three, ...)","Cardinal" ), numeral);
+
+ wordType->setWordType(KEduVocWordFlag::Adjective);
numeral->appendChildContainer(wordType);
KEduVocWordType* article = static_cast<KEduVocWordType*>(parent->childContainer(3));
wordType = new KEduVocWordType(i18nc( "@item:inlistbox A subtype of the grammatical word type: Article (the)","Definite" ), article);
+ wordType->setWordType(KEduVocWordFlag::Article | KEduVocWordFlag::Definite);
article->appendChildContainer(wordType);
wordType = new KEduVocWordType(i18nc( "@item:inlistbox A subtype of the grammatical word type: Article (a)","Indefinite" ), article);
+ wordType->setWordType(KEduVocWordFlag::Article | KEduVocWordFlag::Indefinite);
article->appendChildContainer(wordType);
KEduVocWordType* verb = static_cast<KEduVocWordType*>(parent->childContainer(0));
- verb->setWordType(KEduVocWordType::Verb);
+ verb->setWordType(KEduVocWordFlag::Verb);
wordType = new KEduVocWordType(i18nc( "@item:inlistbox A subtype of the grammatical word type: Verb with regular conjugation","Regular" ), verb);
- wordType->setWordType(KEduVocWordType::Verb);
+ wordType->setWordType(KEduVocWordFlag::Verb | KEduVocWordFlag::Regular);
verb->appendChildContainer(wordType);
wordType = new KEduVocWordType(i18nc( "@item:inlistbox A subtype of the grammatical word type: Verb with irregular conjugation","Irregular" ), verb);
verb->appendChildContainer(wordType);
- wordType->setWordType(KEduVocWordType::Verb);
+ wordType->setWordType(KEduVocWordFlag::Verb | KEduVocWordFlag::Irregular);
KEduVocWordType* noun = static_cast<KEduVocWordType*>(parent->childContainer(1));
- noun->setWordType(KEduVocWordType::Noun);
+ noun->setWordType(KEduVocWordFlag::Noun);
wordType = new KEduVocWordType(i18nc( "@item:inlistbox A subtype of the grammatical word type: Noun", "Male" ), noun);
noun->appendChildContainer(wordType);
- wordType->setWordType(KEduVocWordType::NounMale);
+ wordType->setWordType(KEduVocWordFlag::Noun | KEduVocWordFlag::Masculine);
wordType = new KEduVocWordType(i18nc( "@item:inlistbox A subtype of the grammatical word type: Noun", "Female" ), noun);
noun->appendChildContainer(wordType);
- wordType->setWordType(KEduVocWordType::NounFemale);
+ wordType->setWordType(KEduVocWordFlag::Noun | KEduVocWordFlag::Feminine);
wordType = new KEduVocWordType(i18nc( "@item:inlistbox A subtype of the grammatical word type: Noun", "Neutral" ), noun);
noun->appendChildContainer(wordType);
- wordType->setWordType(KEduVocWordType::NounNeutral);
+ wordType->setWordType(KEduVocWordFlag::Noun | KEduVocWordFlag::Neuter);
KEduVocWordType* pronoun = static_cast<KEduVocWordType*>(parent->childContainer(6));
wordType = new KEduVocWordType(i18nc( "@item:inlistbox A subtype of the grammatical word type: Pronoun (my, your, his, her...)", "Possessive" ), pronoun);
+ wordType->setWordType(KEduVocWordFlag::Pronoun);
pronoun->appendChildContainer(wordType);
wordType = new KEduVocWordType(i18nc( "@item:inlistbox A subtype of the grammatical word type: Pronoun (I, you, he...)", "Personal" ), pronoun);
+ wordType->setWordType(KEduVocWordFlag::Pronoun);
pronoun->appendChildContainer(wordType);
}
QString articleString;
// female
- articleString = m_doc->identifier(i).article().article( KEduVocArticle::Singular, KEduVocArticle::Definite, KEduVocArticle::Feminine );
+ articleString = m_doc->identifier(i).article().article( KEduVocWordFlag::Singular, KEduVocWordFlag::Definite, KEduVocWordFlag::Feminine );
if ( !articleString.isEmpty() ) {
QDomElement domElementFD = m_domDoc.createElement( KV_ART_FD );
QDomText domTextFD = m_domDoc.createTextNode( articleString );
domElementFD.appendChild( domTextFD );
domElementEntry.appendChild( domElementFD );
}
- articleString = m_doc->identifier(i).article().article( KEduVocArticle::Singular, KEduVocArticle::Indefinite, KEduVocArticle::Feminine );
+ articleString = m_doc->identifier(i).article().article( KEduVocWordFlag::Singular, KEduVocWordFlag::Indefinite, KEduVocWordFlag::Feminine );
if ( !articleString.isEmpty() ) {
QDomElement domElementFI = m_domDoc.createElement( KV_ART_FI );
QDomText domTextFI = m_domDoc.createTextNode( articleString );
// male
- articleString = m_doc->identifier(i).article().article( KEduVocArticle::Singular, KEduVocArticle::Definite, KEduVocArticle::Masculine );
+ articleString = m_doc->identifier(i).article().article( KEduVocWordFlag::Singular, KEduVocWordFlag::Definite, KEduVocWordFlag::Masculine );
if ( !articleString.isEmpty() ) {
QDomElement domElementMD = m_domDoc.createElement( KV_ART_MD );
QDomText domTextMD = m_domDoc.createTextNode( articleString );
domElementMD.appendChild( domTextMD );
domElementEntry.appendChild( domElementMD );
}
- articleString = m_doc->identifier(i).article().article( KEduVocArticle::Singular, KEduVocArticle::Indefinite, KEduVocArticle::Masculine );
+ articleString = m_doc->identifier(i).article().article( KEduVocWordFlag::Singular, KEduVocWordFlag::Indefinite, KEduVocWordFlag::Masculine );
if ( !articleString.isEmpty() ) {
QDomElement domElementMI = m_domDoc.createElement( KV_ART_MI );
QDomText domTextMI = m_domDoc.createTextNode( articleString );
}
// neutral
- articleString = m_doc->identifier(i).article().article( KEduVocArticle::Singular, KEduVocArticle::Definite, KEduVocArticle::Neutral );
+ articleString = m_doc->identifier(i).article().article( KEduVocWordFlag::Singular, KEduVocWordFlag::Definite, KEduVocWordFlag::Neutral );
if ( !articleString.isEmpty() ) {
QDomElement domElementND = m_domDoc.createElement( KV_ART_ND );
QDomText domTextND = m_domDoc.createTextNode( articleString );
domElementND.appendChild( domTextND );
domElementEntry.appendChild( domElementND );
}
- articleString = m_doc->identifier(i).article().article( KEduVocArticle::Singular, KEduVocArticle::Indefinite, KEduVocArticle::Neutral );
+ articleString = m_doc->identifier(i).article().article( KEduVocWordFlag::Singular, KEduVocWordFlag::Indefinite, KEduVocWordFlag::Neutral );
if ( !articleString.isEmpty() ) {
QDomElement domElementNI = m_domDoc.createElement( KV_ART_NI );
QDomText domTextNI = m_domDoc.createTextNode( articleString );
--- /dev/null
+//
+// C++ Interface: keduvocwordflags
+//
+// Description:
+//
+//
+// Author: David Capel <wot.narg@gmail.com>, (C) 2008
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+
+#ifndef KEDUVOCWORDFLAGS_H
+#define KEDUVOCWORDFLAGS_H
+
+#include <QFlags>
+
+class KEduVocWordFlag
+{
+public:
+ enum Flags
+ {
+ // This is used for both empty flags and to denote no flags of the correct type were set.
+ NoInformation = 0x0,
+
+ // Gender
+ Masculine = 0x1,
+ Feminine = 0x2,
+ Neuter = 0x4,
+
+ // Plurality
+ Singular = 0x10,
+ Dual = 0x20,
+ Plural = 0x40,
+
+ // Part of Speech
+ Verb = 0x100,
+ Noun = 0x200,
+ Pronoun = 0x400,
+ Adjective = 0x800,
+ Adverb = 0x1000,
+ Article = 0x2000,
+ Conjunction = 0x4000,
+ OtherPartOfSpeech = 0x8000,
+
+ // Other assorted flags
+ Regular = 0x10000, // Regular verb conjugation
+ Irregular = 0x20000, // Irregular verb conjugation
+ Phrase = 0x40000, // The 'word' is actually a phrase
+ Definite = 0x80000, // The article is definite
+ Indefinite = 0x100000, // The article is indefinite
+ };
+
+ static const Flags genders = (Flags)(Masculine | Feminine | Neuter);
+ static const Flags partsOfSpeech =(Flags)(Noun | Verb | Article | Pronoun | Adjective | Adverb | Conjunction | OtherPartOfSpeech);
+ static const Flags numbers = (Flags)(Singular | Plural | Dual);
+};
+
+Q_DECLARE_FLAGS(KEduVocWordFlags, KEduVocWordFlag::Flags);
+Q_DECLARE_OPERATORS_FOR_FLAGS(KEduVocWordFlags);
+
+
+#endif
class KEduVocWordType::Private
{
public:
- EnumWordType m_wordType;
- // cache the entries
+ // bitvector of word type flags
+ KEduVocWordFlags m_flags;
QList<KEduVocExpression*> m_expressions;
// list of translations
QList<KEduVocTranslation*> m_translations;
KEduVocWordType::KEduVocWordType(const QString& name, KEduVocWordType *parent)
: KEduVocContainer(name, WordType, parent), d( new Private )
-{
- d->m_wordType = General;
-}
+{}
KEduVocWordType::~KEduVocWordType()
{
return entries().value(row);
}
-void KEduVocWordType::setWordType(EnumWordType type)
+KEduVocWordFlags KEduVocWordType::wordType() const
{
- d->m_wordType = type;
+ return d->m_flags;
}
-KEduVocWordType::EnumWordType KEduVocWordType::wordType() const
+void KEduVocWordType::setWordType(KEduVocWordFlags flags)
{
- return d->m_wordType;
+ d->m_flags = flags;
}
-KEduVocWordType* KEduVocWordType::childOfType(KEduVocWordType::EnumWordType type)
+KEduVocWordType* KEduVocWordType::childOfType(const KEduVocWordFlags& flags)
{
- if(wordType()==type) {
+ if(d->m_flags == flags) {
return this;
}
foreach(KEduVocContainer* child, childContainers()) {
- KEduVocWordType* result = static_cast<KEduVocWordType*>(child)->childOfType(type);
+ KEduVocWordType* result = static_cast<KEduVocWordType*>(child)->childOfType(flags);
if(result) {
return result;
}
#include "keduvoccontainer.h"
+#include "keduvocwordflags.h"
+
#include <QtCore/QList>
#include <QtCore/QString>
{
public:
- enum EnumWordType {
- General,
- Noun,
- NounMale,
- NounFemale,
- NounNeutral,
- Verb,
- Adjective,
- Adverb
- };
-
/** default constructor */
explicit KEduVocWordType(const QString& name, KEduVocWordType *parent = 0);
/**
* Internally (different from the name) the class can have one of the preset word types. These are used to determine special properties (verbs have conjugations available for example).
- * @param type
+ * @param type
*/
- void setWordType(EnumWordType type);
+ void setWordType(KEduVocWordFlags flags);
/**
- * Return the meta word type for this class.
- * @return
+ * Return the raw WordTypeFlags. Returns NoInformation if no flags are set.
+ * @return WordTypeFlags
*/
- KEduVocWordType::EnumWordType wordType() const;
+ KEduVocWordFlags wordType() const;
/**
* Return a child class (or this class) that is of the specified type. Returns 0 if no class of that type is found.
- * @param type
- * @return
+ * @param type
+ * @return
*/
- KEduVocWordType* childOfType(KEduVocWordType::EnumWordType type);
+ KEduVocWordType* childOfType(const KEduVocWordFlags& flags);
/**
* The word type class does keep track of individual translations, because for one entry, the translations can have different word types (eg. genders of nouns tend to be different in different langues).
- * @param row
- * @return
+ * @param row
+ * @return
*/
KEduVocTranslation * translation(int row);
/**
* get a list of all entries in the lesson
* @param recursive include entries in sublessons
- * @return
+ * @return
*/
QList < KEduVocExpression* > entries(EnumEntriesRecursive recursive = NotRecursive);
GIT / libqmvoc.git / commitdiff