.. _program_listing_file_app_cli.h:

Program Listing for File cli.h
==============================

|exhale_lsh| :ref:`Return to documentation for file <file_app_cli.h>` (``app/cli.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #ifndef BERGAMOT_APP_CLI_H
   #define BERGAMOT_APP_CLI_H
   #include <cstdlib>
   #include <future>
   #include <iostream>
   #include <sstream>
   #include <unordered_map>
   
   #include "common/definitions.h"
   #include "common/timer.h"
   #include "common/utils.h"
   #include "marian.h"
   #include "translator/byte_array_util.h"
   #include "translator/parser.h"
   #include "translator/response.h"
   #include "translator/response_options.h"
   #include "translator/service.h"
   
   namespace marian {
   namespace bergamot {
   
   // marian::bergamot:: makes life easier, won't need to prefix it everywhere and these classes plenty use constructs.
   
   namespace app {
   
   void wasm(Ptr<Options> options) {
     // Here, we take the command-line interface which is uniform across all apps. This is parsed into Ptr<Options> by
     // marian. However, mozilla does not allow a Ptr<Options> constructor and demands an std::string constructor since
     // std::string isn't marian internal unlike Ptr<Options>. Since this std::string path needs to be tested for mozilla
     // and since this class/CLI is intended at testing mozilla's path, we go from:
     //
     // cmdline -> Ptr<Options> -> std::string -> Service(std::string)
     //
     // Overkill, yes.
   
     std::string config = options->asYamlString();
     Service model(config);
   
     ResponseOptions responseOptions;
     std::vector<std::string> texts;
   
     for (std::string line; std::getline(std::cin, line);) {
       texts.emplace_back(line);
     }
   
     auto results = model.translateMultiple(std::move(texts), responseOptions);
   
     for (auto &result : results) {
       std::cout << result.getTranslatedText() << std::endl;
     }
   }
   
   void decoder(Ptr<Options> options) {
     marian::timer::Timer decoderTimer;
     Service service(options);
     // Read a large input text blob from stdin
     std::ostringstream std_input;
     std_input << std::cin.rdbuf();
     std::string input = std_input.str();
   
     // Wait on future until Response is complete
     std::future<Response> responseFuture = service.translate(std::move(input));
     responseFuture.wait();
     const Response &response = responseFuture.get();
   
     for (size_t sentenceIdx = 0; sentenceIdx < response.size(); sentenceIdx++) {
       std::cout << response.target.sentence(sentenceIdx) << "\n";
     }
     LOG(info, "Total time: {:.5f}s wall", decoderTimer.elapsed());
   }
   
   void native(Ptr<Options> options) {
     // Prepare memories for bytearrays (including model, shortlist and vocabs)
     MemoryBundle memoryBundle;
   
     if (options->get<bool>("bytearray")) {
       // Load legit values into bytearrays.
       memoryBundle = getMemoryBundleFromConfig(options);
     }
   
     Service service(options, std::move(memoryBundle));
   
     // Read a large input text blob from stdin
     std::ostringstream std_input;
     std_input << std::cin.rdbuf();
     std::string input = std_input.str();
   
     ResponseOptions responseOptions;
     responseOptions.qualityScores = true;
     responseOptions.alignment = true;
     responseOptions.alignmentThreshold = 0.2f;
   
     // Wait on future until Response is complete
     std::future<Response> responseFuture = service.translate(std::move(input), responseOptions);
     responseFuture.wait();
     Response response = responseFuture.get();
   
     std::cout << "[original]: " << response.source.text << '\n';
     std::cout << "[translated]: " << response.target.text << '\n';
     for (int sentenceIdx = 0; sentenceIdx < response.size(); sentenceIdx++) {
       std::cout << " [src Sentence]: " << response.source.sentence(sentenceIdx) << '\n';
       std::cout << " [tgt Sentence]: " << response.target.sentence(sentenceIdx) << '\n';
       std::cout << "Alignments" << '\n';
       typedef std::pair<size_t, float> Point;
   
       // Initialize a point vector.
       std::vector<std::vector<Point>> aggregate(response.source.numWords(sentenceIdx));
   
       // Handle alignments
       auto &alignments = response.alignments[sentenceIdx];
       for (auto &p : alignments) {
         aggregate[p.src].emplace_back(p.tgt, p.prob);
       }
   
       for (size_t src = 0; src < aggregate.size(); src++) {
         std::cout << response.source.word(sentenceIdx, src) << ": ";
         for (auto &p : aggregate[src]) {
           std::cout << response.target.word(sentenceIdx, p.first) << "(" << p.second << ") ";
         }
         std::cout << '\n';
       }
   
       // Handle quality.
       auto &quality = response.qualityScores[sentenceIdx];
       std::cout << "Quality: whole(" << quality.sequence << "), tokens below:" << '\n';
       size_t wordIdx = 0;
       bool first = true;
       for (auto &p : quality.word) {
         if (first) {
           first = false;
         } else {
           std::cout << " ";
         }
         std::cout << response.target.word(sentenceIdx, wordIdx) << "(" << p << ")";
         wordIdx++;
       }
       std::cout << '\n';
     }
     std::cout << "--------------------------\n";
     std::cout << '\n';
   }
   
   }  // namespace app
   
   }  // namespace bergamot
   }  // namespace marian
   
   #endif  // BERGAMOT_APP_CLI_H