Update Bliss::Lexicon & some related classes to return Core::Status (#121)

Author: curufinwe

Modules.make

@@ -148,6 +148,7 @@ endif
 # ****** Libraries ******
 LIBS_SEARCH = src/Search/libSprintSearch.$(a)
 LIBS_SEARCH += src/Search/LexiconfreeTimesyncBeamSearch/libSprintLexiconfreeTimesyncBeamSearch.$(a)
+LIBS_SEARCH += src/Search/TreeTimesyncBeamSearch/libSprintTreeTimesyncBeamSearch.$(a)
 ifdef MODULE_SEARCH_WFST
 LIBS_SEARCH += src/Search/Wfst/libSprintSearchWfst.$(a)
 LIBS_SEARCH += src/OpenFst/libSprintOpenFst.$(a)

src/Bliss/Lexicon.cc

@@ -13,10 +13,12 @@
  *  limitations under the License.
  */
 // $Id$
-
+#include <chrono>
 #include <unordered_map>
 
+#include <Core/IoUtilities.hh>
 #include <Core/MD5.hh>
+#include <Core/StopWatch.hh>
 #include <Core/Utility.hh>
 #include <Fsa/AlphabetUtility.hh>
 #include "Fsa.hh"
@@ -137,6 +139,9 @@ Lexicon::~Lexicon() {
 }
 
 void Lexicon::load(const std::string& filename) {
+    Core::StopWatch stopwatch;
+    stopwatch.start();
+
     Core::MD5   md5;
     std::string strippedFilename = Core::FormatSet::stripQualifier(filename);
     if (md5.updateFromFile(strippedFilename)) {
@@ -146,10 +151,20 @@ void Lexicon::load(const std::string& filename) {
         warning("Could not derive md5 sum from file '%s'", strippedFilename.c_str());
     }
 
-    log("Reading lexicon from file") << " \"" << strippedFilename << "\" ...";
+    stopwatch.stop();
+    log("md5 dependency computed in %.2f seconds", stopwatch.elapsedSeconds());
+
+    std::string absFilename = Core::realPath(strippedFilename);
+    log("reading lexicon from file \"%s\" (%s) ...", strippedFilename.c_str(), absFilename.c_str());
+    stopwatch.reset();
+    stopwatch.start();
+
     if (!formats().read(filename, *this)) {
         error("Error while reading lexicon file.");
     }
+
+    stopwatch.stop();
+    log("parsed XML lexicon in %.2f seconds", stopwatch.elapsedSeconds());
     log("dependency value: ") << dependency_.value();
 }
 
@@ -230,9 +245,7 @@ Pronunciation* Lexicon::getOrCreatePronunciation(const std::vector<Phoneme::Id>&
     tie(it, isNew) = pronunciationMap_.insert(pron);
     if (isNew) {
         phon_.start();
-        for (std::vector<Phoneme::Id>::const_iterator i = phonemes.begin();
-             i != phonemes.end(); ++i)
-            phon_.grow(*i);
+        phon_.grow(phonemes.data(), phonemes.data() + phonemes.size());
         pron->phonemes_ = phon_.currentBegin();
         verify(phon_.currentEnd()[-1] == Phoneme::term);
         phon_.finish();
@@ -245,7 +258,7 @@ Pronunciation* Lexicon::getOrCreatePronunciation(const std::vector<Phoneme::Id>&
     return pron;
 }
 
-void Lexicon::parsePronunciation(const std::string& phonStr, std::vector<Phoneme::Id>& phonemes) const {
+Core::Status Lexicon::parsePronunciation(const std::string& phonStr, std::vector<Phoneme::Id>& phonemes) const {
     require(phonemeInventory());
     const Phoneme*         phoneme;
     std::string::size_type i, j;
@@ -258,20 +271,27 @@ void Lexicon::parsePronunciation(const std::string& phonStr, std::vector<Phoneme
             phonemes.push_back(phoneme->id());
         }
         else {
-            error("ignoring unknown phoneme \"%s\"",
-                  phonStr.substr(i, j - i).c_str());
+            std::string errorMessage = std::string("Unknown phoneme: \"") + phonStr.substr(i, j - i) + "\"";
+            return Core::Status(Core::StatusCode::InvalidArgument, errorMessage);
         }
         i = phonStr.find_first_not_of(utf8::whitespace, j);
     }
+    return Core::Status();
 }
 
-Pronunciation* Lexicon::getPronunciation(const std::string& phon) {
+Core::Status Lexicon::getPronunciation(const std::string& phon, Pronunciation*& out) {
     require(phonemeInventory());
+
     std::vector<Phoneme::Id> phonemes;
-    parsePronunciation(phon, phonemes);
+    Core::Status             status = parsePronunciation(phon, phonemes);
+    if (!status.ok()) {
+        out = nullptr;
+        return status;
+    }
+
     phonemes.push_back(Phoneme::term);
-    Pronunciation* pron = getOrCreatePronunciation(phonemes);
-    return pron;
+    out = getOrCreatePronunciation(phonemes);
+    return status;
 }
 
 void Lexicon::addPronunciation(Lemma* lemma, Pronunciation* pron, f32 weight) {

src/Bliss/Lexicon.hh

@@ -29,8 +29,10 @@
 #include <Core/Obstack.hh>
 #include <Core/Parameter.hh>
 #include <Core/ReferenceCounting.hh>
+#include <Core/Status.hh>
 #include <Core/StringUtilities.hh>
 #include <Core/Types.hh>
+
 #include "Phoneme.hh"
 #include "Symbol.hh"
 
@@ -541,7 +543,7 @@ protected:
     EvaluationToken*                      getOrCreateEvaluationToken(Symbol);
 
     /** Convert phonemic string to sequence of phoneme ids */
-    void parsePronunciation(const std::string&, std::vector<Phoneme::Id>&) const;
+    Core::Status parsePronunciation(const std::string&, std::vector<Phoneme::Id>&) const;
 
     struct Internal;
     Internal* internal_;
@@ -574,7 +576,7 @@ public:
      * @param phon a string containing a white-space separate list
      * of phoneme symbols.
      */
-    Pronunciation* getPronunciation(const std::string& phon);
+    Core::Status getPronunciation(const std::string& phon, Pronunciation*& out);
 
     /**
      * Add a pronunciation to a lemma.

src/Bliss/LexiconParser.cc

@@ -261,8 +261,13 @@ void LexiconElement::addPhon(const WeightedPhonemeString& phon) {
         return;
     }
 
-    Pronunciation* pron = product_->getPronunciation(phon.phon);
-    if (lemma_->hasPronunciation(pron)) {
+    Pronunciation* pron   = nullptr;
+    Core::Status   status = product_->getPronunciation(phon.phon, pron);
+    if (pron == nullptr) {
+        parser()->error("Could not create pronunciation for %s: %s", phon.phon.c_str(), status.message().c_str());
+        return;
+    }
+    else if (lemma_->hasPronunciation(pron)) {
         parser()->error("duplicate pronunciation");
         return;
     }
@@ -458,8 +463,14 @@ void VocabTextLexiconParser::createLemmata() {
         Lemma* newLemma_ = lexicon_->newLemma();
         // set orth
         lexicon_->setOrthographicForms(newLemma_, {symbol});
+
         // set phon
-        Pronunciation* pron = lexicon_->getPronunciation(symbol);
+        Pronunciation* pron   = nullptr;
+        Core::Status   status = lexicon_->getPronunciation(symbol, pron);
+        if (pron == nullptr) {
+            Core::Application::us()->error("Could not create pronunciation for %s: %s", symbol.c_str(), status.message().c_str());
+            return;
+        }
         lexicon_->addPronunciation(newLemma_, pron);
         lexicon_->setDefaultLemmaName(newLemma_);
     }

src/Core/Component.cc

@@ -171,6 +171,10 @@ bool Component::hasFatalErrors() const {
     return false;
 }
 
+bool Component::hasErrors() const {
+    return errorCounts_[ErrorTypeError] > 0 or errorCounts_[ErrorTypeCriticalError] > 0;
+}
+
 void Component::respondToDelayedErrors() const {
     if (hasFatalErrors())
         exit();

src/Core/Component.hh

@@ -309,6 +309,11 @@ public:
      */
     bool hasFatalErrors() const;
 
+    /**
+     * Test whether any errors have occured (ignored or not).
+     */
+    bool hasErrors() const;
+
     /**
      * Terminate execution iff an error has occured previously.
      * More specifically, terminate iff hasFatalErrors() returns

src/Core/Makefile

@@ -43,6 +43,7 @@ LIBSPRINTCORE_O	= $(OBJDIR)/Application.o \
 		  $(OBJDIR)/ReferenceCounting.o \
 		  $(OBJDIR)/ResourceUsageInfo.o \
 		  $(OBJDIR)/Statistics.o \
+		  $(OBJDIR)/Status.o \
 		  $(OBJDIR)/StopWatch.o \
 		  $(OBJDIR)/StringExpression.o \
 		  $(OBJDIR)/StringUtilities.o \

src/Core/Status.cc

@@ -0,0 +1,93 @@
+/** Copyright 2025 RWTH Aachen University. All rights reserved.
+ *
+ *  Licensed under the RWTH ASR License (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.hltpr.rwth-aachen.de/rwth-asr/rwth-asr-license.html
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+#include "Status.hh"
+
+namespace Core {
+std::string statusCodeToString(StatusCode code) {
+    switch (code) {
+        case StatusCode::Ok:
+            return "OK";
+        case StatusCode::Cancelled:
+            return "CANCELLED";
+        case StatusCode::Unknown:
+            return "UNKNOWN";
+        case StatusCode::InvalidArgument:
+            return "INVALID_ARGUMENT";
+        case StatusCode::DeadlineExceeded:
+            return "DEADLINE_EXCEEDED";
+        case StatusCode::NotFound:
+            return "NOT_FOUND";
+        case StatusCode::AlreadyExists:
+            return "ALREADY_EXISTS";
+        case StatusCode::PermissionDenied:
+            return "PERMISSION_DENIED";
+        case StatusCode::ResourceExhausted:
+            return "RESOURCE_EXHAUSTED";
+        case StatusCode::FailedPrecondition:
+            return "FAILED_PRECONDITION";
+        case StatusCode::Aborted:
+            return "ABORTED";
+        case StatusCode::OutOfRange:
+            return "OUT_OF_RANGE";
+        case StatusCode::Unimplemented:
+            return "UNIMPLEMENTED";
+        case StatusCode::Internal:
+            return "INTERNAL";
+        case StatusCode::Unavailable:
+            return "UNAVAILABLE";
+        case StatusCode::DataLoss:
+            return "DATA_LOSS";
+        case StatusCode::Unauthenticated:
+            return "UNAUTHENTICATED";
+    }
+    return "UNKNOWN_ERROR_TYPE";
+}
+
+Status::Status()
+        : code_(StatusCode::Ok),
+          msg_(""){};
+
+Status::Status(StatusCode code, std::string msg)
+        : code_(code),
+          msg_("") {
+    if (!ok()) {
+        msg_ = msg;
+    }
+}
+
+std::string Status::message() const {
+    std::stringstream msg(statusCodeToString(code_));
+    if (!msg_.empty()) {
+        msg << ": " << msg_;
+    }
+    return msg.str();
+}
+
+void Status::update(StatusCode code) {
+    update(code, "");
+}
+
+void Status::update(StatusCode code, std::string msg) {
+    if (ok()) {
+        code_ = code;
+        msg_  = msg;
+    }
+}
+
+void Status::update(Status const& status) {
+    update(status.code(), status.message());
+}
+
+}  // namespace Core

src/Core/Status.hh

@@ -0,0 +1,79 @@
+/** Copyright 2025 RWTH Aachen University. All rights reserved.
+ *
+ *  Licensed under the RWTH ASR License (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.hltpr.rwth-aachen.de/rwth-asr/rwth-asr-license.html
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+#ifndef _CORE_STATUS_HH
+#define _CORE_STATUS_HH
+
+#include <sstream>
+
+namespace Core {
+
+enum class StatusCode : int {
+    Ok                 = 0,
+    Cancelled          = 1,
+    Unknown            = 2,
+    InvalidArgument    = 3,
+    DeadlineExceeded   = 4,
+    NotFound           = 5,
+    AlreadyExists      = 6,
+    PermissionDenied   = 7,
+    ResourceExhausted  = 8,
+    FailedPrecondition = 9,
+    Aborted            = 10,
+    OutOfRange         = 11,
+    Unimplemented      = 12,
+    Internal           = 13,
+    Unavailable        = 14,
+    DataLoss           = 15,
+    Unauthenticated    = 16,
+    // RASR internal codes
+    InvalidFileFormat = 100,
+};
+
+std::string statusCodeToString(StatusCode code);
+
+class [[nodiscard]] Status final {
+public:
+    // This default constructor creates an OK status
+    Status();
+
+    // This constructor sets error message if not OK Status
+    Status(StatusCode code, std::string msg);
+
+    bool        ok() const;
+    StatusCode  code() const;
+    std::string message() const;
+
+    void update(StatusCode code);
+    void update(StatusCode code, std::string msg);
+    void update(Status const& status);
+
+private:
+    StatusCode  code_;
+    std::string msg_;
+};
+
+// inline implementations
+
+inline bool Status::ok() const {
+    return code_ == StatusCode::Ok;
+}
+
+inline StatusCode Status::code() const {
+    return code_;
+}
+
+}  // namespace Core
+
+#endif  // _CORE_STATUS_HH