Changeset 838 for code

Timestamp:

Feb 27, 2008, 12:54:00 AM (17 years ago)

Author:

landauf

Message:

changed naming in Language: translation → localisation, name → label

Location:

code/branches/core/src/orxonox/core

Files:

• ConfigValueContainer.cc (modified) (1 diff)
• ConfigValueContainer.h (modified) (1 diff)
• CorePrereqs.h (modified) (1 diff)
• Language.cc (modified) (9 diffs)
• Language.h (modified) (5 diffs)

code/branches/core/src/orxonox/core/ConfigValueContainer.cc

@@ -959 +959 @@
     std::string ConfigValueContainer::getDescription() const
     {
-        return Language::getLanguage().getTranslation(this->description_);
+        return Language::getLanguage().getLocalisation(this->description_);
     }
 }

code/branches/core/src/orxonox/core/ConfigValueContainer.h

@@ -150 +150 @@
 
             bool bAddedDescription_;                            //!< True if a description was added
-            LanguageEntryName description_;                     //!< The description
+            LanguageEntryLabel description_;                    //!< The description
     };
 }

code/branches/core/src/orxonox/core/CorePrereqs.h

@@ -65 +65 @@
 namespace orxonox
 {
-  typedef std::string LanguageEntryName;
+  typedef std::string LanguageEntryLabel;
 
   class ArgReader;

code/branches/core/src/orxonox/core/Language.cc

@@ -50 +50 @@
 
         this->fallbackEntry_ = fallbackEntry;
-        this->translatedEntry_ = fallbackEntry; // Set the translation to the fallback entry, for the case that no translation gets assigned
-        this->bTranslationSet_ = false;
-    }
-
-    /**
-        @brief Sets the translation of the entry.
-        @param translation The translation
-    */
-    void LanguageEntry::setTranslation(const std::string& translation)
+        this->localisedEntry_ = fallbackEntry; // Set the localisation to the fallback entry, for the case that no translation gets assigned
+        this->bLocalisationSet_ = false;
+    }
+
+    /**
+        @brief Sets the localisation of the entry.
+        @param localisation The localisation
+    */
+    void LanguageEntry::setLocalisation(const std::string& localisation)
     {
         // Check if the translation is more than just an empty string
-        if (translation.compare("") != 0)
-        {
-            this->translatedEntry_ = translation;
-            this->bTranslationSet_ = true;
+        if (localisation.compare("") != 0)
+        {
+            this->localisedEntry_ = localisation;
+            this->bLocalisationSet_ = true;
         }
         else
-            this->translatedEntry_ = this->fallbackEntry_;
+            this->localisedEntry_ = this->fallbackEntry_;
     }
 
@@ -77 +77 @@
     {
         // If the default entry changes and the translation wasn't set yet, use the new default entry as translation
-        if (!this->bTranslationSet_)
-            this->translatedEntry_ = fallbackEntry;
+        if (!this->bLocalisationSet_)
+            this->localisedEntry_ = fallbackEntry;
 
         this->fallbackEntry_ = fallbackEntry;
@@ -94 +94 @@
 
         this->defaultLanguage_ = "default";
-        this->defaultTranslation_ = "ERROR: LANGUAGE ENTRY DOESN'T EXIST!";
+        this->defaultLocalisation_ = "ERROR: LANGUAGE ENTRY DOESN'T EXIST!";
 
         // Read the default language file to create all known LanguageEntry objects
@@ -132 +132 @@
 
     /**
-        @brief Creates a new LanguageEntry with a given name and a given default entry.
-        @param name The name of the entry
+        @brief Creates a new LanguageEntry with a given label and a given default entry.
+        @param label The label of the entry
         @param entry The default entry
         @return The created LanguageEntry object
     */
-    LanguageEntry* Language::createEntry(const LanguageEntryName& name, const std::string& entry)
-    {
-        std::map<std::string, LanguageEntry*>::const_iterator it = this->languageEntries_.find(name);
+    LanguageEntry* Language::createEntry(const LanguageEntryLabel& label, const std::string& entry)
+    {
+        std::map<std::string, LanguageEntry*>::const_iterator it = this->languageEntries_.find(label);
 
         // Make sure we don't create a duplicate entry
@@ -145 +145 @@
         {
             LanguageEntry* newEntry = new LanguageEntry(entry);
-            newEntry->setName(name);
-            this->languageEntries_[name] = newEntry;
+            newEntry->setName(label);
+            this->languageEntries_[label] = newEntry;
             return newEntry;
         }
 
-        COUT(2) << "Warning: Language entry " << name << " is duplicate in " << getFileName(this->defaultLanguage_) << "!" << std::endl;
+        COUT(2) << "Warning: Language entry " << label << " is duplicate in " << getFileName(this->defaultLanguage_) << "!" << std::endl;
         return it->second;
     }
@@ -156 +156 @@
     /**
         @brief Adds a new LanguageEntry, if it's not already existing.
-        @param name The name of the entry
+        @param label The label of the entry
         @param entry The default entry
     */
-    void Language::addEntry(const LanguageEntryName& name, const std::string& entry)
-    {
-        COUT(5) << "Language: Called addEntry with\n  name: " << name << "\n  entry: " <<  entry << std::endl;
-        std::map<std::string, LanguageEntry*>::const_iterator it = this->languageEntries_.find(name);
+    void Language::addEntry(const LanguageEntryLabel& label, const std::string& entry)
+    {
+        COUT(5) << "Language: Called addEntry with\n  label: " << label << "\n  entry: " <<  entry << std::endl;
+        std::map<std::string, LanguageEntry*>::const_iterator it = this->languageEntries_.find(label);
         if (it == this->languageEntries_.end())
         {
             // The entry isn't available yet, meaning it's new, so create it
-            this->createEntry(name, entry);
+            this->createEntry(label, entry);
         }
         else if (it->second->getDefault().compare(entry) == 0)
@@ -185 +185 @@
 
     /**
-        @brief Returns the translation of a given entry.
-        @param name The name of the entry
-        @return The translation
-    */
-    const std::string& Language::getTranslation(const LanguageEntryName& name) const
-    {
-        std::map<std::string, LanguageEntry*>::const_iterator it = this->languageEntries_.find(name);
+        @brief Returns the localisation of a given entry.
+        @param label The label of the entry
+        @return The localisation
+    */
+    const std::string& Language::getLocalisation(const LanguageEntryLabel& label) const
+    {
+        std::map<std::string, LanguageEntry*>::const_iterator it = this->languageEntries_.find(label);
         if (it != this->languageEntries_.end())
-            return it->second->getTranslation();
+            return it->second->getLocalisation();
         else
         {
             // Uh, oh, an undefined entry was requested: return the default string
-            COUT(2) << "Warning: Language entry \"" << name << "\" not found!" << std::endl;
-            return this->defaultTranslation_;
+            COUT(2) << "Warning: Language entry \"" << label << "\" not found!" << std::endl;
+            return this->defaultLocalisation_;
         }
     }
@@ -260 +260 @@
 
     /**
-        @brief Reads the language file of the configured language and assigns the translations to the corresponding LanguageEntry object.
+        @brief Reads the language file of the configured language and assigns the localisation to the corresponding LanguageEntry object.
     */
     void Language::readTranslatedLanguageFile()
@@ -299 +299 @@
                     // Check if the entry exists
                     if (it != this->languageEntries_.end())
-                        it->second->setTranslation(lineString.substr(pos + 1));
+                        it->second->setLocalisation(lineString.substr(pos + 1));
                     else
-                        this->createEntry(lineString.substr(0, pos), this->defaultTranslation_)->setTranslation(lineString.substr(pos + 1));
+                        this->createEntry(lineString.substr(0, pos), this->defaultLocalisation_)->setLocalisation(lineString.substr(pos + 1));
                 }
                 else

code/branches/core/src/orxonox/core/Language.h

@@ -30 +30 @@
     @brief Definition of the Language and the LanguageEntry class.
 
-    The Language class is used, to get a translation of a string in the configured language.
-    The string is identified by another string, the name of the entry.
+    The Language class is used, to get a localisation of a string in the configured language.
+    The string is identified by another string, the label of the entry.
     If the translation in the configured language isn't available, the default entry, defined in the code, is used.
 
     Usage:
      - Set the entry with the default string:
-       Language::getLanguage()->addEntry("name of the entry", "the string to translate");
+       Language::getLanguage()->addEntry("label of the entry", "the string to translate");
 
-     - Get the translation of the entry in the configured language:
-       std::cout << Language::getLanguage()->getTranslation("name of the entry") << std::endl;
+     - Get the localisation of the entry in the configured language:
+       std::cout << Language::getLanguage()->getLocalisation("name of the entry") << std::endl;
 */
 
@@ -61 +61 @@
         public:
             explicit LanguageEntry(const std::string& fallbackEntry);
-            void setTranslation(const std::string& translation);
+            void setLocalisation(const std::string& localisation);
             void setDefault(const std::string& fallbackEntry);
 
             /**
-              @brief Returns the translated entry in the configured language.
+              @brief Returns the localised entry in the configured language.
               @return The translated entry
             */
-            inline const std::string& getTranslation()
-                { return this->translatedEntry_; }
+            inline const std::string& getLocalisation()
+                { return this->localisedEntry_; }
 
             /**
@@ -80 +80 @@
         private:
             std::string fallbackEntry_;                             //!< The default entry: Used, if no translation is available or no language configured
-            std::string translatedEntry_;                           //!< The translated entry in the configured language
-            bool bTranslationSet_;                                  //!< True if the translation was set
+            std::string localisedEntry_;                            //!< The localised entry in the configured language
+            bool bLocalisationSet_;                                 //!< True if the translation was set
     };
     template class _CoreExport orxonox::ClassIdentifier<LanguageEntry>;
@@ -99 +99 @@
             static Language& getLanguage();
             void setConfigValues();
-            void addEntry(const LanguageEntryName& name, const std::string& entry);
-            const std::string& getTranslation(const LanguageEntryName& name) const;
+            void addEntry(const LanguageEntryLabel& label, const std::string& entry);
+            const std::string& getLocalisation(const LanguageEntryLabel& label) const;
 
         private:
@@ -111 +111 @@
             void writeDefaultLanguageFile() const;
             static const std::string getFileName(const std::string& language);
-            LanguageEntry* createEntry(const LanguageEntryName& name, const std::string& entry);
+            LanguageEntry* createEntry(const LanguageEntryLabel& label, const std::string& entry);
 
             std::string language_;                                  //!< The configured language
             std::string defaultLanguage_;                           //!< The default language
-            std::string defaultTranslation_;                        //!< The returned string, if an entry unavailable entry is requested
-            std::map<std::string, LanguageEntry*> languageEntries_; //!< A map to store all LanguageEntry objects and their name
+            std::string defaultLocalisation_;                       //!< The returned string, if an entry unavailable entry is requested
+            std::map<std::string, LanguageEntry*> languageEntries_; //!< A map to store all LanguageEntry objects and their labels
     };
     template class _CoreExport orxonox::ClassIdentifier<Language>;