/* Copyright (c) 2010-2015 Stanford University
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR(S) DISCLAIM ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL AUTHORS BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef CEPH_COMMON_TUB_H
#define CEPH_COMMON_TUB_H

/**
 * A Tub holds an object that may be uninitialized; it allows the allocation of
 * memory for objects to be separated from its construction and destruction.
 * When you initially create a Tub its object is uninitialized (and should not
 * be used). You can call #construct and #destroy to invoke the constructor and
 * destructor of the embedded object, and #get or #operator-> will return the
 * embedded object. The embedded object is automatically destroyed when the Tub
 * is destroyed (if it was ever constructed in the first place).
 *
 * Tubs are useful in situations like the following:
 * - You want to create an array of objects, but the objects need complex
 *   constructors with multiple arguments.
 * - You want to create a collection of objects, only some of which will be
 *   used, and you don't want to pay the cost of constructing objects that will
 *   never be used.
 * - You want automatic destruction of an object but don't want to
 *   heap-allocate the object (as with std::unique_ptr).
 * - You want a way to return failure from a method without using pointers,
 *   exceptions, or special values (e.g. -1). The Tub gives you a 'maybe'
 *   object; it may be empty if a failure occurred.
 * - You want a singleton, but don't want to deal with heap-allocating an
 *   object on first use and freeing it later. Instead, just declare your object
 *   in a tub and do:
 *      if (!tub) tub.construct();
 *  - You want optional arguments to a function, but don't want to use pointers
 *    (i.e. use the Tub's boolean to determine that an argument was passed,
 *    rather than checking arg != NULL).
 *
 * Tub is CopyConstructible if and only if ElementType is CopyConstructible,
 * and Tub is Assignable if and only if ElementType is Assignable.
 *
 * \tparam ElementType
 *      The type of the object to be stored within the Tub.
 */
template<typename ElementType>
class Tub {
 public:
  /// The type of the object to be stored within the Tub.
  typedef ElementType element_type;

  /**
	 * Default constructor: the object starts off uninitialized.
	 */
  Tub(): occupied(false) {}

  /**
	 * Construct an occupied Tub, whose contained object is initialized
	 * with a copy of the given object.
	 * \pre
	 *      ElementType is CopyConstructible.
	 * \param other
	 *      Source of the copy.
	 */
  Tub(const ElementType& other) // NOLINT
          : occupied(false) {
    construct(other);
  }

  /**
	 * Construct an occupied Tub, whose contained object is initialized
	 * with a move of the given object.
	 * \pre
	 *      ElementType is MoveConstructible.
	 * \param other
	 *      Source of the move.
	 */
  Tub(ElementType&& other) // NOLINT
          : occupied(false) {
    construct(std::move(other));
  }

  /**
	 * Copy constructor.
	 * The object will be initialized if and only if the source of the copy is
	 * initialized.
	 * \pre
	 *      ElementType is CopyConstructible.
	 * \param other
	 *      Source of the copy.
	 */
  Tub(const Tub<ElementType>& other) // NOLINT
          : occupied(false) {
    if (other.occupied) {
      construct(*other.object); // use ElementType's copy constructor
    }
  }

  /**
	 * Move constructor.
	 * The object will be initialized if and only if the source of the move is
	 * initialized.
	 * \pre
	 *      ElementType is MoveConstructible.
	 * \param other
	 *      Source of the move.
	 */
  Tub(Tub<ElementType>&& other) // NOLINT
          : occupied(false) {
    if (other.occupied)
      construct(std::move(*other.object)); // use ElementType's copy constructor
  }

  /**
	 * Destructor: destroy the object if it was initialized.
	 */
  ~Tub() {
    destroy();
  }

  /**
	 * Assignment: destroy current object if initialized, replace with
	 * source.  Result will be uninitialized if source is uninitialized.
	 * \pre
	 *      ElementType is Assignable.
	 */
  Tub<ElementType>& operator=(const Tub<ElementType>& other) {
    if (this != &other) {
      if (other.occupied) {
        if (occupied) {
#if __GNUC__ && __GNUC__ >= 4 && __GNUC_MINOR__ >= 7
          #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warray-bounds"
#endif
          *object = *other.object; // use ElementType's assignment
#if __GNUC__ && __GNUC__ >= 4 && __GNUC_MINOR__ >= 7
#pragma GCC diagnostic pop
#endif
        } else {
          construct(*other.object);
        }
      } else {
        destroy();
      }
    }
    return *this;
  }

  /**
	 * Assignment: destroy current object if initialized, replace with
	 * source.  Result will be uninitialized if source is uninitialized.
	 * \pre
	 *      ElementType is Assignable.
	 */
  Tub<ElementType>& operator=(Tub<ElementType> &&other) {
    if (this != &other) {
      if (other.occupied) {
        if (occupied)
          *object = std::move(*other.object);
        else
          construct(std::move(*other.object));
        other.destroy();
      } else {
        destroy();
      }
    }
    return *this;
  }

  /**
	 * Assignment: destroy current object if initialized, replace with
	 * source.  Result will be uninitialized if source is uninitialized.
	 * \pre
	 *      ElementType is Assignable.
	 */
  Tub<ElementType>& operator=(ElementType &&elt) {
    if (occupied) {
      *object = std::move(elt);
    } else {
      construct(std::forward<ElementType>(elt));
    }
    return *this;
  }

  /**
	 * Initialize the object.
	 * If the object was already initialized, it will be destroyed first.
	 * \param args
	 *      Arguments to ElementType's constructor.
	 * \return
	 *      A pointer to the newly initialized object.
	 * \post
	 *      The object is initialized.
	 */
  template<typename... Args>
  ElementType* construct(Args&&... args) {
    destroy();
    new(object) ElementType(std::forward<Args>(args)...);
    occupied = true;
    return object;
  }

  /**
	 * Destroy the object, leaving the Tub in the same state
	 * as after the no-argument constructor.
	 * If the object was not initialized, this will have no effect.
	 * \post
	 *      The object is uninitialized.
	 */
  void destroy() {
    if (occupied) {
      object->~ElementType();
      occupied = false;
    }
  }

  /// See #get().
  const ElementType& operator*() const {
    return *get();
  }

  /// See #get().
  ElementType& operator*() {
    return *get();
  }

  /// See #get().
  const ElementType* operator->() const {
    return get();
  }

  /// See #get().
  ElementType* operator->() {
    return get();
  }

  /**
	 * Return a pointer to the object.
	 * \pre
	 *      The object is initialized.
	 */
  ElementType* get() {
    if (!occupied)
      return NULL;
    return object;
  }

  /// See #get().
  const ElementType* get() const {
    if (!occupied)
      return NULL;
    return object;
  }

  /**
	 * Return whether the object is initialized.
	 */
  operator bool() const {
    return occupied;
  }

 private:
  /**
	 * A pointer to where the object is, if it is initialized.
	 * This must directly precede #raw in the struct.
	 */
  ElementType object[0];

  /**
	 * A storage area to back the object while it is initialized.
	 */
  char raw[sizeof(ElementType)];

  /**
	 * Whether the object is initialized.
	 */
  bool occupied;
};

#endif  // CEPH_COMMON_TUB_H