StatisticsArchives.hpp

// <StatisticsArchives> -*- C++ -*-
 
#pragma once
 
#include "sparta/statistics/dispatch/StatisticsHierRootNodes.hpp"
#include "sparta/statistics/dispatch/archives/RootArchiveNode.hpp"
#include "sparta/statistics/dispatch/archives/ArchiveController.hpp"
 
#include <filesystem>
 
#include <boost/archive/binary_iarchive.hpp>
 
namespace sparta {
namespace statistics {
 
class StatisticsArchives : public StatisticsHierRootNodes<RootArchiveNode>
{
public:
    StatisticsArchives() = default;
 
    explicit StatisticsArchives(const std::string & db_dir)
    {
        namespace sfs = std::filesystem;
        sfs::path p(db_dir);
 
        if (!sfs::is_directory(p)) {
            throw SpartaException(
                "The path given is not a directory: ") << db_dir;
        }
 
        //Archives are organized as follows:
        //
        //   db_directory
        //      db_subdirectory     <->    foo.csv
        //      db_subdirectory     <->    bar.json
        //      ...                        ...
        //
        //We need to loop over the subdirectories, and create
        //a RootArchiveNode object for each one.
        std::vector<sfs::directory_entry> subdirs;
        std::copy(sfs::directory_iterator(p),
                  sfs::directory_iterator(),
                  std::back_inserter(subdirs));
 
        auto dir_iter = subdirs.begin();
        while (dir_iter != subdirs.end()) {
            const std::string archive_fulldir = dir_iter->path().string();
            createArchivePlaceholderForExistingDatabase_(archive_fulldir);
            ++dir_iter;
        }
    }
 
    void saveTo(const std::string & dir);
 
private:
    void createArchivePlaceholderForExistingDatabase_(
        const std::string & archive_fulldir)
    {
        std::vector<std::string> split;
        boost::split(split, archive_fulldir, boost::is_any_of("/"));
        const std::string archive_name = split.back();
        archive_placeholder_dirs_[archive_name] = archive_fulldir;
    }
 
    std::vector<std::string> getLazyLoadedRootNames_() const override {
        std::vector<std::string> names;
        names.reserve(archive_placeholder_dirs_.size());
        for (const auto & dir : archive_placeholder_dirs_) {
            names.emplace_back(dir.first);
        }
        return names;
    }
 
    void onNamedRootRequest_(const std::string & root_name) override {
        auto iter = archive_placeholder_dirs_.find(root_name);
        if (iter != archive_placeholder_dirs_.end()) {
            loadArchiveFspartaxistingDatabase_(iter->second);
            archive_placeholder_dirs_.erase(iter);
        }
    }
 
    void recursSetParentForChildNodes_(ArchiveNode * parent) const {
        for (auto & child : parent->getChildren()) {
            child->setParent(parent);
            recursSetParentForChildNodes_(child.get());
        }
    }
 
    void loadArchiveFspartaxistingDatabase_(const std::string & archive_fulldir)
    {
        std::shared_ptr<RootArchiveNode> root(new RootArchiveNode);
 
        const std::string meta_filename = archive_fulldir + "/archive_tree.bin";
        std::ifstream fin(meta_filename, std::ios::binary);
        if (!fin) {
            throw SpartaException(
                "Unable to open archive file for read: ") << meta_filename;
        }
 
        boost::archive::binary_iarchive ia(fin);
        ia >> *root;
 
        //Give everyone in this archive tree easy access to their
        //raw values filename
        const std::string binary_filename = archive_fulldir + "/values.bin";
        root->setMetadataValue("output_filename", binary_filename);
 
        //Give the root archive node a controller it can use to
        //save the archive to another directory. Offline controllers
        //do not implement synchronization.
        std::shared_ptr<ArchiveController> controller(
            new OfflineArchiveController(archive_fulldir));
        root->setArchiveController(controller);
 
        //Make the connection from child nodes to their parent node
        recursSetParentForChildNodes_(root.get());
 
        //The archive directories given to us are in the form:
        //   "db_directory/db_subdirectory"
        //
        //The unique archive name is simply the db_subdirectory, which
        //will be something like 'foo.csv', 'bar.html', etc.
        std::vector<std::string> split;
        boost::split(split, archive_fulldir, boost::is_any_of("/"));
        const std::string archive_name = split.back();
        addHierarchyRoot(archive_name, root);
    }
 
    std::unordered_map<std::string, std::string> archive_placeholder_dirs_;
};
 
} // namespace statistics
} // namespace sparta