AttrRecorderInterface.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdio>  // std::FILE
#include <string>
#include <string_view>
 
#include "../utils/error_handling.h"
 
class AttrRecorderInterface
{
 public:
  // I don't anticipate that we'll need the virtual destructor, but we're
  // including it just in case. I'm concerned that if we don't declare it to
  // be virtual a future change could make it necessary and people may be
  // confused about failure since inheritance is EXTREMELY rare in this
  // codebase
  virtual ~AttrRecorderInterface() {}
 
  // declare the recording methods for arrays of values
 
  virtual void record_arr(const char* name, const double* arr, int length) = 0;
  virtual void record_arr(const char* name, const int* arr, int length)    = 0;
  virtual void record_arr(const char* name, const long* arr, int length)   = 0;
 
  // the following member group consists of member functions for recording scalar
  // attributes. The overload for writing a string is the only pure virtual member.
  // Every other member function has a default implementation that treats the scalar
  // as a 1 element array
 
 
  virtual void record(const char* name, const char* val) = 0;
  virtual void record(const char* name, double val)      = 0;
  virtual void record(const char* name, int val)         = 0;
  virtual void record(const char* name, long val)        = 0;
 
  void record_triple(const char* name, double a, double b, double c)
  {
    double tmp[3] = {a, b, c};
    this->record_arr(name, tmp, 3);
  }
 
  /* A convenience method for recording 3 ints */
  void record_triple(const char* name, int a, int b, int c)
  {
    int tmp[3] = {a, b, c};
    this->record_arr(name, tmp, 3);
  }
};
 
namespace io_detail
{
 
std::string encode_toml_key(std::string_view key);
 
std::string encode_toml_str(std::string_view s);
}  // namespace io_detail
 
class TextAttrRecorder : public AttrRecorderInterface
{
  std::FILE* fp_;
  bool is_closed_;
 
  template <typename T>
  void write_val_(T val)
  {
    if constexpr (std::is_same_v<T, long>) {
      std::fprintf(this->fp_, "%ld", val);
    } else if constexpr (std::is_same_v<T, int>) {
      std::fprintf(this->fp_, "%d", val);
    } else if constexpr (std::is_same_v<T, double>) {
      std::fprintf(this->fp_, "%.17g", val);
    } else if constexpr (std::is_same_v<T, const char*>) {
      std::string tmp = io_detail::encode_toml_str(val);
      std::fputs(tmp.c_str(), this->fp_);
    } else {
      static_assert(always_false<T>, "unexpected type");
    }
  }
 
  template <typename T>
  void record_(const char* name, const T* val, int length)
  {
    if (is_closed_) {
      CHOLLA_ERROR("can't record any more header attributes after closing the recorder");
    }
    std::string key = io_detail::encode_toml_key(name);
    std::fprintf(this->fp_, "%s = ", key.c_str());
    if (length < 0) {  // denotes a scalar
      this->write_val_<T>(*val);
    } else {  // recording an array
      std::fputc('[', this->fp_);
      for (int i = 0; i < length; i++) {
        if (i > 0) {
          std::fputc(',', this->fp_);
          std::fputc(' ', this->fp_);
        }
        write_val_(val[i]);
      }
      std::fputc(']', this->fp_);
    }
    std::fputc('\n', this->fp_);
  }
 
 public:
  TextAttrRecorder() = delete;
 
  explicit TextAttrRecorder(std::FILE* fp) : fp_{fp}, is_closed_(false)
  {
    CHOLLA_ASSERT(fp != nullptr, "received nullptr");
    std::fputs("BEGIN-HEADER\n", this->fp_);
  }
 
  void ensure_closed()
  {
    if (not this->is_closed_) {
      std::fputs("END-HEADER\n", this->fp_);
      this->is_closed_ = true;
    }
  }
 
  // the destructor does NOT call `std::fclose(this->fp_)` since instances of this type
  // are intended to be temporary wrappers
  ~TextAttrRecorder() override { this->ensure_closed(); }
 
  void record_arr(const char* name, const double* arr, int length) override { this->record_(name, arr, length); }
 
  void record_arr(const char* name, const int* arr, int length) override { this->record_(name, arr, length); }
 
  void record_arr(const char* name, const long* arr, int length) override { this->record_(name, arr, length); }
 
  void record(const char* name, const char* val) override { this->record_(name, &val, -1); }
  void record(const char* name, double val) override { this->record_(name, &val, -1); }
  void record(const char* name, int val) override { this->record_(name, &val, -1); }
  void record(const char* name, long val) override { this->record_(name, &val, -1); }
};