optional.hpp

Go to the documentation of this file.

#ifndef GENESIS_UTILS_CONTAINERS_OPTIONAL_H_
#define GENESIS_UTILS_CONTAINERS_OPTIONAL_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2022 Lucas Czech
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
    Contact:
    Lucas Czech <lczech@carnegiescience.edu>
    Department of Plant Biology, Carnegie Institution For Science
    260 Panama Street, Stanford, CA 94305, USA
*/
 
/*
    The code below is adapted from https://github.com/martinmoene/optional-bare
    We heavily modified the code to fit our needs, but the basic functionaly is the same.
 
    Copyright 2017-2019 by Martin Moene
    Distributed under the Boost Software License, Version 1.0.
    See http://www.boost.org/LICENSE_1_0.txt
 
    Boost Software License - Version 1.0 - August 17th, 2003
 
    Permission is hereby granted, free of charge, to any person or organization
    obtaining a copy of the software and accompanying documentation covered by
    this license (the "Software") to use, reproduce, display, distribute,
    execute, and transmit the Software, and to prepare derivative works of the
    Software, and to permit third-parties to whom the Software is furnished to
    do so, all subject to the following:
 
    The copyright notices in the Software and this entire statement, including
    the above license grant, this restriction and the following disclaimer,
    must be included in all copies of the Software, in whole or in part, and
    all derivative works of the Software, unless such copies or derivative
    works are solely in the form of machine-executable object code generated by
    a source language processor.
 
    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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
    SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
    FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
    ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
*/
 
// =================================================================================================
//     Prelude
// =================================================================================================
 
// C++ language version detection:
// Note: VC14.0/1900 (VS2015) lacks too much from C++14.
#ifndef   GENESIS_OPTIONAL_CPLUSPLUS
# if defined(_MSVC_LANG ) && !defined(__clang__)
#  define GENESIS_OPTIONAL_CPLUSPLUS  (_MSC_VER == 1900 ? 201103L : _MSVC_LANG )
# else
#  define GENESIS_OPTIONAL_CPLUSPLUS  __cplusplus
# endif
#endif
 
// Check if C++17 std::optional is available:
#if ( GENESIS_OPTIONAL_CPLUSPLUS >= 201703L ) && defined( __has_include )
#    if __has_include( <optional> )
#        define GENESIS_OPTIONAL_HAVE_STD_OPTIONAL  1
#    else
#        define GENESIS_OPTIONAL_HAVE_STD_OPTIONAL  0
#    endif
#else
#    define GENESIS_OPTIONAL_HAVE_STD_OPTIONAL  0
#endif
 
// Use C++17 std::optional if available and requested:
// Currently, we default to using std::optional if it is available.
// Might make this configurable in the future.
#define GENESIS_OPTIONAL_USES_STD_OPTIONAL GENESIS_OPTIONAL_HAVE_STD_OPTIONAL
 
// =================================================================================================
//     Using std::optional
// =================================================================================================
 
#if GENESIS_OPTIONAL_USES_STD_OPTIONAL
 
#include <optional>
#include <utility>
 
// Add the C++17 std::optional to our namespace, so that our classes can use tham as if they
// were our own. This is a bit ugly, but good enough for now. Users that compile genesis with
// C++17 or later will still be able to use std::optional with our classes, as the compiler
// sees through the typedefs here.
namespace genesis {
namespace utils {
 
    template<class T>
    using Optional = std::optional<T>;
    using BadOptionalAccess = std::bad_optional_access;
 
    using std::nullopt;
    using std::nullopt_t;
 
    using std::make_optional;
 
} // namespace utils
} // namespace genesis
 
// =================================================================================================
//     Using optional-bare
// =================================================================================================
 
#else // GENESIS_OPTIONAL_USES_STD_OPTIONAL
 
#include <cassert>
#include <stdexcept>
 
namespace genesis {
namespace utils {
 
struct nullopt_t
{
    struct init{};
    nullopt_t( init ) {}
};
 
const nullopt_t nullopt(( nullopt_t::init() ));
// (extra parenthesis to prevent the most vexing parse)
 
class BadOptionalAccess : public std::logic_error
{
public:
    explicit BadOptionalAccess()
        : std::logic_error( "Bad Optional access" )
    {}
};
 
// ===========================================================================
//     Optional
// ===========================================================================
 
template< typename T >
class Optional
{
public:
 
    // -------------------------------------------------------------------------
    //     Typedefs and Enums
    // -------------------------------------------------------------------------
 
    typedef T value_type;
 
    // -------------------------------------------------------------------------
    //     Constructors and Rule of Five
    // -------------------------------------------------------------------------
 
    Optional()
        : has_value_( false )
    {}
 
    Optional( nullopt_t )
        : has_value_( false )
    {}
 
    Optional( T const & arg )
        : has_value_( true )
        , value_    ( arg  )
    {}
 
    Optional( T && arg )
        : has_value_( true )
        , value_    ( std::move( arg ))
    {}
 
    template< class U >
    Optional( Optional<U> const & other )
        : has_value_( other.has_value() )
    {
        if ( other.has_value() ){
            value_ = other.value();
        }
    }
 
    template< class U >
    Optional( Optional<U> && other )
        : has_value_( other.has_value() )
    {
        if ( other.has_value() ){
            value_ = std::move( other.value() );
        }
    }
 
    Optional & operator=( nullopt_t )
    {
        reset();
        return *this;
    }
 
    Optional & operator=( T const & other )
    {
        has_value_ = true;
        value_ = other;
        return *this;
    }
 
    Optional & operator=( T && other )
    {
        has_value_ = true;
        value_ = std::move( other );
        return *this;
    }
 
    template< class U >
    Optional & operator=( Optional<U> const & other )
    {
        has_value_ = other.has_value();
        if ( other.has_value() ) {
            value_ = other.value();
        }
        return *this;
    }
 
    template< class U >
    Optional & operator=( Optional<U> && other )
    {
        has_value_ = other.has_value();
        if ( other.has_value() ) {
            value_ = std::move( other.value() );
        }
        return *this;
    }
 
    void swap( Optional & rhs )
    {
        using std::swap;
        if     (   has_value() &&   rhs.has_value() ) { swap( **this, *rhs ); }
        else if( ! has_value() &&   rhs.has_value() ) { initialize_( *rhs ); rhs.reset(); }
        else if(   has_value() && ! rhs.has_value() ) { rhs.initialize_( **this ); reset(); }
        // else: both empty, nothing to do
    }
 
    // -------------------------------------------------------------------------
    //     Observers
    // -------------------------------------------------------------------------
 
    value_type const * operator->() const
    {
        assert( has_value() );
        return &value_;
    }
 
    value_type * operator->()
    {
        assert( has_value() );
        return &value_;
    }
 
    value_type const & operator*() const
    {
        assert( has_value() );
        return value_;
    }
 
    value_type & operator*()
    {
        assert( has_value() );
        return value_;
    }
 
    explicit operator bool() const
    {
        return has_value();
    }
 
    bool has_value() const
    {
        return has_value_;
    }
 
    value_type const & value() const
    {
        if( ! has_value() ) {
            throw BadOptionalAccess();
        }
        assert( has_value() );
        return value_;
    }
 
    value_type & value()
    {
        if( ! has_value() ) {
            throw BadOptionalAccess();
        }
        assert( has_value() );
        return value_;
    }
 
    template< class U >
    value_type value_or( U const & v ) const
    {
        return has_value() ? value() : static_cast<value_type>( v );
    }
 
    // -------------------------------------------------------------------------
    //     Modifiers
    // -------------------------------------------------------------------------
 
    void reset()
    {
        has_value_ = false;
    }
 
    // -------------------------------------------------------------------------
    //     Internal Members
    // -------------------------------------------------------------------------
 
private:
 
    template< typename V >
    void initialize_( V const & value )
    {
        assert( ! has_value() );
        value_ = value;
        has_value_ = true;
    }
 
private:
 
    bool has_value_;
    value_type value_;
 
};
 
// ===========================================================================
//     Relational operators
// ===========================================================================
 
template< typename T, typename U >
inline bool operator==( Optional<T> const & x, Optional<U> const & y )
{
    return bool(x) != bool(y) ? false : bool(x) == false ? true : *x == *y;
}
 
template< typename T, typename U >
inline bool operator!=( Optional<T> const & x, Optional<U> const & y )
{
    return !(x == y);
}
 
template< typename T, typename U >
inline bool operator<( Optional<T> const & x, Optional<U> const & y )
{
    return (!y) ? false : (!x) ? true : *x < *y;
}
 
template< typename T, typename U >
inline bool operator>( Optional<T> const & x, Optional<U> const & y )
{
    return (y < x);
}
 
template< typename T, typename U >
inline bool operator<=( Optional<T> const & x, Optional<U> const & y )
{
    return !(y < x);
}
 
template< typename T, typename U >
inline bool operator>=( Optional<T> const & x, Optional<U> const & y )
{
    return !(x < y);
}
 
// ===========================================================================
//     Comparison with nullopt
// ===========================================================================
 
template< typename T >
inline bool operator==( Optional<T> const & x, nullopt_t )
{
    return (!x);
}
 
template< typename T >
inline bool operator==( nullopt_t, Optional<T> const & x )
{
    return (!x);
}
 
template< typename T >
inline bool operator!=( Optional<T> const & x, nullopt_t )
{
    return bool(x);
}
 
template< typename T >
inline bool operator!=( nullopt_t, Optional<T> const & x )
{
    return bool(x);
}
 
template< typename T >
inline bool operator<( Optional<T> const &, nullopt_t )
{
    return false;
}
 
template< typename T >
inline bool operator<( nullopt_t, Optional<T> const & x )
{
    return bool(x);
}
 
template< typename T >
inline bool operator<=( Optional<T> const & x, nullopt_t )
{
    return (!x);
}
 
template< typename T >
inline bool operator<=( nullopt_t, Optional<T> const & )
{
    return true;
}
 
template< typename T >
inline bool operator>( Optional<T> const & x, nullopt_t )
{
    return bool(x);
}
 
template< typename T >
inline bool operator>( nullopt_t, Optional<T> const & )
{
    return false;
}
 
template< typename T >
inline bool operator>=( Optional<T> const &, nullopt_t )
{
    return true;
}
 
template< typename T >
inline bool operator>=( nullopt_t, Optional<T> const & x )
{
    return (!x);
}
 
// ===========================================================================
//     Comparison with T
// ===========================================================================
 
template< typename T, typename U >
inline bool operator==( Optional<T> const & x, U const & v )
{
    return bool(x) ? *x == v : false;
}
 
template< typename T, typename U >
inline bool operator==( U const & v, Optional<T> const & x )
{
    return bool(x) ? v == *x : false;
}
 
template< typename T, typename U >
inline bool operator!=( Optional<T> const & x, U const & v )
{
    return bool(x) ? *x != v : true;
}
 
template< typename T, typename U >
inline bool operator!=( U const & v, Optional<T> const & x )
{
    return bool(x) ? v != *x : true;
}
 
template< typename T, typename U >
inline bool operator<( Optional<T> const & x, U const & v )
{
    return bool(x) ? *x < v : true;
}
 
template< typename T, typename U >
inline bool operator<( U const & v, Optional<T> const & x )
{
    return bool(x) ? v < *x : false;
}
 
template< typename T, typename U >
inline bool operator<=( Optional<T> const & x, U const & v )
{
    return bool(x) ? *x <= v : true;
}
 
template< typename T, typename U >
inline bool operator<=( U const & v, Optional<T> const & x )
{
    return bool(x) ? v <= *x : false;
}
 
template< typename T, typename U >
inline bool operator>( Optional<T> const & x, U const & v )
{
    return bool(x) ? *x > v : false;
}
 
template< typename T, typename U >
inline bool operator>( U const & v, Optional<T> const & x )
{
    return bool(x) ? v > *x : true;
}
 
template< typename T, typename U >
inline bool operator>=( Optional<T> const & x, U const & v )
{
    return bool(x) ? *x >= v : false;
}
 
template< typename T, typename U >
inline bool operator>=( U const & v, Optional<T> const & x )
{
    return bool(x) ? v >= *x : true;
}
 
// ===========================================================================
//     Specialized algorithms
// ===========================================================================
 
template< typename T >
void swap( Optional<T> & x, Optional<T> & y )
{
    x.swap( y );
}
 
template< typename T >
inline Optional<T> make_optional( T const & v )
{
    return Optional<T>( v );
}
 
} // namespace utils
} // namespace genesis
 
#endif // GENESIS_OPTIONAL_USES_STD_OPTIONAL
 
#endif // include guard