Control panel for simulations

include/emp/datastructs/DisjointVariant.hpp

@@ -0,0 +1,93 @@
+/**
+ *  @note This file is part of Empirical, https://github.com/devosoft/Empirical
+ *  @copyright Copyright (C) Michigan State University, MIT Software license; see doc/LICENSE.md
+ *  @date 2021
+ *
+ *  @file  DisjointVariant.hpp
+ *  @brief A container similar to std::variant, where only one of a set of
+ *  types can be active, but state is maintained for inactive types (they are
+ *  not destructed or overwritten).
+ */
+
+
+#ifndef EMP_DISJOINT_VARIANT_HPP
+
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <variant>
+
+#include "../polyfill/type_identity.hpp"
+
+namespace emp {
+
+template<typename ...Ts>
+class DisjointVariant {
+
+  // Holds state for each element.
+  std::tuple<Ts...> disjoint_data;
+
+  /// Tracks which type is active.
+  std::variant<std::type_identity<Ts>...> active_typeid;
+
+  public:
+
+  /// Forwarding constructor.
+  template<typename... Args>
+  DisjointVariant(Args&&... args)
+  : disjoint_data(std::forward<Args>(args)...)
+  {}
+
+  /// Switch which data element is active.
+  template<typename T>
+  void Activate() {
+    using wrapped_active_type_t = std::type_identity<T>;
+    active_typeid.template emplace<wrapped_active_type_t>();
+  }
+
+  /// Assign to data element.
+  template<typename T>
+  void AssignToElement(T&& val) {
+    std::get<T>(disjoint_data) = std::forward<T>(val);
+  }
+
+  /// Assign data element and set that element as active.
+  template<typename T>
+  void AssignAndActivate(T&& val) {
+    AssignToElement<T>( std::forward<T>(val) );
+    Activate<T>();
+  }
+
+  /// Wraps std::visit to execute visitor on active data element.
+  template<class Visitor>
+  decltype(auto) Visit(Visitor&& visitor) {
+    return std::visit(
+      [this, &visitor]( const auto& typeid_ ){
+        using wrapped_active_type_t = std::decay_t<decltype(typeid_)>;
+        using active_type_t = typename wrapped_active_type_t::type;
+        auto& active_data = std::get<active_type_t>( disjoint_data );
+        return std::forward<Visitor>(visitor)(active_data);
+      },
+      active_typeid
+    );
+  }
+
+
+  /// Wraps std::apply to execute function on each data element.
+  template<class UnaryFunction>
+  void ApplyToAll(UnaryFunction&& f) {
+    // adapted from https://stackoverflow.com/a/54053084
+    std::apply(
+      [&f](auto&&... args){
+        (( f(args) ), ...);
+      },
+      disjoint_data
+    );
+  }
+
+
+};
+
+} // namespace emp
+
+#endif

include/emp/polyfill/type_identity.hpp

@@ -0,0 +1,23 @@
+#ifndef POLYFILL_TYPE_IDENTITY_H
+#define POLYFILL_TYPE_IDENTITY_H
+
+#if __cplusplus <= 201703L
+
+// TODO: C++20 || cpp20
+namespace std {
+
+  // adapted from https://en.cppreference.com/w/cpp/types/type_identity
+  template< class T >
+  struct type_identity {
+    using type = T;
+  };
+
+}
+
+#else // #if __cplusplus <= 201703L
+
+#include <type_traits>
+
+#endif // #if __cplusplus <= 201703L
+
+#endif // #ifndef POLYFILL_TYPE_IDENTITY_H

include/emp/prefab/ButtonGroup.hpp

@@ -0,0 +1,61 @@
+/**
+ *  @note This file is part of Empirical, https://github.com/devosoft/Empirical
+ *  @copyright Copyright (C) Michigan State University, MIT Software license; see doc/LICENSE.md
+ *  @date 2021
+ *
+ *  @file  ButtonGroup.hpp
+ *  @brief ButtonGroups add styling to compactly display a group of buttons and
+ *  provides methods useful for moving buttons between groups.
+ */
+
+#ifndef EMP_BUTTON_GROUP_HPP
+#define EMP_BUTTON_GROUP_HPP
+
+#include "emp/web/Div.hpp"
+
+namespace emp::prefab {
+  /**
+   * A ButtonGroup is a container with styling specifically to display buttons.
+   * It also provides methods for moving buttons from one group into another
+   * allowing the user to combine groups.
+   *
+   * Use a ButtonGroup to place buttons of a similar role into the same
+   * container or to save space by placing buttons without gaps between them.
+   */
+  class ButtonGroup : public web::Div {
+
+    protected:
+    /**
+     * A protected contructor for a ButtonGroup for internal use only. See the
+     * prefab/README.md for more information on this design pattern.
+     *
+     * @param info_ref shared pointer containing presistent state
+     */
+    ButtonGroup(web::internal::DivInfo * info_ref) : web::Div(info_ref) {
+      SetAttr("class", "btn-group");
+    }
+
+    public:
+    /**
+     * Constructor for a ButtonGroup.
+     * @param in_id HTML ID of ButtonGroup div
+     */
+    ButtonGroup(const std::string & in_id="")
+    : ButtonGroup(new web::internal::DivInfo(in_id)) { ; }
+
+    /**
+     * A function useful for joining two button groups together into one unit.
+     * Removes buttons from the ButtonGroup passed in and appends them in order
+     * to this button group group.
+     *
+     * @param btn_group a button group
+     */
+    ButtonGroup & TakeChildren(ButtonGroup && btn_group) {
+      *this << btn_group.Children();
+      btn_group.Clear();
+      return (*this);
+    }
+  };
+} // namespace emp::prefab
+
+#endif // #ifndef EMP_BUTTON_GROUP_HPP