I tried to use optional-lite in our project and receive some errors when compiling by clang with -Werror flag. I've tested it on FreeBSD with clang 3.4.1 and on Win10 with clang 6.0.0.

This PR contains fixes for errors detected by clang.

I get this error when building the tests on macOS:

In file included from test/optional-lite.t.cpp:7: In file included from test/optional-lite.t.h:12: include/nonstd/optional.hpp:1070:7: error: explicit specialization of non-template class 'hash' class hash< nonstd::optional > ^ ~~~~~~~~~~~~~~~~~~~~~~~ 1 error generated.

My Clang version:

$ clang --version
Apple LLVM version 8.1.0 (clang-802.0.42)
Target: x86_64-apple-darwin16.5.0
Thread model: posix
InstalledDir: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin

My compiler flags:

-std=c++11

for debugging optional-lite I propose this pretty printer

class NonStdOptionalPrinter(SingleObjContainerPrinter):
    "Print a nonstd::optional"

    def __init__ (self, typename, val):
        alternatives = get_template_arg_list(val.type)
        valtype = self._recognize (val.type.template_argument(0))
        self.typename = strip_versioned_namespace(typename)
        self.typename = re.sub('^nonstd::(optional_lite::|)(optional::|)(.*)', 
                                              r'nonstd::\1\3<%s>' % valtype, 
                                              self.typename, 1)
        self.val = val
        self.contained_type = alternatives[0]
        addr = val['contained']['data']['__data'].address
        contained_value = addr.cast(self.contained_type.pointer()).dereference()
        visualizer = gdb.default_visualizer (contained_value)
        super (NonStdOptionalPrinter, self).__init__ (contained_value, visualizer)

    def to_string (self):
        if self.contained_value is None:
            return "%s [no contained value]" % self.typename
        if self.visualizer:
            return "%s containing %s" % (self.typename,
                                         self.visualizer.to_string())
        return self.typename

And don't forget add printer with this code

libstdcxx_printer.add_version('nonstd::optional_lite::',
                                  'optional', NonStdOptionalPrinter)

Code:

#include <https://raw.githubusercontent.com/martinmoene/optional-lite/master/include/nonstd/optional.hpp>
#include <iostream>
#include <string>

int main()
{
    nonstd::optional<std::string> s;
    s = "test";
    std::cout << (*s == "test") << std::endl;
    std::cout << (s.value_or("") == "test") << std::endl; // comment this line
    std::cout << (s->empty()) <<  std::endl;
}

Output: 1 1 1

Expected output: 1 1 0

If I comment line with value_or it works just fine. GCC version also works as expected, but clang and msvc does not.

Live code: https://godbolt.org/z/frqjfr

https://github.com/martinmoene/optional-lite#dependencies

This section says "rhs dependencies" where it should probably be "other dependencies".

I was going to use this library in next version of https://github.com/agauniyal/rang for which I was going to use conan.io for package management. Thought instead of bundling or using git submodule, why not publish optional-lite on conan as well - https://bintray.com/agauniyal/rang/optional-lite%3Arang

Since its a header only library its not much of maintenance task so I'll be happy to maintain this. You can mention in readme if you want or if you have any objection to this upload please leave a comment :) The repo for conan recipie is - https://github.com/agauniyal/conan-optional-lite

The current implementation required ad least a move-constructor for in-place construction. This made it impossible to directly, create an optional of a type without copy and move operators.

A workaround is using the variadic emplace function, but it requires to construct the object in two steps.

std::optional does not require any copy or move operation for in-place construction

The class declares initialize_list functions under a optional_CPP11_OR_GREATER preprocessor block but the header is in a optional_HAVE_INITIALIZER_LIST block.

We should either:

1. Change the #include to be wrapped by #if optional_CPP11_OR_GREATER
2. Change the declarations of the initializer_list functions to be wrapped in optional_HAVE_INITIALIZER_LIST and add a define for optional_HAVE_INITIALIZER_LIST

I suspect 2 is wanted.

Snippet to reproduce:

// g++ -std=c++14 -o x x.cpp

#include "optional.hpp"

class A
{
};

// B is implicitly constructible from A.
class B
{
public:
  B(A a)
  {
  }
};

// f accepts optional<B>.
void f(nonstd::optional<B> b)
{
}

// check conditions on https://en.cppreference.com/w/cpp/utility/optional/optional item 8
static_assert(std::is_constructible<B, A&&>::value, "");
static_assert(!std::is_same<std::decay_t<A&&>, nonstd::in_place_t>::value, "");
static_assert(!std::is_same<std::decay_t<A&&>, nonstd::optional<B>>::value, "");

int main()
{
  A a;

  f(a); // Call f with A, compile error.
}

This snippet fails to compile on gcc 5.4 in C++14 mode:

$ g++ -std=c++14 -o x x.cpp
x.cpp: In function ‘int main()’:
x.cpp:31:6: error: could not convert ‘a’ from ‘A’ to ‘nonstd::optional_lite::optional<B>’
   f(a);
      ^

It works on gcc 8.2 in C++17 mode: https://godbolt.org/z/2XyZum

I know that your library is reported to work on mingw52

on mingw 4.8 ,__cplusplus = 201103 but it seem like REF_QUALIFIER feature is not supported

this naive patch fixed compilation error for me for optional-lite version 3.1.1

Index: optional.hpp
===================================================================
--- optional.hpp	(version 3.1.1)
+++ optional.hpp	(fix have ref)
@@ -254,6 +254,7 @@
 # define optional_COMPILER_GNUC_VERSION   0
 #endif
 
+
 #if defined(__clang__)
 # define optional_COMPILER_CLANG_VERSION  optional_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
 #else
@@ -345,7 +346,7 @@
 # define optional_nullptr  NULL
 #endif
 
-#if optional_HAVE( REF_QUALIFIER )
+#if optional_HAVE( REF_QUALIFIER )  &&  ( !optional_COMPILER_GNUC_VERSION || optional_COMPILER_GNUC_VERSION >= 490 )
 # define optional_ref_qual  &
 # define optional_refref_qual  &&
 #else
@@ -718,7 +719,7 @@
     {
         return as<value_type>();
     }
-
+#if optional_HAVE( REF_QUALIFIER )  &&  ( !optional_COMPILER_GNUC_VERSION || optional_COMPILER_GNUC_VERSION >= 490 )
     value_type const & value() const optional_ref_qual
     {
         return * value_ptr();
@@ -742,7 +743,18 @@
     }
 
 #endif
+#else
+    value_type const & value() const
+    {
+        return * value_ptr();
+    }
 
+    value_type & value()
+    {
+        return * value_ptr();
+    }
+#endif
+
 #if optional_CPP11_OR_GREATER
 
     using aligned_storage_t = typename std::aligned_storage< sizeof(value_type), alignof(value_type) >::type;

best regards.

https://github.com/martinmoene/optional-lite/blob/ed68dc81d8e4fbe7ece18ed8f1e3111d6258d895/include/nonstd/optional.hpp#L1250 assumes that std17::is_nothrow_swappable::value exists, but for a pre-c++-17 compiler it is not defined in that template class: https://github.com/martinmoene/optional-lite/blob/ed68dc81d8e4fbe7ece18ed8f1e3111d6258d895/include/nonstd/optional.hpp#L459. The latest Intecl compiler (icpc 19) observes this, and refuses to compile the code.

Can we add the appropriate value field?

Hello!

Thank you for a great library. I've been using it with great pleasure. Today I found an interesting deviation from how std::optional works, and I was wondering if it's on purpose or not: std::optional<const X> allows emplacing with a new value, whereas nonstd::optional<const X> seemingly does not.

This snippet fails with what I think is trying to placement-new into const memory:

  nonstd::optional<const int> nonstd_opt;
  nonstd_opt.emplace(0);

Godbolt link: https://godbolt.org/z/r46fccxEj

Thank you for your consideration.

I am cross-compiling for ARM architecture with arm-linux-g++ (GCC) 3.4.4 compiler and the standard library header type_traits is under bits folder. To fix the related compilation issue I have defined the following preprocessor directives, but I think that there is a better way to do the same thing.

#define optional_HAVE_BITS_TYPE_TRAITS  defined(__arm__)

#if optional_HAVE( BITS_TYPE_TRAITS )
# include <bits/type_traits.h>
#elif optional_HAVE( TYPE_TRAITS )
# include <type_traits>
#elif optional_HAVE( TR1_TYPE_TRAITS )
# include <tr1/type_traits>
#endif

Code:

#include <https://raw.githubusercontent.com/martinmoene/optional-lite/master/include/nonstd/optional.hpp>
#include <iostream>
#include <string>

struct A
{
    A() = default;
    A(const A &) = delete;
    A& operator=(const A &) = delete;
    A(A &&) = delete;
    A& operator=(A &&) = delete;
};

int main()
{
    std::cout << "Copy constructible: "
        << std::is_copy_constructible<A>::value << " "
        << std::is_copy_constructible<nonstd::optional<A>>::value
        << std::endl;

    std::cout << "Move constructible: "
        << std::is_move_constructible<A>::value << " "
        << std::is_move_constructible<nonstd::optional<A>>::value
        << std::endl;

    std::cout << "Copy assignable: "
        << std::is_copy_assignable<A>::value << " "
        << std::is_copy_assignable<nonstd::optional<A>>::value
        << std::endl;

    std::cout << "Move assignable: "
        << std::is_move_assignable<A>::value << " "
        << std::is_move_assignable<nonstd::optional<A>>::value
        << std::endl;
}

Output:

Copy constructible: 0 1
Move constructible: 0 1
Copy assignable: 0 1
Move assignable: 0 1

Expected output:

Copy constructible: 0 0
Move constructible: 0 0
Copy assignable: 0 0
Move assignable: 0 0

Live demo: https://godbolt.org/z/a7fhv3

optional.hpp seems to rely only on the C++ standard version in use to choose between the std::in_place facility from the standard library or its own implementation.

https://github.com/martinmoene/optional-lite/blob/86db12f3b6c2026ad83efd51c5ce3622bb06f1b8/include/nonstd/optional.hpp#L88-L99

However, simply compiling in C++17 mode doesn't guarantee that the standard library contains these facilities. For instance, this detection technique fails on Ubuntu 16.04 when compiling with clang-5.0 (and the default libstdc++):

$ clang++-5.0 -xc++ -std=c++17 -ferror-limit=5 -c -o /dev/null - <<< '#include "optional.hpp"'
In file included from <stdin>:1:
./optional.hpp:94:12: error: no member named 'in_place' in namespace 'std'
using std::in_place;
      ~~~~~^
./optional.hpp:95:12: error: no member named 'in_place_type' in namespace 'std'
using std::in_place_type;
      ~~~~~^
./optional.hpp:96:12: error: no member named 'in_place_index' in namespace 'std'
using std::in_place_index;
      ~~~~~^
./optional.hpp:97:12: error: no member named 'in_place_t' in namespace 'std'
using std::in_place_t;
      ~~~~~^
./optional.hpp:98:12: error: no member named 'in_place_type_t' in namespace 'std'
using std::in_place_type_t;
      ~~~~~^
fatal error: too many errors emitted, stopping now [-ferror-limit=]
6 errors generated.