base.h

Go to the documentation of this file.

//
// Project NuriKit - Copyright 2023 SNU Compbio Lab.
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef NURI_FMT_BASE_H_
#define NURI_FMT_BASE_H_

#include <cstddef>
#include <filesystem>
#include <fstream>
#include <istream>
#include <memory>
#include <sstream>
#include <string>
#include <string_view>
#include <vector>
 
#include <absl/base/attributes.h>
#include <absl/base/optimization.h>
#include <absl/log/absl_log.h>
 
#include "nuri/core/container/dumb_buffer.h"
#include "nuri/core/molecule.h"
#include "nuri/utils.h"
 
namespace nuri {
class MoleculeReader;
 
template <class Reader = MoleculeReader>
class MoleculeStream {
public:
  MoleculeStream(Reader &reader): reader_(&reader) { }
 
  MoleculeStream(const MoleculeStream &) = delete;
  MoleculeStream &operator=(const MoleculeStream &) = delete;
  MoleculeStream(MoleculeStream &&) noexcept = default;
  MoleculeStream &operator=(MoleculeStream &&) noexcept = default;
  ~MoleculeStream() noexcept = default;

  ABSL_MUST_USE_RESULT bool advance() {
    if (!reader_->getnext(block_)) {
      return false;
    }
 
    mol_ = reader_->parse(block_);
    return true;
  }

  Molecule &current() { return mol_; }

  const Molecule &current() const { return mol_; }
 
private:
  Reader *reader_;
  std::vector<std::string> block_;
  Molecule mol_;
};
 
template <class Stream>
Stream &operator>>(Stream &stream, Molecule &mol) {
  if (stream.advance()) {
    mol = std::move(stream.current());
  }
  return stream;
}
 
class MoleculeReader {
public:
  MoleculeReader() = default;
  MoleculeReader(const MoleculeReader &) = delete;
  MoleculeReader &operator=(const MoleculeReader &) = delete;
  MoleculeReader(MoleculeReader &&) noexcept = default;
  MoleculeReader &operator=(MoleculeReader &&) noexcept = default;
  virtual ~MoleculeReader() noexcept = default;

  std::vector<std::string> next() {
    std::vector<std::string> block;
    if (!getnext(block)) {
      block.clear();
    }
    return block;
  }

  ABSL_MUST_USE_RESULT virtual bool
  getnext(std::vector<std::string> &block) = 0;

  virtual Molecule parse(const std::vector<std::string> &block) const = 0;

  virtual bool bond_valid() const = 0;

  MoleculeStream<MoleculeReader> stream() { return { *this }; }
};
 
template <auto parser>
class DefaultReaderImpl: public MoleculeReader {
public:
  DefaultReaderImpl() = default;
  DefaultReaderImpl(std::istream &is): is_(&is) { }
 
  Molecule parse(const std::vector<std::string> &block) const final {
    return parser(block);
  }
 
protected:
  // NOLINTBEGIN(*-non-private-member-variables-in-classes)
  std::istream *is_;
  // NOLINTEND(*-non-private-member-variables-in-classes)
};
 
class MoleculeReaderFactory {
public:
  MoleculeReaderFactory() = default;
  MoleculeReaderFactory(const MoleculeReaderFactory &) = default;
  MoleculeReaderFactory &operator=(const MoleculeReaderFactory &) = default;
  MoleculeReaderFactory(MoleculeReaderFactory &&) noexcept = default;
  MoleculeReaderFactory &operator=(MoleculeReaderFactory &&) noexcept = default;
  virtual ~MoleculeReaderFactory() noexcept = default;

  virtual std::unique_ptr<MoleculeReader>
  from_stream(std::istream &is) const = 0;

  static const MoleculeReaderFactory *find_factory(std::string_view name);

  static bool register_factory(std::unique_ptr<MoleculeReaderFactory> factory,
                               const std::vector<std::string> &names);

  void register_for(std::string_view alias) const {
    register_for_name(this, alias);
  }
 
private:
  static void register_for_name(const MoleculeReaderFactory *factory,
                                std::string_view name);
};
 
template <class ReaderFactoryImpl>
bool register_reader_factory(const std::vector<std::string> &names) {
  return MoleculeReaderFactory::register_factory(
      std::make_unique<ReaderFactoryImpl>(), names);
}
 
template <class MoleculeReaderImpl>
class DefaultReaderFactoryImpl: public MoleculeReaderFactory {
public:
  std::unique_ptr<MoleculeReader> from_stream(std::istream &is) const final {
    return std::make_unique<MoleculeReaderImpl>(is);
  }
};
 
template <class SourceStream, class Reader = MoleculeReader>
class MoleculeReaderWrapper {
public:
  template <class... Args>
  MoleculeReaderWrapper(std::string_view fmt, Args &&...args)
      : is_(std::forward<Args>(args)...) {
    const MoleculeReaderFactory *factory =
        MoleculeReaderFactory::find_factory(fmt);
 
    if (ABSL_PREDICT_FALSE(factory == nullptr)) {
      ABSL_LOG(WARNING) << "No factory found for " << fmt;
      return;
    }
 
    reader_ = static_unique_ptr_cast<Reader>(factory->from_stream(is_));
  }

  std::vector<std::string> next() { return reader_->next(); }

  bool getnext(std::vector<std::string> &block) {
    return reader_->getnext(block);
  }

  Molecule parse(const std::vector<std::string> &block) const {
    return reader_->parse(block);
  }
 
  MoleculeStream<Reader> stream() { return { *reader_ }; }
 
  operator bool() const { return is_ && reader_; }
 
private:
  SourceStream is_;
  std::unique_ptr<Reader> reader_;
};
 
template <class Reader>
class MoleculeReaderWrapper<std::ifstream, Reader> {
public:
  explicit MoleculeReaderWrapper(const std::filesystem::path &path): is_(path) {
    const std::filesystem::path full_ext = path.extension();
    const std::string_view ext = extension_no_dot(full_ext);
 
    const MoleculeReaderFactory *factory =
        MoleculeReaderFactory::find_factory(ext);
 
    if (ABSL_PREDICT_FALSE(factory == nullptr)) {
      ABSL_LOG(WARNING) << "No factory found for " << ext;
      return;
    }
 
    reader_ = static_unique_ptr_cast<Reader>(factory->from_stream(is_));
  }
 
  MoleculeReaderWrapper(std::string_view fmt, const std::filesystem::path &path)
      : is_(path) {
    const MoleculeReaderFactory *factory =
        MoleculeReaderFactory::find_factory(fmt);
 
    if (ABSL_PREDICT_FALSE(factory == nullptr)) {
      ABSL_LOG(WARNING) << "No factory found for " << fmt;
      return;
    }
 
    reader_ = static_unique_ptr_cast<Reader>(factory->from_stream(is_));
  }

  std::vector<std::string> next() { return reader_->next(); }

  bool getnext(std::vector<std::string> &block) {
    return reader_->getnext(block);
  }

  Molecule parse(const std::vector<std::string> &block) const {
    return reader_->parse(block);
  }
 
  MoleculeStream<Reader> stream() { return { *reader_ }; }
 
  operator bool() const { return is_ && reader_; }
 
private:
  std::ifstream is_;
  std::unique_ptr<Reader> reader_;
};
 
template <class Reader = MoleculeReader>
using FileMoleculeReader = MoleculeReaderWrapper<std::ifstream, Reader>;
 
template <class Reader = MoleculeReader>
using StringMoleculeReader = MoleculeReaderWrapper<std::istringstream, Reader>;
 
class ReversedStream {
public:
  ReversedStream(std::istream &is, char delim = '\n', std::size_t bufsz = 4096)
      : is_(&is), delim_(delim), buf_(bufsz) {
    reset();
  }
 
  void reset();
 
  bool getline(std::string &line);
 
private:
  void read_block();
 
  std::istream *is_;
  std::size_t prev_;
  char delim_;
  internal::DumbBuffer<char> buf_;
};
 
namespace internal {
  extern std::string ascii_safe(std::string_view str);

  extern std::string ascii_newline_safe(std::string_view str);
}  // namespace internal
}  // namespace nuri
 
#endif /* NURI_FMT_BASE_H_ */