Driver.h

 
#pragma once
 
#include <istream>
#include <map>
#include <string>
#include <unordered_map>
#include <utility>
 
#include "dlinear/libs/libgmp.h"
#include "dlinear/parser/Driver.h"
#include "dlinear/parser/mps/BoundType.h"
#include "dlinear/parser/mps/Sense.h"
#include "dlinear/parser/mps/scanner.h"
#include "dlinear/solver/Context.h"
#include "dlinear/symbolic/symbolic.h"
 
namespace dlinear::mps {
 
class MpsDriver : public Driver {
 public:
  explicit MpsDriver(Context &context);
 
  bool ParseStreamCore(std::istream &in) override;
 
  static void error(const location &l, const std::string &m);
 
  void ObjectiveSense(bool is_min);
 
  void ObjectiveName(const std::string &row);
 
  void AddRow(Sense sense, const std::string &row);
 
  void AddColumn(const std::string &column, const std::string &row, mpq_class value);
 
  void AddRhs(const std::string &rhs, const std::string &row, mpq_class value);
 
  void AddRange(const std::string &rhs, const std::string &row, mpq_class value);
 
  void AddBound(BoundType type, const std::string &bound, const std::string &column, mpq_class value);
 
  void AddBound(BoundType type, const std::string &bound, const std::string &column);
 
  void End();
 
  [[nodiscard]] const std::string &problem_name() const { return problem_name_; }
  std::string &m_problem_name() { return problem_name_; }
  [[nodiscard]] bool strict_mps() const { return strict_mps_; }
  void set_strict_mps(bool b) { strict_mps_ = b; }
  [[nodiscard]] std::size_t n_assertions() const { return rhs_.size() + bounds_.size(); }
  [[nodiscard]] bool is_min() const { return is_min_; }
  [[nodiscard]] const std::string &obj_row() const { return obj_row_; }
  [[nodiscard]] MpsScanner *scanner() { return scanner_; }
 
  void ToSmt2(std::ostream &os) const;
 
 private:
  inline bool VerifyStrictRhs(const std::string &rhs);
 
  inline bool VerifyStrictBound(const std::string &bound);
 
  std::string problem_name_;      
  bool is_min_{true};             
  std::string obj_row_;           
  MpsScanner *scanner_{nullptr};  
  bool strict_mps_{false};  
 
  std::unordered_map<std::string, std::map<Expression, mpq_class>> rows_;
  std::unordered_map<std::string, Sense> row_senses_;       
  std::unordered_map<std::string, Variable> columns_;       
  std::unordered_map<std::string, bool> skip_lower_bound_;  
  std::unordered_map<std::string, mpq_class> rhs_values_;   
 
  // TODO(TendTo): Could be optimized by using unordered_map.
  std::map<std::string, Formula> rhs_;     
  std::map<std::string, Formula> bounds_;  
 
  std::string rhs_name_;    
  std::string bound_name_;  
};
 
}  // namespace dlinear::mps