Safe transfer of bindings through typedefs

src/translator/response.h

@@ -64,6 +64,10 @@ struct Response {
   /// sparse matrix representation with indices corresponding
   /// to (sub-)words accessible through Annotation.
   std::vector<Alignment> alignments;
+
+  const std::string &getOriginalText() const { return source.text; }
+
+  const std::string &getTranslatedText() const { return target.text; }
 };
 } // namespace bergamot
 } // namespace marian

src/translator/service.cpp

@@ -28,8 +28,8 @@ loadVocabularies(marian::Ptr<marian::Options> options) {
 namespace marian {
 namespace bergamot {
 
-Service::Service(Ptr<Options> options, AlignedMemory modelMemory, AlignedMemory shortlistMemory)
-    : requestId_(0), vocabs_(std::move(loadVocabularies(options))),
+Service::Service(Ptr<Options> options, AlignedMemory modelMemory, AlignedMemory shortlistMemory) 
+    : requestId_(0), options_(options), vocabs_(std::move(loadVocabularies(options))),
       text_processor_(vocabs_, options), batcher_(options),
       numWorkers_(options->get<int>("cpu-threads")),
       modelMemory_(std::move(modelMemory)), shortlistMemory_(std::move(shortlistMemory))

src/translator/service.h

@@ -123,6 +123,12 @@ class Service {
   translateMultiple(std::vector<std::string> &&source,
                     TranslationRequest translationRequest);
 
+  /// Returns if model is alignment capable or not. Exists for not breaking
+  /// things at the extension.
+  bool isAlignmentSupported() const {
+    return options_->hasAndNotEmpty("alignment");
+  }
+
 private:
   /// Queue an input for translation.
   std::future<Response> queueRequest(std::string &&input,
@@ -149,6 +155,10 @@ class Service {
 
   /// Number of workers to launch.
   size_t numWorkers_; // ORDER DEPENDENCY (pcqueue_)
+
+  /// Options object holding the options Service was instantiated with.
+  Ptr<Options> options_;
+
   /// Model memory to load model passed as bytes.
   AlignedMemory modelMemory_; // ORDER DEPENDENCY (translators_)
   /// Shortlist memory passed as bytes.

wasm/bindings/TranslationModelBindings.cpp

@@ -6,10 +6,14 @@
 
 #include <emscripten/bind.h>
 
-#include "TranslationModel.h"
+#include "response.h"
+#include "service.h"
 
 using namespace emscripten;
 
+typedef marian::bergamot::Service TranslationModel;
+typedef marian::bergamot::Response TranslationResult;
+
 val getByteArrayView(marian::bergamot::AlignedMemory& alignedMemory) {
   return val(typed_memory_view(alignedMemory.size(), alignedMemory.as<char>()));
 }
@@ -31,9 +35,11 @@ TranslationModel* TranslationModelFactory(const std::string &config,
 EMSCRIPTEN_BINDINGS(translation_model) {
   class_<TranslationModel>("TranslationModel")
     .constructor(&TranslationModelFactory, allow_raw_pointers())
-    .function("translate", &TranslationModel::translate)
+    .function("translate", &TranslationModel::translateMultiple)
 	  .function("isAlignmentSupported", &TranslationModel::isAlignmentSupported)
     ;
+  // ^ We redirect Service::translateMultiple to WASMBound::translate instead. Sane API is
+  // translate. If and when async comes, we can be done with this inconsistency.
 
   register_vector<std::string>("VectorString");
   register_vector<TranslationResult>("VectorTranslationResult");

wasm/bindings/TranslationResultBindings.cpp

@@ -6,15 +6,17 @@
 #include <emscripten/bind.h>
 #include <vector>
 
-#include "TranslationResult.h"
+// #include "TranslationResult.h"
+#include "response.h"
+
+typedef marian::bergamot::Response TranslationResult;
 
 using namespace emscripten;
 
 // Binding code
 EMSCRIPTEN_BINDINGS(translation_result) {
   class_<TranslationResult>("TranslationResult")
-    .constructor<std::string, std::string, TranslationResult::SentenceMappings>()
-	  .function("getOriginalText", &TranslationResult::getOriginalText)
-	  .function("getTranslatedText", &TranslationResult::getTranslatedText)
-    ;
+      .constructor<>()
+      .function("getOriginalText", &TranslationResult::getOriginalText)
+      .function("getTranslatedText", &TranslationResult::getTranslatedText);
 }