Tag: Global

I’m trying to create a relatively simple class that stores global configuration in some serializable struct, and reads/writes from/to a file.

My main goal is to make this class easy to use correctly. While it’s not a public library, there will be a sizable team using it in many parts of the codebase and I want to make it obvious to use in new code.

Settings.h

#pragma once

#include <exception>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <shared_mutex>

/// Represents global configuration based on a struct.
/// Provides abilities to load/save to a file.
///
/// @param SettingsStruct The following global overloads must exist for
/// serialization to/from streams:
///
///   ostream& operator<<(ostream&, const SettingsStruct
///   istream& operator>>(istream&, SettingsStruct&);
///
template <typename SettingsStruct>
class Settings {
 private:
  SettingsStruct settings_;
  mutable std::shared_mutex mutex_;
  std::filesystem::path filename_;

 public:
  /// Attempts to open file and initialize in-memory settings.
  Settings(std::filesystem::path filename);

  /// @note Calls Commit() before destruction
  ~Settings() { Commit(); }

  Settings(const Settings &) = delete;
  Settings &operator=(const Settings &) = delete;
  Settings(Settings &&) = delete;
  Settings &operator=(Settings &&) = delete;

  /// Commits in-memory settings to a file
  void Commit() const;

  /// @return a copy of the current settings
  SettingsStruct Get() const {
    std::shared_lock lk(mutex_);
    return settings_;
  }

  /// Safely locks + mutates the current settings based on the given transform
  /// function.
  ///
  /// @return a copy of the mutated settings
  ///
  /// @example
  ///   settings.Mutate(()(auto old){ old.SomeGroup.Nested = 4.0; return old; }
  template <typename Func>
  SettingsStruct Mutate(const Func &transformFunction) {
    std::scoped_lock lk(mutex_);
    settings_ = transformFunction(settings_);
    return settings_;
  }
};

template <typename SettingsStruct>
Settings<SettingsStruct>::Settings(std::filesystem::path filename)
    : filename_(filename) {
  std::ifstream ifs(filename);
  if (ifs.is_open()) {
    ifs >> settings_;
  } else {
    std::cerr << "warning could not open settings file "
              << std::filesystem::absolute(filename);
  }
}

template <typename SettingsStruct>
void Settings<SettingsStruct>::Commit() const {
  std::scoped_lock lk(mutex_);
  std::ofstream ofs(filename_);
  ofs << settings_;
}

main.cpp

#include <fstream>
#include <future>
#include <iostream>

#include "Settings.h"

using namespace std;

struct SomeGroupedSettings {
  float Nested = 0.1;  // default
  string Address = "asdf";
};

struct MySettings {
  int Version = 1;

  SomeGroupedSettings SomeGroup = {};
};

ostream &operator<<(ostream &out, const MySettings &s) {
  out << s.Version << 'n'
      << s.SomeGroup.Nested << 'n'
      << s.SomeGroup.Address << 'n';
  return out;
}

istream &operator>>(istream &in, MySettings &s) {
  in >> s.Version;
  in >> s.SomeGroup.Nested;
  in >> s.SomeGroup.Address;
  return in;
}

int main(int argc, char **argv) {
  const auto filename = argc > 1 ? argv(1) : "config.txt";

  // clean file for testing
  {
    ofstream ofs(filename);
    if (! ofs.is_open()) return 1;
    ofs << "1n0.5nold_addressn";
  }

  Settings<MySettings> settings(filename);

  cout << "Loaded settings:n" << settings.Get() << endl;

  auto a = std::async(std::launch::async, ((&)() {
                        cout << "Changing address in other thread..." << endl;
                        settings.Mutate(()(auto old) {
                          old.SomeGroup.Address = "new_address";
                          return old;
                        });
                        cout << "Changed address in other thread:n"
                             << settings.Get() << endl;
                      }));

  cout << "Changing settings in other thread..." << endl;

  settings.Mutate(()(auto old) {
    old.SomeGroup.Nested = 101.3;
    old.Version = 3;
    // leave SomeGroup.Address alone
    return old;
  });

  cout << "Changed settings in main thread:n" << settings.Get() << endl;
}

Example output

Loaded settings:
1
0.5
old_address

Changing Nested in main thread...
Changing Address in other thread...
Changed Address in other thread:
3
101.3
new_address

Changed Nested in main thread:
3
101.3
new_address

With config.txt looking like:

3
101.3
new_address

Questions/not questions:

• I will replace the <</>>-based serialization scheme with a parser based on Nlohmann’s JSON Library in the future. I’m not looking for feedback on this.

• Get() will be called often, while Mutate will be called rarely.

• Performance is not a massive concern, but obvious improvements are obviously welcome.

• The pattern for Mutate that I came up with (passing a mutator as an argument) doesn’t seem widely used, or at least I’m not searching the right terms.

  • What are some better ways to handle mutation of shared classes?

  • Is the design of Mutate a terrible or particularly strange design? What are its pitfalls and why isn’t it more common? I can’t find much about it.

• How could I add threadsafe move operations to this? It might be useful.

Any feedback, or examples of this sort of thing in the wild, is much appreciated.