Optional.hpp

/*
 * Optional.hpp
 *
 * Copyright (C) 2020 by RStudio, PBC
 *
 * Unless you have received this program directly from RStudio pursuant to the terms of a commercial license agreement
 * with RStudio, then this program is licensed to you under the following terms:
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */
 
#ifndef LAUNCHER_PLUGINS_OPTIONAL_HPP
#define LAUNCHER_PLUGINS_OPTIONAL_HPP
 
#include <memory>
 
namespace rstudio {
namespace launcher_plugins {
 
template <typename T>
class Optional
{
public:
   Optional() = default;
 
   explicit Optional(T* in_value) :
      m_value(in_value)
   {
   }
 
   explicit Optional(const T& in_value) :
      m_value(new T(in_value))
   {
   }
 
   Optional(const Optional& in_other)
   {
      *this = in_other;
   }
 
   Optional(Optional&& in_other) noexcept
   {
      m_value.swap(in_other.m_value);
   }
 
   explicit operator bool() const
   {
      return hasValue();
   }
 
   bool operator!() const
   {
      return !hasValue();
   }
 
   Optional& operator=(const Optional& in_other)
   {
      if (this == &in_other)
         return *this;
 
      if (in_other.m_value == nullptr)
         m_value.reset();
      else
         m_value.reset(new T(*in_other.m_value));
 
      return *this;
   }
 
   Optional& operator=(Optional&& in_other) noexcept
   {
      if (this == &in_other)
         return *this;
 
      m_value = std::move(in_other.m_value);
      return *this;
   }
 
   Optional& operator=(T* in_value)
   {
      m_value.reset(in_value);
      return *this;
   }
 
   Optional& operator=(const T& in_value)
   {
      m_value.reset(new T(in_value));
      return *this;
   }
 
   const T& getValueOr(const T& in_default) const
   {
      if (hasValue())
         return *m_value;
 
      return in_default;
   }
 
   T& getValueOr(T& in_default)
   {
      return const_cast<T&>(const_cast<const Optional*>(this)->getValueOr(in_default));
   }
 
   bool hasValue() const
   {
      return m_value != nullptr;
   }
 
private:
   std::unique_ptr<T> m_value;
};
 
} // namespace launcher_plugins
} // namespace rstudio
 
#endif