universe.h

// Copyright 2018 The Darwin Neuroevolution Framework Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#pragma once

#include "utils.h"
#include "database.h"
#include "properties.h"
#include "stringify.h"

#include <time.h>
#include <mutex>
#include <optional>
using namespace std;

// TODO: test cases

namespace darwin {

struct DbUniverseObject {
  db::RowId id = 0;

  optional<string> comment;
  
  time_t timestamp = 0;
};

struct DbExperiment : public DbUniverseObject {
  optional<string> name;
  
  string setup;

  optional<db::RowId> last_variation_id;

  time_t last_activity_timestamp = 0;
};

struct DbExperimentVariation : public DbUniverseObject {
  optional<db::RowId> previous_id;

  db::RowId experiment_id = 0;

  optional<string> name;
  
  string config;
};

struct DbEvolutionTrace : public DbUniverseObject {
  db::RowId variation_id = 0;

  string config;
};

struct DbGeneration : public DbUniverseObject {
  db::RowId trace_id = 0;

  int generation = -1;
  
  string summary;
  
  optional<string> details;
  
  optional<string> genotypes;
  
  optional<string> profile;
};

class Universe : public core::NonCopyable {
 public:
  static unique_ptr<Universe> create(const string& path);
  
  static unique_ptr<Universe> open(const string& path);

  string path() const { return path_; }

  unique_ptr<DbExperiment> newExperiment(const optional<string>& name,
                                         const string& setup,
                                         const optional<db::RowId>& base_variation_id);

  unique_ptr<DbExperiment> loadExperiment(db::RowId experiment_id) const;

  bool findExperiment(const string& name) const;
  
  vector<DbExperiment> experimentsList() const;

  unique_ptr<DbExperimentVariation> newVariation(db::RowId experiment_id,
                                                 const string& config);

  unique_ptr<DbExperimentVariation> loadVariation(db::RowId variation_id) const;

  unique_ptr<DbEvolutionTrace> newTrace(db::RowId variation_id,
                                        const string& evolution_config);

  void newGeneration(const DbGeneration& db_generation);

  // yeah, doesn't really belong here, but the standard C++ library
  // support for formatting date/time is still broken (not thread safe)
  string strftime(time_t timestamp, const string& format) const;

 private:
  explicit Universe(const string& path);

  static void initializeUniverse(const string& path);

  db::RowId createVariationHelper(db::RowId experiment_id,
                                  const optional<db::RowId> prev_variation_id,
                                  const string& config);

 private:
  string path_;

  // the database connection is mutable to allow Universe to
  // expose a proper interface (including const methods)
  mutable db::Connection db_;

  // guards all inserts in order to reliably get the last inserted RowId
  mutex db_insert_lock_;
};

}  // namespace darwin