eitherImpl.hpp

#pragma once

#include <algorithm>
#include <cassert>
#include <new>

namespace ma {
struct LeftSide {
  LeftSide() {}
};
static const LeftSide Left;

struct RightSide {
  RightSide() {}
};
static const RightSide Right;

namespace detail {

enum EitherSide : char { left, right };

template <typename Left_t, typename Right_t> class EitherImpl {
 public:
  template <typename... Args>
  EitherImpl(LeftSide /* selects overload */, Args&&... args)
      : side(EitherSide::left) {
    new (&storage) Left_t(std::forward<Args>(args)...);
  }

  template <typename... Args>
  EitherImpl(RightSide /* selects overload */, Args&&... args)
      : side(EitherSide::right) {
    new (&storage) Right_t(std::forward<Args>(args)...);
  }

  ~EitherImpl() { cleanup(); }

  EitherImpl(const EitherImpl& rhs) : side(rhs.side) {
    if (side == left) {
      new (&storage) Left_t(rhs.asLeft());
    } else {
      new (&storage) Right_t(rhs.asRight());
    }
  }

  EitherImpl(EitherImpl&& rhs) noexcept : side(rhs.side) {
    if (side == left) {
      new (&storage) Left_t(std::move(rhs.asLeft()));
    } else {
      new (&storage) Right_t(std::move(rhs.asRight()));
    }
  }

  EitherImpl& operator=(const EitherImpl& rhs) {
    if (this == &rhs) {
      return *this;
    }
    /* destroy whatever we are currently holding */
    cleanup();

    /* copy rhs */
    side = rhs.side;
    if (side == left) {
      new (&storage) Left_t((rhs.asLeft()));
    } else {
      new (&storage) Right_t((rhs.asRight()));
    }
    return *this;
  }

  EitherImpl& operator=(EitherImpl&& rhs) noexcept {
    if (this == &rhs) {
      return *this;
    }
    /* destroy whatever we are currently holding */
    cleanup();

    /* move rhs */
    side = rhs.side;
    if (side == left) {
      new (&storage) Left_t(std::move(rhs.asLeft()));
    } else {
      new (&storage) Right_t(std::move(rhs.asRight()));
    }
    return *this;
  }

  Right_t& asRight() {
    assert(side == right);
    return *reinterpret_cast<Right_t*>(&storage);
  }

  const Right_t& asRight() const {
    assert(side == right);
    return *reinterpret_cast<const Right_t*>(&storage);
  }

  Left_t& asLeft() {
    assert(side == left);
    return *reinterpret_cast<Left_t*>(&storage);
  }

  const Left_t& asLeft() const {
    assert(side == left);
    return *reinterpret_cast<const Left_t*>(&storage);
  }

 protected:
  EitherSide side;

 private:
  void cleanup() {
    if (side == left) {
      asLeft().~Left_t();
    } else {
      asRight().~Right_t();
    }
  }

  using storage_t = typename std::aligned_union<1, Left_t, Right_t>::type;
  storage_t storage;
};
}  // namespace detail
}  // namespace ma