Further consolidation of enums.

svn path=/trunk/KDE/kdeedu/libkdeedu/; revision=839941

diff --git a/keduvocdocument/keduvocconjugation.cpp b/keduvocdocument/keduvocconjugation.cpp
index 2e46e32c5489fe31c333a2101af09b85a137a541..9d164f3a6c0ed601e161daf7657ca84252224325 100644 (file)
--- a/keduvocdocument/keduvocconjugation.cpp
+++ b/keduvocdocument/keduvocconjugation.cpp
@@ -32,7 +32,7 @@
 class KEduVocConjugation::Private
 {
 public:
-    QMap<int, KEduVocText> m_conjugations;
+    QMap<KEduVocWordFlags, KEduVocText> m_conjugations;
 };
 
 
@@ -65,41 +65,23 @@ bool KEduVocConjugation::operator ==(const KEduVocConjugation& other) const
 }
 
 
-KEduVocText& KEduVocConjugation::conjugation(int index)
-{
-    return d->m_conjugations[index];
-}
-
 
-KEduVocText& KEduVocConjugation::conjugation(ConjugationPerson person, ConjugationNumber number)
+KEduVocText KEduVocConjugation::conjugation(KEduVocWordFlags flags)
 {
-    return conjugation(indexOf(person, number));
+    return d->m_conjugations.value(flags & (KEduVocWordFlag::persons | KEduVocWordFlag::numbers | KEduVocWordFlag::genders));
 }
 
-void KEduVocConjugation::setConjugation(const KEduVocText& conjugation, ConjugationPerson person, ConjugationNumber number)
+void KEduVocConjugation::setConjugation(const KEduVocText& conjugation, KEduVocWordFlags flags)
 {
-    setConjugation(conjugation, indexOf(person, number));
+    d->m_conjugations[flags & (KEduVocWordFlag::persons | KEduVocWordFlag::numbers | KEduVocWordFlag::genders)] = conjugation;
 }
 
-
-void KEduVocConjugation::setConjugation(const KEduVocText& conjugation, int index)
-{
-    d->m_conjugations[index] = conjugation;
-}
-
-
-int KEduVocConjugation::indexOf(ConjugationPerson person, ConjugationNumber number)
-{
-    return person + (ThirdNeutralCommon+1) * number;
-}
-
-
 bool KEduVocConjugation::isEmpty()
 {
     return d->m_conjugations.count() == 0;
 }
 
-QList< int > KEduVocConjugation::keys()
+QList< KEduVocWordFlags > KEduVocConjugation::keys()
 {
     return d->m_conjugations.keys();
 }
@@ -112,21 +94,30 @@ void KEduVocConjugation::toKVTML2(QDomElement & parent, const QString &tense)
         return;
     }
 
+    QMap<int, KEduVocWordFlag::Flags> numbers;
+    numbers[0] = KEduVocWordFlag::Singular;
+    numbers[1] = KEduVocWordFlag::Dual;
+    numbers[2] = KEduVocWordFlag::Plural;
+    QMap<int, KEduVocWordFlag::Flags> persons;
+    persons[0] = KEduVocWordFlag::First;
+    persons[1] = KEduVocWordFlag::Second;
+    persons[3] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Masculine);
+    persons[4] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Feminine);
+    persons[5] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Neuter);
+
     // write the tense tag
     QDomDocument domDoc = parent.ownerDocument();
     QDomElement tenseElement = domDoc.createElement( KVTML_TENSE );
     tenseElement.appendChild( domDoc.createTextNode(tense) );
     parent.appendChild(tenseElement);
 
-    for ( KEduVocConjugation::ConjugationNumber num = KEduVocConjugation::Singular; num <= KEduVocConjugation::Plural; num = KEduVocConjugation::ConjugationNumber(num +1) ) {
-
+    for ( int num = 0; num <= 2; ++num) {
         QDomElement numberElement = domDoc.createElement( KVTML_GRAMMATICAL_NUMBER[num] );
-        for ( KEduVocConjugation::ConjugationPerson person = KEduVocConjugation::First; person <= KEduVocConjugation::ThirdNeutralCommon; person = KEduVocConjugation::ConjugationPerson(person +1) ) {
-
-            if (!conjugation(indexOf(person, num)).isEmpty()) {
+        for ( int person = 0; person <= 5; ++person) {
+            if (!conjugation(numbers[num] | persons[person]).isEmpty()) {
                 QDomElement personElement = domDoc.createElement( KVTML_GRAMMATICAL_PERSON[person] );
                 numberElement.appendChild(personElement);
-                conjugation(indexOf(person, num)).toKVTML2(personElement);
+                conjugation(persons[person] | numbers[num]).toKVTML2(personElement);
             }
         }
         if (numberElement.hasChildNodes()) {
@@ -201,13 +192,25 @@ KEduVocConjugation* KEduVocConjugation::fromKVTML2(QDomElement & parent)
         return 0;
     }
 
+    QMap<int, KEduVocWordFlag::Flags> numbers;
+    numbers[0] = KEduVocWordFlag::Singular;
+    numbers[1] = KEduVocWordFlag::Dual;
+    numbers[2] = KEduVocWordFlag::Plural;
+    QMap<int, KEduVocWordFlag::Flags> persons;
+    persons[0] = KEduVocWordFlag::First;
+    persons[1] = KEduVocWordFlag::Second;
+    persons[3] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Masculine);
+    persons[4] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Feminine);
+    persons[5] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Neuter);
+
+
     KEduVocConjugation* conjugation = new KEduVocConjugation;
 
-    for ( int num = KEduVocConjugation::Singular; num <= KEduVocConjugation::Plural; num++ ) {
+    for ( int num = 0; num <= 2; num++ ) {
         QDomElement numberElement = parent.firstChildElement( KVTML_GRAMMATICAL_NUMBER[num] );
 
         if (numberElement.hasChildNodes()) {
-            for (int person = KEduVocConjugation::First; person <= KEduVocConjugation::ThirdNeutralCommon; person++) {
+            for (int person = 0; person <= 5; person++) {
                 QDomElement personElement = numberElement.firstChildElement( KVTML_GRAMMATICAL_PERSON[person] );
                 if (!personElement.isNull()) {
                     KEduVocText text;
@@ -216,7 +219,7 @@ KEduVocConjugation* KEduVocConjugation::fromKVTML2(QDomElement & parent)
                         // compatibility for kde 4.0. There the text was directly below the person, not enabling grades per conjugation form.
                         text.setText(personElement.text());
                     }
-                    conjugation->setConjugation(text, ConjugationPerson(person), KEduVocConjugation::ConjugationNumber(num));
+                    conjugation->setConjugation(text, persons[person] | numbers[num]);
                 }
             }
         }

diff --git a/keduvocdocument/keduvocconjugation.h b/keduvocdocument/keduvocconjugation.h
index c81c76b9f5dad3de2725ff61b15a8f6543a85b56..939dc378b0c4d4fe2c015442a09edbbef75429b6 100644 (file)
--- a/keduvocdocument/keduvocconjugation.h
+++ b/keduvocdocument/keduvocconjugation.h
@@ -27,6 +27,7 @@
 
 #include "libkeduvocdocument_export.h"
 #include "keduvoctext.h"
+#include "keduvocwordflags.h"
 
 #include <QtCore/QStringList>
 
@@ -37,22 +38,6 @@ class KEDUVOCDOCUMENT_EXPORT KEduVocConjugation
 {
 public:
 
-    enum ConjugationNumber {
-        Singular,
-        Dual,
-        Plural
-    };
-
-    // store third person neutral/common in the same sttr
-    enum ConjugationPerson {
-        First,
-        Second,
-        ThirdMale,
-        ThirdFemale,
-        ThirdNeutralCommon
-    };
-
-
     /**
      * The constructor
      */
@@ -65,12 +50,10 @@ public:
     KEduVocConjugation& operator = ( const KEduVocConjugation& a );
     bool operator == ( const KEduVocConjugation& a ) const;
 
-    KEduVocText& conjugation(ConjugationPerson person, ConjugationNumber number);
-    KEduVocText& conjugation(int index);
-    void setConjugation(const KEduVocText& conjugation, ConjugationPerson person, ConjugationNumber number);
-    void setConjugation(const KEduVocText& conjugation, int index);
+    KEduVocText conjugation(KEduVocWordFlags flags);
+    void setConjugation(const KEduVocText& conjugation, KEduVocWordFlags flags);
 
-    QList<int> keys();
+    QList<KEduVocWordFlags> keys();
 
     bool isEmpty();
 
@@ -87,8 +70,6 @@ public:
      */
     static KEduVocConjugation* fromKVTML2(QDomElement& parent);
 
-    static int indexOf(ConjugationPerson person, ConjugationNumber number);
-
 private:
     class Private;
     Private* const d;

diff --git a/keduvocdocument/keduvocdeclension.cpp b/keduvocdocument/keduvocdeclension.cpp
index 0b9d5fd667597fc4fc505ad1495a3418d3287ee5..327c3ed5ca9057788c4a4319afdc0e75952cbe10 100644 (file)
--- a/keduvocdocument/keduvocdeclension.cpp
+++ b/keduvocdocument/keduvocdeclension.cpp
@@ -32,7 +32,7 @@
 class KEduVocDeclension::Private
 {
 public:
-    QMap<int, KEduVocText> m_declensions;
+    QMap<KEduVocWordFlags, KEduVocText> m_declensions;
 };
 
 KEduVocDeclension::KEduVocDeclension()
@@ -57,29 +57,14 @@ KEduVocDeclension::~KEduVocDeclension()
     delete d;
 }
 
-KEduVocText& KEduVocDeclension::declension(DeclensionNumber number, DeclensionCase decCase)
+KEduVocText& KEduVocDeclension::declension(KEduVocWordFlags flags)
 {
-    return declension(indexOf(number, decCase));
+    return d->m_declensions[flags];
 }
 
-KEduVocText & KEduVocDeclension::declension(int index)
+void KEduVocDeclension::setDeclension(const KEduVocText & declension, KEduVocWordFlags flags)
 {
-    return d->m_declensions[index];
-}
-
-void KEduVocDeclension::setDeclension(const KEduVocText & declension, int index)
-{
-    d->m_declensions[index] = declension;
-}
-
-void KEduVocDeclension::setDeclension(const KEduVocText & declension, DeclensionNumber number, DeclensionCase decCase)
-{
-    setDeclension(declension, indexOf(number, decCase));
-}
-
-int KEduVocDeclension::indexOf(DeclensionNumber number, DeclensionCase decCase)
-{
-    return number * (Vocative+1) + decCase;
+    d->m_declensions[flags] = declension;
 }
 
 bool KEduVocDeclension::isEmpty()
@@ -95,11 +80,27 @@ void KEduVocDeclension::toKVTML2(QDomElement & parent)
     QDomDocument domDoc = parent.ownerDocument();
     QDomElement declensionElement = domDoc.createElement( KVTML_DECLENSION );
 
-    for ( KEduVocDeclension::DeclensionNumber num = KEduVocDeclension::Singular; num <= KEduVocDeclension::Plural; num = KEduVocDeclension::DeclensionNumber(num +1) ) {
+    QMap<int, KEduVocWordFlags> numbers;
+    numbers[0] = KEduVocWordFlag::Singular;
+    numbers[1] = KEduVocWordFlag::Dual;
+    numbers[2] = KEduVocWordFlag::Plural;
+
+    QMap<int, KEduVocWordFlags> cases;
+    cases[0] = KEduVocWordFlag::Nominative;
+    cases[1] = KEduVocWordFlag::Genitive;
+    cases[2] = KEduVocWordFlag::Dative;
+    cases[3] = KEduVocWordFlag::Accusative;
+    cases[4] = KEduVocWordFlag::Ablative;
+    cases[5] = KEduVocWordFlag::Locative;
+    cases[6] = KEduVocWordFlag::Vocative;
+
+
+
+    for ( int num = 0; num <= 2; ++num) {
         QDomElement numberElement = domDoc.createElement( KVTML_GRAMMATICAL_NUMBER[num] );
-        for ( KEduVocDeclension::DeclensionCase dcase = KEduVocDeclension::Nominative; dcase < (KEduVocDeclension::Vocative+1); dcase = KEduVocDeclension::DeclensionCase(dcase +1) ) {
+        for ( int dcase = 0; dcase <= 6; ++dcase ) {
             QDomElement caseElement = domDoc.createElement( KVTML_DECLENSION_CASE[dcase] );
-            declension(num, dcase).toKVTML2(caseElement);
+            declension(numbers[num] | cases[dcase]).toKVTML2(caseElement);
 
             if (caseElement.hasChildNodes()) {
                 numberElement.appendChild(caseElement);
@@ -122,17 +123,32 @@ KEduVocDeclension* KEduVocDeclension::fromKVTML2(QDomElement & parent)
         return 0;
     }
 
+
+    QMap<int, KEduVocWordFlags> numbers;
+    numbers[0] = KEduVocWordFlag::Singular;
+    numbers[1] = KEduVocWordFlag::Dual;
+    numbers[2] = KEduVocWordFlag::Plural;
+
+    QMap<int, KEduVocWordFlags> cases;
+    cases[0] = KEduVocWordFlag::Nominative;
+    cases[1] = KEduVocWordFlag::Genitive;
+    cases[2] = KEduVocWordFlag::Dative;
+    cases[3] = KEduVocWordFlag::Accusative;
+    cases[4] = KEduVocWordFlag::Ablative;
+    cases[5] = KEduVocWordFlag::Locative;
+    cases[6] = KEduVocWordFlag::Vocative;
+
     KEduVocDeclension* declension = new KEduVocDeclension;
 
-    for ( KEduVocDeclension::DeclensionNumber num = KEduVocDeclension::Singular; num <= KEduVocDeclension::Plural; num = KEduVocDeclension::DeclensionNumber(num +1) ) {
+    for ( int num = 0; num <= 2; ++num ) {
         QDomElement numberElement = declensionElement.firstChildElement( KVTML_GRAMMATICAL_NUMBER[num] );
         if (!numberElement.isNull()) {
-            for ( KEduVocDeclension::DeclensionCase dcase = KEduVocDeclension::Nominative; dcase <= KEduVocDeclension::Vocative; dcase = DeclensionCase(dcase +1) ) {
+            for ( int dcase = 0; dcase <= 6; ++dcase) {
                 QDomElement caseElement = numberElement.firstChildElement( KVTML_DECLENSION_CASE[dcase] );
                 if (!caseElement.isNull()) {
                     KEduVocText text;
                     text.fromKVTML2(caseElement);
-                    declension->setDeclension(text, num, dcase);
+                    declension->setDeclension(text, numbers[num] | cases[dcase]);
                 }
             }
         }

diff --git a/keduvocdocument/keduvocdeclension.h b/keduvocdocument/keduvocdeclension.h
index ff6eeb0bf1ddec7b74ec9053c9bf5d16d65495dc..3ac3f3de2f08797a136a0274910ec2ba9c08d560 100644 (file)
--- a/keduvocdocument/keduvocdeclension.h
+++ b/keduvocdocument/keduvocdeclension.h
@@ -26,6 +26,7 @@
 #include "libkeduvocdocument_export.h"
 
 #include "keduvoctext.h"
+#include "keduvocwordflags.h"
 
 /**
 A declension contains all forms that a NOUN possibly can have.
@@ -34,21 +35,6 @@ A declension contains all forms that a NOUN possibly can have.
 */
 class KEDUVOCDOCUMENT_EXPORT KEduVocDeclension{
 public:
-    enum DeclensionNumber {
-        Singular = 0,
-        Dual,
-        Plural
-    };
-
-    enum DeclensionCase {
-        Nominative = 0,
-        Genitive,
-        Dative,
-        Accusative,
-        Ablative,
-        Locative,
-        Vocative
-    };
 
     /**
      * The constructor without arguments
@@ -81,8 +67,7 @@ public:
      * @param decCase
      * @return
      */
-    KEduVocText& declension(DeclensionNumber number, DeclensionCase decCase);
-    KEduVocText& declension(int index);
+    KEduVocText& declension(KEduVocWordFlags flags);
 
     /**
      * Set a declension
@@ -90,28 +75,24 @@ public:
      * @param number
      * @param decCase
      */
-    void setDeclension(const KEduVocText& declension, DeclensionNumber number, DeclensionCase decCase);
-
-    void setDeclension(const KEduVocText& declension, int index);
+    void setDeclension(const KEduVocText& declension, KEduVocWordFlags flags);
 
     bool isEmpty();
 
 
     /**
      * Create xml for this declension
-     * @param parent 
+     * @param parent
      */
     void toKVTML2(QDomElement& parent);
 
     /**
      * Reads a declension from xml, returns 0 if it is empty
-     * @param parent 
-     * @return 
+     * @param parent
+     * @return
      */
     static KEduVocDeclension* fromKVTML2(QDomElement& parent);
 
-    static int indexOf(DeclensionNumber number, DeclensionCase decCase);
-
 private:
     class Private;
     Private * const d;

diff --git a/keduvocdocument/keduvockvtml2reader.cpp b/keduvocdocument/keduvockvtml2reader.cpp
index ff95c569dd088faba6255041d975af63e71b2e8e..3a17592ff5fffe06e210d77fe115f67ea5e87802 100644 (file)
--- a/keduvocdocument/keduvockvtml2reader.cpp
+++ b/keduvocdocument/keduvockvtml2reader.cpp
@@ -694,27 +694,36 @@ bool KEduVocKvtml2Reader::readPersonalPronoun(QDomElement & pronounElement, KEdu
 
     QDomElement personElement = pronounElement.firstChildElement( KVTML_GRAMMATICAL_NUMBER[0] );
     if ( !personElement.isNull() ) {
-        readPersonalPronounChild( personElement, pronoun, KEduVocConjugation::Singular );
+        readPersonalPronounChild( personElement, pronoun, KEduVocWordFlag::Singular );
     }
 
     personElement = pronounElement.firstChildElement( KVTML_GRAMMATICAL_NUMBER[1] );
     if ( !personElement.isNull() ) {
-        readPersonalPronounChild( personElement, pronoun, KEduVocConjugation::Dual );
+        readPersonalPronounChild( personElement, pronoun, KEduVocWordFlag::Dual );
     }
 
     personElement = pronounElement.firstChildElement( KVTML_GRAMMATICAL_NUMBER[2] );
     if ( !personElement.isNull() ) {
-        readPersonalPronounChild( personElement, pronoun, KEduVocConjugation::Plural );
+        readPersonalPronounChild( personElement, pronoun, KEduVocWordFlag::Plural );
     }
     return true;
 }
 
 
-bool KEduVocKvtml2Reader::readPersonalPronounChild(QDomElement & personElement, KEduVocPersonalPronoun & pronoun, KEduVocConjugation::ConjugationNumber number)
+bool KEduVocKvtml2Reader::readPersonalPronounChild(QDomElement & personElement, KEduVocPersonalPronoun & pronoun, KEduVocWordFlags number)
 {
-    for (int person = KEduVocConjugation::First; person <= KEduVocConjugation::ThirdNeutralCommon; person++) {
+    QMap<int, KEduVocWordFlag::Flags> persons;
+    persons[0] = KEduVocWordFlag::First;
+    persons[1] = KEduVocWordFlag::Second;
+    persons[3] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Masculine);
+    persons[4] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Feminine);
+    persons[5] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Neuter);
+
+
+
+    for (int person = 0; person <= 5; person++) {
         QDomElement currentElement = personElement.firstChildElement( KVTML_GRAMMATICAL_PERSON[person] );
-        pronoun.setPersonalPronoun( currentElement.text(), KEduVocConjugation::ConjugationPerson(person), number );
+        pronoun.setPersonalPronoun( currentElement.text(), persons[person] | number );
     }
 
     return true;

diff --git a/keduvocdocument/keduvockvtml2reader.h b/keduvocdocument/keduvockvtml2reader.h
index 8f2ac84ed5f5664245e2b428366ec7404956bcfb..1213e5991615dfae57a3c5b930f2587c8ca18bfd 100644 (file)
--- a/keduvocdocument/keduvockvtml2reader.h
+++ b/keduvocdocument/keduvockvtml2reader.h
@@ -77,7 +77,7 @@ private:
 
     bool readPersonalPronoun( QDomElement &conjugElement, KEduVocPersonalPronoun &pronoun );
 
-    bool readPersonalPronounChild(QDomElement & personElement, KEduVocPersonalPronoun & pronoun, KEduVocConjugation::ConjugationNumber number);
+    bool readPersonalPronounChild(QDomElement & personElement, KEduVocPersonalPronoun &pronoun, KEduVocWordFlags flags);
 
     /** read the types
      * @param typesElement QDomElement for the types group
@@ -97,9 +97,9 @@ private:
 
     /**
      * Read all <container> tags within a word type definition.
-     * @param parentContainer 
-     * @param lessonElement 
-     * @return 
+     * @param parentContainer
+     * @param lessonElement
+     * @return
      */
     bool readChildWordTypes( KEduVocWordType* parentContainer, QDomElement &lessonElement );
 
@@ -137,9 +137,9 @@ private:
 
     /**
      * Read <lesson> tags.
-     * @param parentLesson 
-     * @param lessonElement 
-     * @return 
+     * @param parentLesson
+     * @param lessonElement
+     * @return
      */
     bool readChildLessons( KEduVocLesson* parentLesson, QDomElement &lessonElement );
 

diff --git a/keduvocdocument/keduvockvtml2writer.cpp b/keduvocdocument/keduvockvtml2writer.cpp
index b5fdec666b1cdb93e4830750978bf7c1db4788f5..f6c058dfef89f6176f1db258498b9bb2906368b6 100644 (file)
--- a/keduvocdocument/keduvockvtml2writer.cpp
+++ b/keduvocdocument/keduvockvtml2writer.cpp
@@ -636,11 +636,25 @@ bool KEduVocKvtml2Writer::writePersonalPronoun(QDomElement & pronounElement, con
         pronounElement.appendChild( m_domDoc.createElement( KVTML_DUAL_EXISTS ) );
     }
 
+
+    QMap<int, KEduVocWordFlag::Flags> numbers;
+    numbers[0] = KEduVocWordFlag::Singular;
+    numbers[1] = KEduVocWordFlag::Dual;
+    numbers[2] = KEduVocWordFlag::Plural;
+    QMap<int, KEduVocWordFlag::Flags> persons;
+    persons[0] = KEduVocWordFlag::First;
+    persons[1] = KEduVocWordFlag::Second;
+    persons[3] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Masculine);
+    persons[4] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Feminine);
+    persons[5] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Neuter);
+
+
+
     // the actual pronouns
-    for ( int num = KEduVocConjugation::Singular; num <= KEduVocConjugation::Plural; num++ ) {
+    for ( int num = 0; num <= 2; num++ ) {
         QDomElement numberElement = m_domDoc.createElement( KVTML_GRAMMATICAL_NUMBER[num] );
-        for ( int person = KEduVocConjugation::First; person <= KEduVocConjugation::ThirdNeutralCommon; person++ ) {
-            QString pronounString = pronoun.personalPronoun(KEduVocConjugation::ConjugationPerson(person), KEduVocConjugation::ConjugationNumber(num));
+        for ( int person = 0; person <= 5; person++ ) {
+            QString pronounString = pronoun.personalPronoun(numbers[num] | persons[person]);
             if (!pronounString.isEmpty()) {
                 numberElement.appendChild( newTextElement( KVTML_GRAMMATICAL_PERSON[person], pronounString ));
             }

diff --git a/keduvocdocument/keduvockvtmlreader.cpp b/keduvocdocument/keduvockvtmlreader.cpp
index 82f5b58b91b05e550e229798f0b2230223b20e6b..e63d87a07933cb025f9aef20d2a6459597d14240 100644 (file)
--- a/keduvocdocument/keduvockvtmlreader.cpp
+++ b/keduvocdocument/keduvockvtmlreader.cpp
@@ -458,34 +458,34 @@ bool KEduVocKvtmlReader::readConjugation( QDomElement &domElementParent, KEduVoc
     // type - the tense?
     // finally the person
 
-    const KEduVocConjugation::ConjugationNumber numS = KEduVocConjugation::Singular;
-    const KEduVocConjugation::ConjugationNumber numP = KEduVocConjugation::Plural;
+    const KEduVocWordFlags numS = KEduVocWordFlag::Singular;
+    const KEduVocWordFlags numP = KEduVocWordFlag::Plural;
 
-    conjugation.setConjugation( pers1_sing, KEduVocConjugation::First, numS);
-    conjugation.setConjugation( pers2_sing, KEduVocConjugation::Second, numS);
-    conjugation.setConjugation( pers1_plur, KEduVocConjugation::First, numP);
-    conjugation.setConjugation( pers2_plur, KEduVocConjugation::Second, numP);
+    conjugation.setConjugation( pers1_sing, KEduVocWordFlag::First | numS);
+    conjugation.setConjugation( pers2_sing, KEduVocWordFlag::Second | numS);
+    conjugation.setConjugation( pers1_plur, KEduVocWordFlag::First | numP);
+    conjugation.setConjugation( pers2_plur, KEduVocWordFlag::Second | numP);
 
     if ( s3_common ) {
-        conjugation.setConjugation( pers3_f_sing, KEduVocConjugation::ThirdNeutralCommon, KEduVocConjugation::Singular );
+        conjugation.setConjugation( pers3_f_sing, KEduVocWordFlag::Third | KEduVocWordFlag::Neuter | KEduVocWordFlag::Singular );
     } else  {
         conjugation.setConjugation( pers3_m_sing,
-            KEduVocConjugation::ThirdMale, KEduVocConjugation::Singular );
+            KEduVocWordFlag::Third | KEduVocWordFlag::Masculine | KEduVocWordFlag::Singular );
         conjugation.setConjugation( pers3_f_sing,
-            KEduVocConjugation::ThirdFemale, KEduVocConjugation::Singular );
+            KEduVocWordFlag::Third | KEduVocWordFlag::Feminine | KEduVocWordFlag::Singular );
         conjugation.setConjugation( pers3_n_sing,
-            KEduVocConjugation::ThirdNeutralCommon, KEduVocConjugation::Singular );
+            KEduVocWordFlag::Third | KEduVocWordFlag::Neuter |  KEduVocWordFlag::Singular );
     }
 
     if ( p3_common ) {
-        conjugation.setConjugation( pers3_f_plur, KEduVocConjugation::ThirdNeutralCommon, KEduVocConjugation::Plural );
+        conjugation.setConjugation( pers3_f_plur, KEduVocWordFlag::Third | KEduVocWordFlag::Neuter | KEduVocWordFlag::Plural );
     } else  {
         conjugation.setConjugation( pers3_m_plur,
-            KEduVocConjugation::ThirdMale, KEduVocConjugation::Plural );
+            KEduVocWordFlag::Third | KEduVocWordFlag::Masculine | KEduVocWordFlag::Plural );
         conjugation.setConjugation( pers3_f_plur,
-            KEduVocConjugation::ThirdFemale, KEduVocConjugation::Plural );
+            KEduVocWordFlag::Third | KEduVocWordFlag::Feminine | KEduVocWordFlag::Plural );
         conjugation.setConjugation( pers3_n_plur,
-            KEduVocConjugation::ThirdNeutralCommon, KEduVocConjugation::Plural );
+            KEduVocWordFlag::Third | KEduVocWordFlag::Neuter | KEduVocWordFlag::Plural );
     }
 
     return true;
@@ -566,37 +566,37 @@ bool KEduVocKvtmlReader::readPersonalPronouns( QDomElement &domElementParent, KE
     // type - the tense?
     // finally the person
 
-    const KEduVocConjugation::ConjugationNumber numS = KEduVocConjugation::Singular;
+    KEduVocWordFlags numS = KEduVocWordFlag::Singular;
     pronouns.setMaleFemaleDifferent(false);
-    pronouns.setPersonalPronoun( pers1_sing, KEduVocConjugation::First, numS );
-    pronouns.setPersonalPronoun( pers2_sing, KEduVocConjugation::Second, numS );
+    pronouns.setPersonalPronoun( pers1_sing, KEduVocWordFlag::First | numS );
+    pronouns.setPersonalPronoun( pers2_sing, KEduVocWordFlag::Second | numS );
 
     // used to have common in female
     if ( s3_common ) {
-        pronouns.setPersonalPronoun( pers3_f_sing, KEduVocConjugation::ThirdNeutralCommon, numS );
+        pronouns.setPersonalPronoun( pers3_f_sing, KEduVocWordFlag::Third | KEduVocWordFlag::Neuter | numS );
     } else  {
         pronouns.setPersonalPronoun( pers3_m_sing,
-            KEduVocConjugation::ThirdMale, numS );
+            KEduVocWordFlag::Third | KEduVocWordFlag::Masculine | numS );
         pronouns.setPersonalPronoun( pers3_f_sing,
-            KEduVocConjugation::ThirdFemale, numS );
+            KEduVocWordFlag::Third | KEduVocWordFlag::Feminine | numS );
         pronouns.setPersonalPronoun( pers3_n_sing,
-            KEduVocConjugation::ThirdNeutralCommon, numS );
+            KEduVocWordFlag::Third | KEduVocWordFlag::Neuter | numS );
         pronouns.setMaleFemaleDifferent(true);
     }
 
-    const KEduVocConjugation::ConjugationNumber numP = KEduVocConjugation::Plural;
+    KEduVocWordFlags numP = KEduVocWordFlag::Plural;
 
-    pronouns.setPersonalPronoun( pers1_plur, KEduVocConjugation::First, numP );
-    pronouns.setPersonalPronoun( pers2_plur, KEduVocConjugation::Second, numP );
+    pronouns.setPersonalPronoun( pers1_plur, KEduVocWordFlag::First | numP );
+    pronouns.setPersonalPronoun( pers2_plur, KEduVocWordFlag::Second | numP );
     if ( p3_common ) {
-        pronouns.setPersonalPronoun( pers3_f_plur, KEduVocConjugation::ThirdNeutralCommon, numP );
+        pronouns.setPersonalPronoun( pers3_f_plur, KEduVocWordFlag::Third | KEduVocWordFlag::Neuter | numP );
     } else  {
         pronouns.setPersonalPronoun( pers3_m_plur,
-            KEduVocConjugation::ThirdMale, numP );
+            KEduVocWordFlag::Third | KEduVocWordFlag::Masculine | numP );
         pronouns.setPersonalPronoun( pers3_f_plur,
-            KEduVocConjugation::ThirdFemale, numP );
+            KEduVocWordFlag::Third | KEduVocWordFlag::Feminine | numP );
         pronouns.setPersonalPronoun( pers3_n_plur,
-            KEduVocConjugation::ThirdNeutralCommon, numP );
+            KEduVocWordFlag::Third | KEduVocWordFlag::Neuter | numP );
         pronouns.setMaleFemaleDifferent(true);
     }
 

diff --git a/keduvocdocument/keduvockvtmlwriter.cpp b/keduvocdocument/keduvockvtmlwriter.cpp
index b47f7b1a6e62bc261c8ef39ba51a6be86163fb91..bd2a61dd69ac600ea8cc7f0194877f8dad51fa9a 100644 (file)
--- a/keduvocdocument/keduvockvtmlwriter.cpp
+++ b/keduvocdocument/keduvockvtmlwriter.cpp
@@ -347,7 +347,7 @@ bool KEduVocKvtmlWriter::writeArticle( QDomElement &domElementParent )
 
         QString articleString;
         // female
-        articleString = m_doc->identifier(i).article().article( KEduVocWordFlag::Singular, KEduVocWordFlag::Definite, KEduVocWordFlag::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 );
@@ -355,7 +355,7 @@ bool KEduVocKvtmlWriter::writeArticle( QDomElement &domElementParent )
             domElementFD.appendChild( domTextFD );
             domElementEntry.appendChild( domElementFD );
         }
-        articleString = m_doc->identifier(i).article().article( KEduVocWordFlag::Singular, KEduVocWordFlag::Indefinite, KEduVocWordFlag::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 );
@@ -366,7 +366,7 @@ bool KEduVocKvtmlWriter::writeArticle( QDomElement &domElementParent )
 
 
         // male
-        articleString = m_doc->identifier(i).article().article( KEduVocWordFlag::Singular, KEduVocWordFlag::Definite, KEduVocWordFlag::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 );
@@ -374,7 +374,7 @@ bool KEduVocKvtmlWriter::writeArticle( QDomElement &domElementParent )
             domElementMD.appendChild( domTextMD );
             domElementEntry.appendChild( domElementMD );
         }
-        articleString = m_doc->identifier(i).article().article( KEduVocWordFlag::Singular, KEduVocWordFlag::Indefinite, KEduVocWordFlag::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 );
@@ -384,7 +384,7 @@ bool KEduVocKvtmlWriter::writeArticle( QDomElement &domElementParent )
         }
 
         // neutral
-        articleString = m_doc->identifier(i).article().article( KEduVocWordFlag::Singular, KEduVocWordFlag::Definite, KEduVocWordFlag::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 );
@@ -392,7 +392,7 @@ bool KEduVocKvtmlWriter::writeArticle( QDomElement &domElementParent )
             domElementND.appendChild( domTextND );
             domElementEntry.appendChild( domElementND );
         }
-        articleString = m_doc->identifier(i).article().article( KEduVocWordFlag::Singular, KEduVocWordFlag::Indefinite, KEduVocWordFlag::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 );
@@ -829,14 +829,14 @@ bool KEduVocKvtmlWriter::writePersonalPronouns( QDomElement &domElementParent, Q
 bool KEduVocKvtmlWriter::writePersonalPronounChild( QDomElement &domElementParent, const KEduVocPersonalPronoun &curr_conjug )
 {
     // the old stuff only has singular
-    const KEduVocConjugation::ConjugationNumber num = KEduVocConjugation::Singular;
+    const KEduVocWordFlag::ConjugationNumber num = KEduVocWordFlag::Singular;
 
-    if ( !curr_conjug.personalPronoun( KEduVocConjugation::First, num ).isEmpty() ) {
-        domElementParent.appendChild( newTextElement( KV_CON_P1S, curr_conjug.personalPronoun( KEduVocConjugation::First, num ) ) );
+    if ( !curr_conjug.personalPronoun( KEduVocWordFlag::First, num ).isEmpty() ) {
+        domElementParent.appendChild( newTextElement( KV_CON_P1S, curr_conjug.personalPronoun( KEduVocWordFlag::First, num ) ) );
     }
 
-    if ( !curr_conjug.personalPronoun( KEduVocConjugation::Second, num ).isEmpty() ) {
-        domElementParent.appendChild( newTextElement( KV_CON_P2S, curr_conjug.personalPronoun( KEduVocConjugation::Second, num ) ) );
+    if ( !curr_conjug.personalPronoun( KEduVocWordFlag::Second, num ).isEmpty() ) {
+        domElementParent.appendChild( newTextElement( KV_CON_P2S, curr_conjug.personalPronoun( KEduVocWordFlag::Second, num ) ) );
     }
 
     ///@todo if the writer ever becomes enabled, write the other pronouns

diff --git a/keduvocdocument/keduvocpersonalpronoun.cpp b/keduvocdocument/keduvocpersonalpronoun.cpp
index aa66ab6230b617aa81a52940ccc8c601414e61bb..3ab354ed65a80c0699924662516e6fbdb5646d88 100644 (file)
--- a/keduvocdocument/keduvocpersonalpronoun.cpp
+++ b/keduvocdocument/keduvocpersonalpronoun.cpp
@@ -24,7 +24,7 @@ public:
     bool m_maleFemaleDifferent;
     bool m_neutralExists;
     bool m_dualExists;
-    QMap<int, QString> m_personalpronouns;
+    QMap<KEduVocWordFlags, QString> m_personalpronouns;
 };
 
 
@@ -75,26 +75,17 @@ bool KEduVocPersonalPronoun::operator ==(const KEduVocPersonalPronoun& other) co
 }
 
 
-QString KEduVocPersonalPronoun::personalPronoun(KEduVocConjugation::ConjugationPerson person, KEduVocConjugation::ConjugationNumber number) const
+QString KEduVocPersonalPronoun::personalPronoun(KEduVocWordFlags flags) const
 {
-    int index = indexOf(person, number);
-    if ( d->m_personalpronouns.contains(index) ) {
-        return d->m_personalpronouns.value(index);
-    }
-    return QString();
+        return d->m_personalpronouns.value(flags & (KEduVocWordFlag::persons | KEduVocWordFlag::numbers));
 }
 
-void KEduVocPersonalPronoun::setPersonalPronoun(const QString & personalpronoun, KEduVocConjugation::ConjugationPerson person, KEduVocConjugation::ConjugationNumber number)
+void KEduVocPersonalPronoun::setPersonalPronoun(const QString & personalpronoun, KEduVocWordFlags flags)
 {
-    d->m_personalpronouns[indexOf(person, number)] = personalpronoun;
+        d->m_personalpronouns[flags & (KEduVocWordFlag::persons | KEduVocWordFlag::numbers)] = personalpronoun;
 }
 
 
-int KEduVocPersonalPronoun::indexOf(KEduVocConjugation::ConjugationPerson person, KEduVocConjugation::ConjugationNumber number) const
-{
-    return person + (KEduVocConjugation::ThirdNeutralCommon+1) * number;
-}
-
 bool KEduVocPersonalPronoun::maleFemaleDifferent() const
 {
     return d->m_maleFemaleDifferent;

diff --git a/keduvocdocument/keduvocpersonalpronoun.h b/keduvocdocument/keduvocpersonalpronoun.h
index d5638fcd63fd5b486be3f6ae913d261c473ca385..94b50cda4169cbf430480c1e1b6c35de5ff03415 100644 (file)
--- a/keduvocdocument/keduvocpersonalpronoun.h
+++ b/keduvocdocument/keduvocpersonalpronoun.h
@@ -38,8 +38,8 @@ public:
     KEduVocPersonalPronoun& operator = ( const KEduVocPersonalPronoun& a );
     bool operator == ( const KEduVocPersonalPronoun& a ) const;
 
-    QString personalPronoun(KEduVocConjugation::ConjugationPerson person, KEduVocConjugation::ConjugationNumber number) const;
-    void setPersonalPronoun(const QString& conjugation, KEduVocConjugation::ConjugationPerson person, KEduVocConjugation::ConjugationNumber number);
+    QString personalPronoun(KEduVocWordFlags flags) const;
+    void setPersonalPronoun(const QString& conjugation, KEduVocWordFlags flags);
 
     bool maleFemaleDifferent() const;
     void setMaleFemaleDifferent(bool different);
@@ -53,7 +53,6 @@ private:
     class Private;
     Private* const d;
 
-    int indexOf(KEduVocConjugation::ConjugationPerson person, KEduVocConjugation::ConjugationNumber number) const;
 };
 
 

diff --git a/keduvocdocument/keduvocwordflags.h b/keduvocdocument/keduvocwordflags.h
index 0a397350fc8eaf86c5b4a8f45345c6027e7da3e4..321c29d99f8ba6de63e7d715abc8917a1bd05a07 100644 (file)
--- a/keduvocdocument/keduvocwordflags.h
+++ b/keduvocdocument/keduvocwordflags.h
@@ -41,19 +41,33 @@ public:
         Adverb = 0x1000,
         Article = 0x2000,
         Conjunction = 0x4000,
-        OtherPartOfSpeech = 0x8000,
+
+        // Person
+        First = 0x10000,
+        Second = 0x20000,
+        Third = 0x40000,
+
+        // Declension Case
+        Nominative = 0x80000,
+        Genitive = 0x100000,
+        Dative = 0x200000,
+        Accusative = 0x400000,
+        Ablative = 0x800000,
+        Locative = 0x1000000,
+        Vocative = 0x2000000,
 
         // 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
+        Definite = 0x4000000, // The article is definite
+        Indefinite = 0x8000000, // The article is indefinite
+        Regular = 0x10000000,
+        Irregular = 0x20000000
     };
 
     static const Flags genders = (Flags)(Masculine | Feminine | Neuter);
-    static const Flags partsOfSpeech =(Flags)(Noun | Verb | Article | Pronoun | Adjective | Adverb | Conjunction | OtherPartOfSpeech);
+    static const Flags partsOfSpeech =(Flags)(Noun | Verb | Article | Pronoun | Adjective | Adverb | Conjunction);
     static const Flags numbers = (Flags)(Singular | Plural | Dual);
+    static const Flags cases = (Flags)(Nominative|Genitive|Dative|Accusative|Ablative|Locative|Vocative);
+    static const Flags persons = (Flags)(First | Second | Third);
 };
 
 Q_DECLARE_FLAGS(KEduVocWordFlags, KEduVocWordFlag::Flags)

diff --git a/keduvocdocument/tests/keduvocdocumentvalidatortest.cpp b/keduvocdocument/tests/keduvocdocumentvalidatortest.cpp
index 50809995f3ffbf54dd8aa6cb4a24ebe8492a747c..601b69d172552f0a4cbd778e23dd864321d63864 100644 (file)
--- a/keduvocdocument/tests/keduvocdocumentvalidatortest.cpp
+++ b/keduvocdocument/tests/keduvocdocumentvalidatortest.cpp
@@ -191,8 +191,8 @@ void KEduVocDocumentValidatorTest::testDeclensions()
 void KEduVocDocumentValidatorTest::testConjugations()
 {
     KEduVocConjugation conjugation;
-    conjugation.setConjugation(KEduVocText("first-singular"), KEduVocConjugation::First, KEduVocConjugation::Singular);
-    QCOMPARE(conjugation.conjugation(KEduVocConjugation::First, KEduVocConjugation::Singular).text(), QString("first-singular"));
+    conjugation.setConjugation(KEduVocText("first-singular"), KEduVocWordFlag::First, KEduVocWordFlag::Singular);
+    QCOMPARE(conjugation.conjugation(KEduVocWordFlag::First, KEduVocWordFlag::Singular).text(), QString("first-singular"));
 
     QDomDocument doc = QDomDocument("test doc");
     QDomElement root = doc.createElement( "kvtml" );
@@ -201,9 +201,9 @@ void KEduVocDocumentValidatorTest::testConjugations()
 
     qDebug() << root.text();
 
-    KEduVocConjugation *con2 = KEduVocConjugation::fromKVTML2(root);
+    KEduVocConjugation *con2 = KEduVocWordFlag::fromKVTML2(root);
 
-    QCOMPARE(conjugation.conjugation(KEduVocConjugation::First, KEduVocConjugation::Singular).text(), con2->conjugation(KEduVocConjugation::First, KEduVocConjugation::Singular).text());
+    QCOMPARE(conjugation.conjugation(KEduVocWordFlag::First, KEduVocWordFlag::Singular).text(), con2->conjugation(KEduVocWordFlag::First, KEduVocWordFlag::Singular).text());
     delete con2;
 }