gdbsupport: remove gdb::optional
The previous patch migrated all the uses of gdb::optional to use std::optional instead, so gdb::optional can be removed entirely as well as the self-tests which came with it. Change-Id: I96ecd67b850b01be10ef00eb85a78ac647d5adc7 Approved-By: Tom Tromey <tom@tromey.com> Approved-By: Pedro Alves <pedro@palves.net>
This commit is contained in:
parent
6b09f1342c
commit
42742fc581
@ -469,7 +469,6 @@ SELFTESTS_SRCS = \
|
||||
unittests/memrange-selftests.c \
|
||||
unittests/offset-type-selftests.c \
|
||||
unittests/observable-selftests.c \
|
||||
unittests/optional-selftests.c \
|
||||
unittests/packed-selftests.c \
|
||||
unittests/parallel-for-selftests.c \
|
||||
unittests/parse-connection-spec-selftests.c \
|
||||
|
@ -1,95 +0,0 @@
|
||||
/* Self tests for optional for GDB, the GNU debugger.
|
||||
|
||||
Copyright (C) 2017-2023 Free Software Foundation, Inc.
|
||||
|
||||
This file is part of GDB.
|
||||
|
||||
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/>. */
|
||||
|
||||
#include "defs.h"
|
||||
#include "gdbsupport/selftest.h"
|
||||
#include "gdbsupport/gdb_optional.h"
|
||||
|
||||
/* Used by the included .cc files below. Included here because the
|
||||
included test files are wrapped in a namespace. */
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <memory>
|
||||
|
||||
/* libstdc++'s testsuite uses VERIFY. */
|
||||
#define VERIFY SELF_CHECK
|
||||
|
||||
/* Used to disable testing features not supported by
|
||||
std::optional. */
|
||||
#define GDB_OPTIONAL
|
||||
|
||||
namespace selftests {
|
||||
namespace optional {
|
||||
|
||||
/* The actual tests live in separate files, which were originally
|
||||
copied over from libstdc++'s testsuite. To preserve the structure
|
||||
and help with comparison with the original tests, the file names
|
||||
have been preserved, and only minimal modification was done to have
|
||||
them compile against std::optional instead of std::optional:
|
||||
|
||||
- std::optional->gdb:optional, etc.
|
||||
- ATTRIBUTE_UNUSED in a few places
|
||||
- wrap each file in a namespace so they can all be compiled as a
|
||||
single unit.
|
||||
- libstdc++'s license and formatting style was preserved.
|
||||
*/
|
||||
|
||||
#include "optional/assignment/1.cc"
|
||||
#include "optional/assignment/2.cc"
|
||||
#include "optional/assignment/3.cc"
|
||||
#include "optional/assignment/4.cc"
|
||||
#include "optional/assignment/5.cc"
|
||||
#include "optional/assignment/6.cc"
|
||||
#include "optional/assignment/7.cc"
|
||||
#include "optional/cons/copy.cc"
|
||||
#include "optional/cons/default.cc"
|
||||
#include "optional/cons/move.cc"
|
||||
#include "optional/cons/value.cc"
|
||||
#include "optional/in_place.cc"
|
||||
#include "optional/observers/1.cc"
|
||||
#include "optional/observers/2.cc"
|
||||
|
||||
static void
|
||||
run_tests ()
|
||||
{
|
||||
assign_1::test ();
|
||||
assign_2::test ();
|
||||
assign_3::test ();
|
||||
assign_4::test ();
|
||||
assign_5::test ();
|
||||
assign_6::test ();
|
||||
assign_7::test ();
|
||||
cons_copy::test ();
|
||||
cons_default::test ();
|
||||
cons_move::test ();
|
||||
cons_value::test ();
|
||||
in_place::test ();
|
||||
observers_1::test ();
|
||||
observers_2::test ();
|
||||
}
|
||||
|
||||
} /* namespace optional */
|
||||
} /* namespace selftests */
|
||||
|
||||
void _initialize_optional_selftests ();
|
||||
void
|
||||
_initialize_optional_selftests ()
|
||||
{
|
||||
selftests::register_test ("optional", selftests::optional::run_tests);
|
||||
}
|
@ -1,196 +0,0 @@
|
||||
// Copyright (C) 2013-2023 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library 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, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
namespace assign_1 {
|
||||
|
||||
struct exception {};
|
||||
|
||||
static int counter = 0;
|
||||
|
||||
struct mixin_counter
|
||||
{
|
||||
mixin_counter() { ++counter; }
|
||||
mixin_counter(mixin_counter const&) { ++counter; }
|
||||
~mixin_counter() { --counter; }
|
||||
};
|
||||
|
||||
struct value_type : private mixin_counter
|
||||
{
|
||||
enum state_type
|
||||
{
|
||||
zero,
|
||||
moved_from,
|
||||
throwing_construction,
|
||||
throwing_copy,
|
||||
throwing_copy_assignment,
|
||||
throwing_move,
|
||||
throwing_move_assignment,
|
||||
threw,
|
||||
};
|
||||
|
||||
value_type() = default;
|
||||
|
||||
explicit value_type(state_type state_)
|
||||
: state(state_)
|
||||
{
|
||||
throw_if(throwing_construction);
|
||||
}
|
||||
|
||||
value_type(value_type const& other)
|
||||
: state(other.state)
|
||||
{
|
||||
throw_if(throwing_copy);
|
||||
}
|
||||
|
||||
value_type&
|
||||
operator=(value_type const& other)
|
||||
{
|
||||
state = other.state;
|
||||
throw_if(throwing_copy_assignment);
|
||||
return *this;
|
||||
}
|
||||
|
||||
value_type(value_type&& other)
|
||||
: state(other.state)
|
||||
{
|
||||
other.state = moved_from;
|
||||
throw_if(throwing_move);
|
||||
}
|
||||
|
||||
value_type&
|
||||
operator=(value_type&& other)
|
||||
{
|
||||
state = other.state;
|
||||
other.state = moved_from;
|
||||
throw_if(throwing_move_assignment);
|
||||
return *this;
|
||||
}
|
||||
|
||||
void throw_if(state_type match)
|
||||
{
|
||||
if(state == match)
|
||||
{
|
||||
state = threw;
|
||||
throw exception {};
|
||||
}
|
||||
}
|
||||
|
||||
state_type state = zero;
|
||||
};
|
||||
|
||||
static void
|
||||
test ()
|
||||
{
|
||||
using O = gdb::optional<value_type>;
|
||||
using S = value_type::state_type;
|
||||
auto const make = [](S s = S::zero) { return O { gdb::in_place, s }; };
|
||||
|
||||
enum outcome_type { nothrow, caught, bad_catch };
|
||||
|
||||
// Check copy/move assignment for disengaged optional
|
||||
|
||||
// From disengaged optional
|
||||
{
|
||||
O o;
|
||||
VERIFY( !o );
|
||||
O p;
|
||||
o = p;
|
||||
VERIFY( !o );
|
||||
VERIFY( !p );
|
||||
}
|
||||
|
||||
{
|
||||
O o;
|
||||
VERIFY( !o );
|
||||
O p;
|
||||
o = std::move(p);
|
||||
VERIFY( !o );
|
||||
VERIFY( !p );
|
||||
}
|
||||
|
||||
#ifndef GDB_OPTIONAL
|
||||
{
|
||||
O o;
|
||||
VERIFY( !o );
|
||||
o = {};
|
||||
VERIFY( !o );
|
||||
}
|
||||
#endif
|
||||
|
||||
// From engaged optional
|
||||
{
|
||||
O o;
|
||||
VERIFY( !o );
|
||||
O p = make(S::throwing_copy_assignment);
|
||||
o = p;
|
||||
VERIFY( o && o->state == S::throwing_copy_assignment );
|
||||
VERIFY( p && p->state == S::throwing_copy_assignment );
|
||||
}
|
||||
|
||||
{
|
||||
O o;
|
||||
VERIFY( !o );
|
||||
O p = make(S::throwing_move_assignment);
|
||||
o = std::move(p);
|
||||
VERIFY( o && o->state == S::throwing_move_assignment );
|
||||
VERIFY( p && p->state == S::moved_from );
|
||||
}
|
||||
|
||||
{
|
||||
outcome_type outcome {};
|
||||
O o;
|
||||
VERIFY( !o );
|
||||
O p = make(S::throwing_copy);
|
||||
|
||||
try
|
||||
{
|
||||
o = p;
|
||||
}
|
||||
catch(exception const&)
|
||||
{ outcome = caught; }
|
||||
catch(...)
|
||||
{ outcome = bad_catch; }
|
||||
|
||||
VERIFY( outcome == caught );
|
||||
VERIFY( !o );
|
||||
VERIFY( p && p->state == S::throwing_copy );
|
||||
}
|
||||
|
||||
{
|
||||
outcome_type outcome {};
|
||||
O o;
|
||||
VERIFY( !o );
|
||||
O p = make(S::throwing_move);
|
||||
|
||||
try
|
||||
{
|
||||
o = std::move(p);
|
||||
}
|
||||
catch(exception const&)
|
||||
{ outcome = caught; }
|
||||
catch(...)
|
||||
{ outcome = bad_catch; }
|
||||
|
||||
VERIFY( outcome == caught );
|
||||
VERIFY( !o );
|
||||
VERIFY( p && p->state == S::moved_from );
|
||||
}
|
||||
|
||||
VERIFY( counter == 0 );
|
||||
}
|
||||
|
||||
} // namespace assign_1
|
@ -1,194 +0,0 @@
|
||||
// Copyright (C) 2013-2023 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library 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, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
namespace assign_2 {
|
||||
|
||||
struct exception {};
|
||||
|
||||
static int counter = 0;
|
||||
|
||||
struct mixin_counter
|
||||
{
|
||||
mixin_counter() { ++counter; }
|
||||
mixin_counter(mixin_counter const&) { ++counter; }
|
||||
~mixin_counter() { --counter; }
|
||||
};
|
||||
|
||||
struct value_type : private mixin_counter
|
||||
{
|
||||
enum state_type
|
||||
{
|
||||
zero,
|
||||
moved_from,
|
||||
throwing_construction,
|
||||
throwing_copy,
|
||||
throwing_copy_assignment,
|
||||
throwing_move,
|
||||
throwing_move_assignment,
|
||||
threw,
|
||||
};
|
||||
|
||||
value_type() = default;
|
||||
|
||||
explicit value_type(state_type state_)
|
||||
: state(state_)
|
||||
{
|
||||
throw_if(throwing_construction);
|
||||
}
|
||||
|
||||
value_type(value_type const& other)
|
||||
: state(other.state)
|
||||
{
|
||||
throw_if(throwing_copy);
|
||||
}
|
||||
|
||||
value_type&
|
||||
operator=(value_type const& other)
|
||||
{
|
||||
state = other.state;
|
||||
throw_if(throwing_copy_assignment);
|
||||
return *this;
|
||||
}
|
||||
|
||||
value_type(value_type&& other)
|
||||
: state(other.state)
|
||||
{
|
||||
other.state = moved_from;
|
||||
throw_if(throwing_move);
|
||||
}
|
||||
|
||||
value_type&
|
||||
operator=(value_type&& other)
|
||||
{
|
||||
state = other.state;
|
||||
other.state = moved_from;
|
||||
throw_if(throwing_move_assignment);
|
||||
return *this;
|
||||
}
|
||||
|
||||
void throw_if(state_type match)
|
||||
{
|
||||
if(state == match)
|
||||
{
|
||||
state = threw;
|
||||
throw exception {};
|
||||
}
|
||||
}
|
||||
|
||||
state_type state = zero;
|
||||
};
|
||||
|
||||
static void
|
||||
test ()
|
||||
{
|
||||
using O = gdb::optional<value_type>;
|
||||
using S = value_type::state_type;
|
||||
auto const make = [](S s = S::zero) { return O { gdb::in_place, s }; };
|
||||
|
||||
enum outcome_type { nothrow, caught, bad_catch };
|
||||
|
||||
// Check copy/move assignment for engaged optional
|
||||
|
||||
// From disengaged optional
|
||||
{
|
||||
O o = make(S::zero);
|
||||
VERIFY( o );
|
||||
O p;
|
||||
o = p;
|
||||
VERIFY( !o );
|
||||
VERIFY( !p );
|
||||
}
|
||||
|
||||
{
|
||||
O o = make(S::zero);
|
||||
VERIFY( o );
|
||||
O p;
|
||||
o = std::move(p);
|
||||
VERIFY( !o );
|
||||
VERIFY( !p );
|
||||
}
|
||||
|
||||
#ifndef GDB_OPTIONAL
|
||||
{
|
||||
O o = make(S::zero);
|
||||
VERIFY( o );
|
||||
o = {};
|
||||
VERIFY( !o );
|
||||
}
|
||||
#endif
|
||||
|
||||
// From engaged optional
|
||||
{
|
||||
O o = make(S::zero);
|
||||
VERIFY( o );
|
||||
O p = make(S::throwing_copy);
|
||||
o = p;
|
||||
VERIFY( o && o->state == S::throwing_copy);
|
||||
VERIFY( p && p->state == S::throwing_copy);
|
||||
}
|
||||
|
||||
{
|
||||
O o = make(S::zero);
|
||||
VERIFY( o );
|
||||
O p = make(S::throwing_move);
|
||||
o = std::move(p);
|
||||
VERIFY( o && o->state == S::throwing_move);
|
||||
VERIFY( p && p->state == S::moved_from);
|
||||
}
|
||||
|
||||
{
|
||||
ATTRIBUTE_UNUSED outcome_type outcome {};
|
||||
O o = make(S::zero);
|
||||
VERIFY( o );
|
||||
O p = make(S::throwing_copy_assignment);
|
||||
|
||||
try
|
||||
{
|
||||
o = p;
|
||||
}
|
||||
catch(exception const&)
|
||||
{ outcome = caught; }
|
||||
catch(...)
|
||||
{ outcome = bad_catch; }
|
||||
|
||||
VERIFY( o && o->state == S::threw);
|
||||
VERIFY( p && p->state == S::throwing_copy_assignment);
|
||||
}
|
||||
|
||||
{
|
||||
ATTRIBUTE_UNUSED outcome_type outcome {};
|
||||
O o = make(S::zero);
|
||||
VERIFY( o );
|
||||
O p = make(S::throwing_move_assignment);
|
||||
|
||||
try
|
||||
{
|
||||
o = std::move(p);
|
||||
}
|
||||
catch(exception const&)
|
||||
{ outcome = caught; }
|
||||
catch(...)
|
||||
{ outcome = bad_catch; }
|
||||
|
||||
VERIFY( o && o->state == S::threw);
|
||||
VERIFY( p && p->state == S::moved_from);
|
||||
}
|
||||
|
||||
VERIFY( counter == 0 );
|
||||
}
|
||||
|
||||
} // namespace assign_2
|
@ -1,157 +0,0 @@
|
||||
// Copyright (C) 2013-2023 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library 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, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
namespace assign_3 {
|
||||
|
||||
struct exception {};
|
||||
|
||||
static int counter = 0;
|
||||
|
||||
struct mixin_counter
|
||||
{
|
||||
mixin_counter() { ++counter; }
|
||||
mixin_counter(mixin_counter const&) { ++counter; }
|
||||
~mixin_counter() { --counter; }
|
||||
};
|
||||
|
||||
struct value_type : private mixin_counter
|
||||
{
|
||||
enum state_type
|
||||
{
|
||||
zero,
|
||||
moved_from,
|
||||
throwing_construction,
|
||||
throwing_copy,
|
||||
throwing_copy_assignment,
|
||||
throwing_move,
|
||||
throwing_move_assignment,
|
||||
threw,
|
||||
};
|
||||
|
||||
value_type() = default;
|
||||
|
||||
explicit value_type(state_type state_)
|
||||
: state(state_)
|
||||
{
|
||||
throw_if(throwing_construction);
|
||||
}
|
||||
|
||||
value_type(value_type const& other)
|
||||
: state(other.state)
|
||||
{
|
||||
throw_if(throwing_copy);
|
||||
}
|
||||
|
||||
value_type&
|
||||
operator=(value_type const& other)
|
||||
{
|
||||
state = other.state;
|
||||
throw_if(throwing_copy_assignment);
|
||||
return *this;
|
||||
}
|
||||
|
||||
value_type(value_type&& other)
|
||||
: state(other.state)
|
||||
{
|
||||
other.state = moved_from;
|
||||
throw_if(throwing_move);
|
||||
}
|
||||
|
||||
value_type&
|
||||
operator=(value_type&& other)
|
||||
{
|
||||
state = other.state;
|
||||
other.state = moved_from;
|
||||
throw_if(throwing_move_assignment);
|
||||
return *this;
|
||||
}
|
||||
|
||||
void throw_if(state_type match)
|
||||
{
|
||||
if(state == match)
|
||||
{
|
||||
state = threw;
|
||||
throw exception {};
|
||||
}
|
||||
}
|
||||
|
||||
state_type state = zero;
|
||||
};
|
||||
|
||||
static void
|
||||
test ()
|
||||
{
|
||||
using O = gdb::optional<value_type>;
|
||||
using S = value_type::state_type;
|
||||
auto const make = [](S s = S::zero) { return value_type { s }; };
|
||||
|
||||
enum outcome_type { nothrow, caught, bad_catch };
|
||||
|
||||
// Check value assignment for disengaged optional
|
||||
|
||||
{
|
||||
O o;
|
||||
value_type v = make(S::throwing_copy_assignment);
|
||||
o = v;
|
||||
VERIFY( o && o->state == S::throwing_copy_assignment );
|
||||
}
|
||||
|
||||
{
|
||||
O o;
|
||||
value_type v = make(S::throwing_move_assignment);
|
||||
o = std::move(v);
|
||||
VERIFY( o && o->state == S::throwing_move_assignment );
|
||||
}
|
||||
|
||||
{
|
||||
ATTRIBUTE_UNUSED outcome_type outcome {};
|
||||
O o;
|
||||
value_type v = make(S::throwing_copy);
|
||||
|
||||
try
|
||||
{
|
||||
o = v;
|
||||
}
|
||||
catch(exception const&)
|
||||
{ outcome = caught; }
|
||||
catch(...)
|
||||
{ outcome = bad_catch; }
|
||||
|
||||
VERIFY( !o );
|
||||
}
|
||||
|
||||
{
|
||||
ATTRIBUTE_UNUSED outcome_type outcome {};
|
||||
O o;
|
||||
value_type v = make(S::throwing_move);
|
||||
|
||||
try
|
||||
{
|
||||
o = std::move(v);
|
||||
}
|
||||
catch(exception const&)
|
||||
{ outcome = caught; }
|
||||
catch(...)
|
||||
{ outcome = bad_catch; }
|
||||
|
||||
VERIFY( !o );
|
||||
}
|
||||
|
||||
VERIFY( counter == 0 );
|
||||
}
|
||||
|
||||
} // namespace assign_3
|
@ -1,157 +0,0 @@
|
||||
// Copyright (C) 2013-2023 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library 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, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
namespace assign_4 {
|
||||
|
||||
struct exception {};
|
||||
|
||||
static int counter = 0;
|
||||
|
||||
struct mixin_counter
|
||||
{
|
||||
mixin_counter() { ++counter; }
|
||||
mixin_counter(mixin_counter const&) { ++counter; }
|
||||
~mixin_counter() { --counter; }
|
||||
};
|
||||
|
||||
struct value_type : private mixin_counter
|
||||
{
|
||||
enum state_type
|
||||
{
|
||||
zero,
|
||||
moved_from,
|
||||
throwing_construction,
|
||||
throwing_copy,
|
||||
throwing_copy_assignment,
|
||||
throwing_move,
|
||||
throwing_move_assignment,
|
||||
threw,
|
||||
};
|
||||
|
||||
value_type() = default;
|
||||
|
||||
explicit value_type(state_type state_)
|
||||
: state(state_)
|
||||
{
|
||||
throw_if(throwing_construction);
|
||||
}
|
||||
|
||||
value_type(value_type const& other)
|
||||
: state(other.state)
|
||||
{
|
||||
throw_if(throwing_copy);
|
||||
}
|
||||
|
||||
value_type&
|
||||
operator=(value_type const& other)
|
||||
{
|
||||
state = other.state;
|
||||
throw_if(throwing_copy_assignment);
|
||||
return *this;
|
||||
}
|
||||
|
||||
value_type(value_type&& other)
|
||||
: state(other.state)
|
||||
{
|
||||
other.state = moved_from;
|
||||
throw_if(throwing_move);
|
||||
}
|
||||
|
||||
value_type&
|
||||
operator=(value_type&& other)
|
||||
{
|
||||
state = other.state;
|
||||
other.state = moved_from;
|
||||
throw_if(throwing_move_assignment);
|
||||
return *this;
|
||||
}
|
||||
|
||||
void throw_if(state_type match)
|
||||
{
|
||||
if(state == match)
|
||||
{
|
||||
state = threw;
|
||||
throw exception {};
|
||||
}
|
||||
}
|
||||
|
||||
state_type state = zero;
|
||||
};
|
||||
|
||||
static void
|
||||
test ()
|
||||
{
|
||||
using O = gdb::optional<value_type>;
|
||||
using S = value_type::state_type;
|
||||
auto const make = [](S s = S::zero) { return value_type { s }; };
|
||||
|
||||
enum outcome_type { nothrow, caught, bad_catch };
|
||||
|
||||
// Check value assignment for engaged optional
|
||||
|
||||
{
|
||||
O o = make();
|
||||
value_type v = make(S::throwing_copy);
|
||||
o = v;
|
||||
VERIFY( o && o->state == S::throwing_copy);
|
||||
}
|
||||
|
||||
{
|
||||
O o = make();
|
||||
value_type v = make(S::throwing_move);
|
||||
o = std::move(v);
|
||||
VERIFY( o && o->state == S::throwing_move);
|
||||
}
|
||||
|
||||
{
|
||||
ATTRIBUTE_UNUSED outcome_type outcome {};
|
||||
O o = make();
|
||||
value_type v = make(S::throwing_copy_assignment);
|
||||
|
||||
try
|
||||
{
|
||||
o = v;
|
||||
}
|
||||
catch(exception const&)
|
||||
{ outcome = caught; }
|
||||
catch(...)
|
||||
{ outcome = bad_catch; }
|
||||
|
||||
VERIFY( o && o->state == S::threw );
|
||||
}
|
||||
|
||||
{
|
||||
ATTRIBUTE_UNUSED outcome_type outcome {};
|
||||
O o = make();
|
||||
value_type v = make(S::throwing_move_assignment);
|
||||
|
||||
try
|
||||
{
|
||||
o = std::move(v);
|
||||
}
|
||||
catch(exception const&)
|
||||
{ outcome = caught; }
|
||||
catch(...)
|
||||
{ outcome = bad_catch; }
|
||||
|
||||
VERIFY( o && o->state == S::threw );
|
||||
}
|
||||
|
||||
VERIFY( counter == 0 );
|
||||
}
|
||||
|
||||
} // namespace assign_4
|
@ -1,81 +0,0 @@
|
||||
// Copyright (C) 2013-2023 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library 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, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
namespace assign_5 {
|
||||
|
||||
static int counter = 0;
|
||||
|
||||
struct mixin_counter
|
||||
{
|
||||
mixin_counter() { ++counter; }
|
||||
mixin_counter(mixin_counter const&) { ++counter; }
|
||||
~mixin_counter() { --counter; }
|
||||
};
|
||||
|
||||
struct value_type : private mixin_counter { };
|
||||
|
||||
static void
|
||||
test ()
|
||||
{
|
||||
using O = gdb::optional<value_type>;
|
||||
|
||||
// Check std::nullopt_t and 'default' (= {}) assignment
|
||||
|
||||
#ifndef GDB_OPTIONAL
|
||||
{
|
||||
O o;
|
||||
o = std::nullopt;
|
||||
VERIFY( !o );
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef GDB_OPTIONAL
|
||||
{
|
||||
O o { gdb::in_place };
|
||||
o = std::nullopt;
|
||||
VERIFY( !o );
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef GDB_OPTIONAL
|
||||
{
|
||||
O o;
|
||||
o = {};
|
||||
VERIFY( !o );
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef GDB_OPTIONAL
|
||||
{
|
||||
O o { gdb::in_place };
|
||||
o = {};
|
||||
VERIFY( !o );
|
||||
}
|
||||
#endif
|
||||
{
|
||||
gdb::optional<std::vector<int>> ovi{{1, 2, 3}};
|
||||
VERIFY(ovi->size() == 3);
|
||||
VERIFY((*ovi)[0] == 1 && (*ovi)[1] == 2 && (*ovi)[2] == 3);
|
||||
ovi = {4, 5, 6, 7};
|
||||
VERIFY(ovi->size() == 4);
|
||||
VERIFY((*ovi)[0] == 4 && (*ovi)[1] == 5 &&
|
||||
(*ovi)[2] == 6 && (*ovi)[3] == 7);
|
||||
}
|
||||
VERIFY( counter == 0 );
|
||||
}
|
||||
|
||||
} // namespace assign_5
|
@ -1,91 +0,0 @@
|
||||
// Copyright (C) 2013-2023 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library 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, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
namespace assign_6 {
|
||||
|
||||
static int counter = 0;
|
||||
|
||||
struct mixin_counter
|
||||
{
|
||||
mixin_counter() { ++counter; }
|
||||
mixin_counter(mixin_counter const&) { ++counter; }
|
||||
~mixin_counter() { --counter; }
|
||||
};
|
||||
|
||||
struct value_type : private mixin_counter
|
||||
{
|
||||
value_type() = default;
|
||||
value_type(int) : state(1) { }
|
||||
value_type(std::initializer_list<char>, const char*) : state(2) { }
|
||||
int state = 0;
|
||||
};
|
||||
|
||||
static void
|
||||
test ()
|
||||
{
|
||||
using O = gdb::optional<value_type>;
|
||||
|
||||
// Check emplace
|
||||
|
||||
{
|
||||
O o;
|
||||
o.emplace();
|
||||
VERIFY( o && o->state == 0 );
|
||||
}
|
||||
{
|
||||
O o { gdb::in_place, 0 };
|
||||
o.emplace();
|
||||
VERIFY( o && o->state == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
O o;
|
||||
o.emplace(0);
|
||||
VERIFY( o && o->state == 1 );
|
||||
}
|
||||
{
|
||||
O o { gdb::in_place };
|
||||
o.emplace(0);
|
||||
VERIFY( o && o->state == 1 );
|
||||
}
|
||||
|
||||
#ifndef GDB_OPTIONAL
|
||||
{
|
||||
O o;
|
||||
o.emplace({ 'a' }, "");
|
||||
VERIFY( o && o->state == 2 );
|
||||
}
|
||||
{
|
||||
O o { gdb::in_place };
|
||||
o.emplace({ 'a' }, "");
|
||||
VERIFY( o && o->state == 2 );
|
||||
}
|
||||
#endif
|
||||
{
|
||||
O o;
|
||||
VERIFY(&o.emplace(0) == &*o);
|
||||
#ifndef GDB_OPTIONAL
|
||||
VERIFY(&o.emplace({ 'a' }, "") == &*o);
|
||||
#endif
|
||||
}
|
||||
|
||||
static_assert( !std::is_constructible<O, std::initializer_list<int>, int>(), "" );
|
||||
|
||||
VERIFY( counter == 0 );
|
||||
}
|
||||
|
||||
} // namespace assign_6
|
@ -1,30 +0,0 @@
|
||||
// Copyright (C) 2016-2023 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library 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, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
namespace assign_7 {
|
||||
|
||||
static void
|
||||
test ()
|
||||
{
|
||||
gdb::optional<int> o{666};
|
||||
VERIFY(o && *o == 666);
|
||||
o.reset();
|
||||
VERIFY(!o);
|
||||
static_assert(noexcept(std::declval<gdb::optional<int>>().reset()), "");
|
||||
}
|
||||
|
||||
} // namespace assign_7
|
@ -1,127 +0,0 @@
|
||||
// Copyright (C) 2013-2023 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library 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, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
namespace cons_copy {
|
||||
|
||||
struct tracker
|
||||
{
|
||||
tracker(int value) : value(value) { ++count; }
|
||||
~tracker() { --count; }
|
||||
|
||||
tracker(tracker const& other) : value(other.value) { ++count; }
|
||||
tracker(tracker&& other) : value(other.value)
|
||||
{
|
||||
other.value = -1;
|
||||
++count;
|
||||
}
|
||||
|
||||
tracker& operator=(tracker const&) = default;
|
||||
tracker& operator=(tracker&&) = default;
|
||||
|
||||
int value;
|
||||
|
||||
static int count;
|
||||
};
|
||||
|
||||
int tracker::count = 0;
|
||||
|
||||
struct exception { };
|
||||
|
||||
struct throwing_copy
|
||||
{
|
||||
throwing_copy() = default;
|
||||
throwing_copy(throwing_copy const&) { throw exception {}; }
|
||||
};
|
||||
|
||||
static void
|
||||
test ()
|
||||
{
|
||||
// [20.5.4.1] Constructors
|
||||
|
||||
{
|
||||
gdb::optional<long> o;
|
||||
auto copy = o;
|
||||
VERIFY( !copy );
|
||||
VERIFY( !o );
|
||||
}
|
||||
|
||||
{
|
||||
const long val = 0x1234ABCD;
|
||||
gdb::optional<long> o { gdb::in_place, val};
|
||||
auto copy = o;
|
||||
VERIFY( copy );
|
||||
VERIFY( *copy == val );
|
||||
#ifndef GDB_OPTIONAL
|
||||
VERIFY( o && o == val );
|
||||
#endif
|
||||
}
|
||||
|
||||
{
|
||||
gdb::optional<tracker> o;
|
||||
auto copy = o;
|
||||
VERIFY( !copy );
|
||||
VERIFY( tracker::count == 0 );
|
||||
VERIFY( !o );
|
||||
}
|
||||
|
||||
{
|
||||
gdb::optional<tracker> o { gdb::in_place, 333 };
|
||||
auto copy = o;
|
||||
VERIFY( copy );
|
||||
VERIFY( copy->value == 333 );
|
||||
VERIFY( tracker::count == 2 );
|
||||
VERIFY( o && o->value == 333 );
|
||||
}
|
||||
|
||||
enum outcome { nothrow, caught, bad_catch };
|
||||
|
||||
{
|
||||
outcome result = nothrow;
|
||||
gdb::optional<throwing_copy> o;
|
||||
|
||||
try
|
||||
{
|
||||
auto copy = o;
|
||||
}
|
||||
catch(exception const&)
|
||||
{ result = caught; }
|
||||
catch(...)
|
||||
{ result = bad_catch; }
|
||||
|
||||
VERIFY( result == nothrow );
|
||||
}
|
||||
|
||||
{
|
||||
outcome result = nothrow;
|
||||
gdb::optional<throwing_copy> o { gdb::in_place };
|
||||
|
||||
try
|
||||
{
|
||||
auto copy = o;
|
||||
}
|
||||
catch(exception const&)
|
||||
{ result = caught; }
|
||||
catch(...)
|
||||
{ result = bad_catch; }
|
||||
|
||||
VERIFY( result == caught );
|
||||
}
|
||||
|
||||
VERIFY( tracker::count == 0 );
|
||||
}
|
||||
|
||||
} // namespace cons_copy
|
@ -1,59 +0,0 @@
|
||||
// Copyright (C) 2013-2023 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library 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, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
namespace cons_default {
|
||||
|
||||
struct tracker
|
||||
{
|
||||
tracker() { ++count; }
|
||||
~tracker() { --count; }
|
||||
|
||||
tracker(tracker const&) { ++count; }
|
||||
tracker(tracker&&) { ++count; }
|
||||
|
||||
tracker& operator=(tracker const&) = default;
|
||||
tracker& operator=(tracker&&) = default;
|
||||
|
||||
static int count;
|
||||
};
|
||||
|
||||
int tracker::count = 0;
|
||||
|
||||
static void
|
||||
test ()
|
||||
{
|
||||
// [20.5.4.1] Constructors
|
||||
|
||||
{
|
||||
gdb::optional<tracker> o;
|
||||
VERIFY( !o );
|
||||
}
|
||||
|
||||
{
|
||||
gdb::optional<tracker> o {};
|
||||
VERIFY( !o );
|
||||
}
|
||||
|
||||
{
|
||||
gdb::optional<tracker> o = {};
|
||||
VERIFY( !o );
|
||||
}
|
||||
|
||||
VERIFY( tracker::count == 0 );
|
||||
}
|
||||
|
||||
} // namespace cons_default
|
@ -1,125 +0,0 @@
|
||||
// Copyright (C) 2013-2023 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library 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, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
namespace cons_move {
|
||||
|
||||
struct tracker
|
||||
{
|
||||
tracker(int value) : value(value) { ++count; }
|
||||
~tracker() { --count; }
|
||||
|
||||
tracker(tracker const& other) : value(other.value) { ++count; }
|
||||
tracker(tracker&& other) : value(other.value)
|
||||
{
|
||||
other.value = -1;
|
||||
++count;
|
||||
}
|
||||
|
||||
tracker& operator=(tracker const&) = default;
|
||||
tracker& operator=(tracker&&) = default;
|
||||
|
||||
int value;
|
||||
|
||||
static int count;
|
||||
};
|
||||
|
||||
int tracker::count = 0;
|
||||
|
||||
struct exception { };
|
||||
|
||||
struct throwing_move
|
||||
{
|
||||
throwing_move() = default;
|
||||
throwing_move(throwing_move const&) { throw exception {}; }
|
||||
};
|
||||
|
||||
static void
|
||||
test ()
|
||||
{
|
||||
// [20.5.4.1] Constructors
|
||||
|
||||
{
|
||||
gdb::optional<long> o;
|
||||
auto moved_to = std::move(o);
|
||||
VERIFY( !moved_to );
|
||||
VERIFY( !o );
|
||||
}
|
||||
|
||||
{
|
||||
const long val = 0x1234ABCD;
|
||||
gdb::optional<long> o { gdb::in_place, val};
|
||||
auto moved_to = std::move(o);
|
||||
VERIFY( moved_to );
|
||||
VERIFY( *moved_to == val );
|
||||
VERIFY( o && *o == val );
|
||||
}
|
||||
|
||||
{
|
||||
gdb::optional<tracker> o;
|
||||
auto moved_to = std::move(o);
|
||||
VERIFY( !moved_to );
|
||||
VERIFY( tracker::count == 0 );
|
||||
VERIFY( !o );
|
||||
}
|
||||
|
||||
{
|
||||
gdb::optional<tracker> o { gdb::in_place, 333 };
|
||||
auto moved_to = std::move(o);
|
||||
VERIFY( moved_to );
|
||||
VERIFY( moved_to->value == 333 );
|
||||
VERIFY( tracker::count == 2 );
|
||||
VERIFY( o && o->value == -1 );
|
||||
}
|
||||
|
||||
enum outcome { nothrow, caught, bad_catch };
|
||||
|
||||
{
|
||||
outcome result = nothrow;
|
||||
gdb::optional<throwing_move> o;
|
||||
|
||||
try
|
||||
{
|
||||
auto moved_to = std::move(o);
|
||||
}
|
||||
catch(exception const&)
|
||||
{ result = caught; }
|
||||
catch(...)
|
||||
{ result = bad_catch; }
|
||||
|
||||
VERIFY( result == nothrow );
|
||||
}
|
||||
|
||||
{
|
||||
outcome result = nothrow;
|
||||
gdb::optional<throwing_move> o { gdb::in_place };
|
||||
|
||||
try
|
||||
{
|
||||
auto moved_to = std::move(o);
|
||||
}
|
||||
catch(exception const&)
|
||||
{ result = caught; }
|
||||
catch(...)
|
||||
{ result = bad_catch; }
|
||||
|
||||
VERIFY( result == caught );
|
||||
}
|
||||
|
||||
VERIFY( tracker::count == 0 );
|
||||
}
|
||||
|
||||
} // namespace cons_move
|
@ -1,295 +0,0 @@
|
||||
// Copyright (C) 2013-2023 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library 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, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
namespace cons_value {
|
||||
|
||||
struct tracker
|
||||
{
|
||||
tracker(int value) : value(value) { ++count; }
|
||||
~tracker() { --count; }
|
||||
|
||||
tracker(tracker const& other) : value(other.value) { ++count; }
|
||||
tracker(tracker&& other) : value(other.value)
|
||||
{
|
||||
other.value = -1;
|
||||
++count;
|
||||
}
|
||||
|
||||
tracker& operator=(tracker const&) = default;
|
||||
tracker& operator=(tracker&&) = default;
|
||||
|
||||
int value;
|
||||
|
||||
static int count;
|
||||
};
|
||||
|
||||
int tracker::count = 0;
|
||||
|
||||
struct exception { };
|
||||
|
||||
struct throwing_construction
|
||||
{
|
||||
explicit throwing_construction(bool propagate) : propagate(propagate) { }
|
||||
|
||||
throwing_construction(throwing_construction const& other)
|
||||
: propagate(other.propagate)
|
||||
{
|
||||
if(propagate)
|
||||
throw exception {};
|
||||
}
|
||||
|
||||
bool propagate;
|
||||
};
|
||||
|
||||
static void
|
||||
test ()
|
||||
{
|
||||
// [20.5.4.1] Constructors
|
||||
|
||||
{
|
||||
auto i = 0x1234ABCD;
|
||||
gdb::optional<long> o { i };
|
||||
VERIFY( o );
|
||||
VERIFY( *o == 0x1234ABCD );
|
||||
VERIFY( i == 0x1234ABCD );
|
||||
}
|
||||
|
||||
{
|
||||
auto i = 0x1234ABCD;
|
||||
gdb::optional<long> o = i;
|
||||
VERIFY( o );
|
||||
VERIFY( *o == 0x1234ABCD );
|
||||
VERIFY( i == 0x1234ABCD );
|
||||
}
|
||||
|
||||
{
|
||||
auto i = 0x1234ABCD;
|
||||
gdb::optional<long> o = { i };
|
||||
VERIFY( o );
|
||||
VERIFY( *o == 0x1234ABCD );
|
||||
VERIFY( i == 0x1234ABCD );
|
||||
}
|
||||
|
||||
{
|
||||
auto i = 0x1234ABCD;
|
||||
gdb::optional<long> o { std::move(i) };
|
||||
VERIFY( o );
|
||||
VERIFY( *o == 0x1234ABCD );
|
||||
VERIFY( i == 0x1234ABCD );
|
||||
}
|
||||
|
||||
{
|
||||
auto i = 0x1234ABCD;
|
||||
gdb::optional<long> o = std::move(i);
|
||||
VERIFY( o );
|
||||
VERIFY( *o == 0x1234ABCD );
|
||||
VERIFY( i == 0x1234ABCD );
|
||||
}
|
||||
|
||||
{
|
||||
auto i = 0x1234ABCD;
|
||||
gdb::optional<long> o = { std::move(i) };
|
||||
VERIFY( o );
|
||||
VERIFY( *o == 0x1234ABCD );
|
||||
VERIFY( i == 0x1234ABCD );
|
||||
}
|
||||
|
||||
#ifndef GDB_OPTIONAL
|
||||
{
|
||||
std::vector<int> v = { 0, 1, 2, 3, 4, 5 };
|
||||
gdb::optional<std::vector<int>> o { v };
|
||||
VERIFY( !v.empty() );
|
||||
VERIFY( o->size() == 6 );
|
||||
}
|
||||
#endif
|
||||
|
||||
{
|
||||
std::vector<int> v = { 0, 1, 2, 3, 4, 5 };
|
||||
gdb::optional<std::vector<int>> o = v;
|
||||
VERIFY( !v.empty() );
|
||||
VERIFY( o->size() == 6 );
|
||||
}
|
||||
|
||||
{
|
||||
std::vector<int> v = { 0, 1, 2, 3, 4, 5 };
|
||||
gdb::optional<std::vector<int>> o { v };
|
||||
VERIFY( !v.empty() );
|
||||
VERIFY( o->size() == 6 );
|
||||
}
|
||||
|
||||
{
|
||||
std::vector<int> v = { 0, 1, 2, 3, 4, 5 };
|
||||
gdb::optional<std::vector<int>> o { std::move(v) };
|
||||
VERIFY( v.empty() );
|
||||
VERIFY( o->size() == 6 );
|
||||
}
|
||||
|
||||
{
|
||||
std::vector<int> v = { 0, 1, 2, 3, 4, 5 };
|
||||
gdb::optional<std::vector<int>> o = std::move(v);
|
||||
VERIFY( v.empty() );
|
||||
VERIFY( o->size() == 6 );
|
||||
}
|
||||
|
||||
{
|
||||
std::vector<int> v = { 0, 1, 2, 3, 4, 5 };
|
||||
gdb::optional<std::vector<int>> o { std::move(v) };
|
||||
VERIFY( v.empty() );
|
||||
VERIFY( o->size() == 6 );
|
||||
}
|
||||
|
||||
{
|
||||
tracker t { 333 };
|
||||
gdb::optional<tracker> o = t;
|
||||
VERIFY( o->value == 333 );
|
||||
VERIFY( tracker::count == 2 );
|
||||
VERIFY( t.value == 333 );
|
||||
}
|
||||
|
||||
{
|
||||
tracker t { 333 };
|
||||
gdb::optional<tracker> o = std::move(t);
|
||||
VERIFY( o->value == 333 );
|
||||
VERIFY( tracker::count == 2 );
|
||||
VERIFY( t.value == -1 );
|
||||
}
|
||||
|
||||
enum outcome { nothrow, caught, bad_catch };
|
||||
|
||||
{
|
||||
outcome result = nothrow;
|
||||
throwing_construction t { false };
|
||||
|
||||
try
|
||||
{
|
||||
gdb::optional<throwing_construction> o { t };
|
||||
}
|
||||
catch(exception const&)
|
||||
{ result = caught; }
|
||||
catch(...)
|
||||
{ result = bad_catch; }
|
||||
|
||||
VERIFY( result == nothrow );
|
||||
}
|
||||
|
||||
{
|
||||
outcome result = nothrow;
|
||||
throwing_construction t { true };
|
||||
|
||||
try
|
||||
{
|
||||
gdb::optional<throwing_construction> o { t };
|
||||
}
|
||||
catch(exception const&)
|
||||
{ result = caught; }
|
||||
catch(...)
|
||||
{ result = bad_catch; }
|
||||
|
||||
VERIFY( result == caught );
|
||||
}
|
||||
|
||||
{
|
||||
outcome result = nothrow;
|
||||
throwing_construction t { false };
|
||||
|
||||
try
|
||||
{
|
||||
gdb::optional<throwing_construction> o { std::move(t) };
|
||||
}
|
||||
catch(exception const&)
|
||||
{ result = caught; }
|
||||
catch(...)
|
||||
{ result = bad_catch; }
|
||||
|
||||
VERIFY( result == nothrow );
|
||||
}
|
||||
|
||||
{
|
||||
outcome result = nothrow;
|
||||
throwing_construction t { true };
|
||||
|
||||
try
|
||||
{
|
||||
gdb::optional<throwing_construction> o { std::move(t) };
|
||||
}
|
||||
catch(exception const&)
|
||||
{ result = caught; }
|
||||
catch(...)
|
||||
{ result = bad_catch; }
|
||||
|
||||
VERIFY( result == caught );
|
||||
}
|
||||
|
||||
{
|
||||
#ifndef GDB_OPTIONAL
|
||||
gdb::optional<std::string> os = "foo";
|
||||
#endif
|
||||
struct X
|
||||
{
|
||||
explicit X(int) {}
|
||||
X& operator=(int) {return *this;}
|
||||
};
|
||||
#ifndef GDB_OPTIONAL
|
||||
gdb::optional<X> ox{42};
|
||||
#endif
|
||||
gdb::optional<int> oi{42};
|
||||
#ifndef GDB_OPTIONAL
|
||||
gdb::optional<X> ox2{oi};
|
||||
#endif
|
||||
gdb::optional<std::string> os2;
|
||||
os2 = "foo";
|
||||
#ifndef GDB_OPTIONAL
|
||||
gdb::optional<X> ox3;
|
||||
ox3 = 42;
|
||||
gdb::optional<X> ox4;
|
||||
ox4 = oi;
|
||||
#endif
|
||||
}
|
||||
{
|
||||
// no converting construction.
|
||||
#ifndef GDB_OPTIONAL
|
||||
gdb::optional<int> oi = gdb::optional<short>();
|
||||
VERIFY(!bool(oi));
|
||||
gdb::optional<std::string> os = gdb::optional<const char*>();
|
||||
VERIFY(!bool(os));
|
||||
#endif
|
||||
gdb::optional<gdb::optional<int>> ooi = gdb::optional<int>();
|
||||
VERIFY(bool(ooi));
|
||||
ooi = gdb::optional<int>();
|
||||
VERIFY(bool(ooi));
|
||||
ooi = gdb::optional<int>(42);
|
||||
VERIFY(bool(ooi));
|
||||
VERIFY(bool(*ooi));
|
||||
#ifndef GDB_OPTIONAL
|
||||
gdb::optional<gdb::optional<int>> ooi2 = gdb::optional<short>();
|
||||
VERIFY(bool(ooi2));
|
||||
ooi2 = gdb::optional<short>();
|
||||
VERIFY(bool(ooi2));
|
||||
ooi2 = gdb::optional<short>(6);
|
||||
VERIFY(bool(ooi2));
|
||||
VERIFY(bool(*ooi2));
|
||||
gdb::optional<gdb::optional<int>> ooi3 = gdb::optional<int>(42);
|
||||
VERIFY(bool(ooi3));
|
||||
VERIFY(bool(*ooi3));
|
||||
gdb::optional<gdb::optional<int>> ooi4 = gdb::optional<short>(6);
|
||||
VERIFY(bool(ooi4));
|
||||
VERIFY(bool(*ooi4));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace cons_value
|
@ -1,66 +0,0 @@
|
||||
// Copyright (C) 2013-2023 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library 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, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
namespace in_place {
|
||||
|
||||
static void
|
||||
test ()
|
||||
{
|
||||
// [20.5.5] In-place construction
|
||||
{
|
||||
gdb::optional<int> o { gdb::in_place };
|
||||
VERIFY( o );
|
||||
VERIFY( *o == int() );
|
||||
|
||||
#ifndef GDB_OPTIONAL
|
||||
static_assert( !std::is_convertible<gdb::in_place_t, gdb::optional<int>>(), "" );
|
||||
#endif
|
||||
}
|
||||
|
||||
{
|
||||
gdb::optional<int> o { gdb::in_place, 42 };
|
||||
VERIFY( o );
|
||||
VERIFY( *o == 42 );
|
||||
}
|
||||
|
||||
{
|
||||
gdb::optional<std::vector<int>> o { gdb::in_place, 18, 4 };
|
||||
VERIFY( o );
|
||||
VERIFY( o->size() == 18 );
|
||||
VERIFY( (*o)[17] == 4 );
|
||||
}
|
||||
|
||||
#ifndef GDB_OPTIONAL
|
||||
{
|
||||
gdb::optional<std::vector<int>> o { gdb::in_place, { 18, 4 } };
|
||||
VERIFY( o );
|
||||
VERIFY( o->size() == 2 );
|
||||
VERIFY( (*o)[0] == 18 );
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef GDB_OPTIONAL
|
||||
{
|
||||
gdb::optional<std::vector<int>> o { gdb::in_place, { 18, 4 }, std::allocator<int> {} };
|
||||
VERIFY( o );
|
||||
VERIFY( o->size() == 2 );
|
||||
VERIFY( (*o)[0] == 18 );
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
} // namespace in_place
|
@ -1,32 +0,0 @@
|
||||
// Copyright (C) 2013-2023 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library 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, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
namespace observers_1 {
|
||||
|
||||
struct value_type
|
||||
{
|
||||
int i;
|
||||
};
|
||||
|
||||
static void
|
||||
test ()
|
||||
{
|
||||
gdb::optional<value_type> o { value_type { 51 } };
|
||||
VERIFY( (*o).i == 51 );
|
||||
}
|
||||
|
||||
} // namespace observers_1
|
@ -1,36 +0,0 @@
|
||||
// Copyright (C) 2013-2023 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library 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, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library 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 library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
namespace observers_2 {
|
||||
|
||||
struct value_type
|
||||
{
|
||||
int i;
|
||||
};
|
||||
|
||||
void* operator&(const value_type&) = delete;
|
||||
|
||||
static void
|
||||
test ()
|
||||
{
|
||||
gdb::optional<value_type> o { value_type { 51 } };
|
||||
VERIFY( o->i == 51 );
|
||||
VERIFY( o->i == (*o).i );
|
||||
VERIFY( &o->i == &(*o).i );
|
||||
}
|
||||
|
||||
} // namespace observers_2
|
@ -1,233 +0,0 @@
|
||||
/* An optional object.
|
||||
|
||||
Copyright (C) 2017-2023 Free Software Foundation, Inc.
|
||||
|
||||
This file is part of GDB.
|
||||
|
||||
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/>. */
|
||||
|
||||
#ifndef COMMON_GDB_OPTIONAL_H
|
||||
#define COMMON_GDB_OPTIONAL_H
|
||||
|
||||
#include "gdbsupport/traits.h"
|
||||
|
||||
namespace gdb
|
||||
{
|
||||
|
||||
struct in_place_t
|
||||
{
|
||||
explicit in_place_t () = default;
|
||||
};
|
||||
|
||||
constexpr gdb::in_place_t in_place {};
|
||||
|
||||
/* This class attempts to be a compatible subset of std::optional,
|
||||
which is slated to be available in C++17. This class optionally
|
||||
holds an object of some type -- by default it is constructed not
|
||||
holding an object, but later the object can be "emplaced". This is
|
||||
similar to using std::unique_ptr, but in-object allocation is
|
||||
guaranteed.
|
||||
|
||||
Unlike std::optional, we currently only support copy/move
|
||||
construction/assignment of an optional<T> from either exactly
|
||||
optional<T> or T. I.e., we don't support copy/move
|
||||
construction/assignment from optional<U> or U, when U is a type
|
||||
convertible to T. Making that work depending on the definitions of
|
||||
T and U is somewhat complicated, and currently the users of this
|
||||
class don't need it. */
|
||||
|
||||
template<typename T>
|
||||
class optional
|
||||
{
|
||||
public:
|
||||
|
||||
constexpr optional ()
|
||||
: m_dummy ()
|
||||
{}
|
||||
|
||||
template<typename... Args>
|
||||
constexpr optional (in_place_t, Args &&... args)
|
||||
: m_item (std::forward<Args> (args)...),
|
||||
m_instantiated (true)
|
||||
{}
|
||||
|
||||
~optional ()
|
||||
{ this->reset (); }
|
||||
|
||||
/* Copy and move constructors. */
|
||||
|
||||
optional (const optional &other)
|
||||
{
|
||||
if (other.m_instantiated)
|
||||
this->emplace (other.get ());
|
||||
}
|
||||
|
||||
optional (optional &&other)
|
||||
noexcept(std::is_nothrow_move_constructible<T> ())
|
||||
{
|
||||
if (other.m_instantiated)
|
||||
this->emplace (std::move (other.get ()));
|
||||
}
|
||||
|
||||
constexpr optional (const T &other)
|
||||
: m_item (other),
|
||||
m_instantiated (true)
|
||||
{}
|
||||
|
||||
constexpr optional (T &&other)
|
||||
noexcept (std::is_nothrow_move_constructible<T> ())
|
||||
: m_item (std::move (other)),
|
||||
m_instantiated (true)
|
||||
{}
|
||||
|
||||
/* Assignment operators. */
|
||||
|
||||
optional &
|
||||
operator= (const optional &other)
|
||||
{
|
||||
if (m_instantiated && other.m_instantiated)
|
||||
this->get () = other.get ();
|
||||
else
|
||||
{
|
||||
if (other.m_instantiated)
|
||||
this->emplace (other.get ());
|
||||
else
|
||||
this->reset ();
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
optional &
|
||||
operator= (optional &&other)
|
||||
noexcept (And<std::is_nothrow_move_constructible<T>,
|
||||
std::is_nothrow_move_assignable<T>> ())
|
||||
{
|
||||
if (m_instantiated && other.m_instantiated)
|
||||
this->get () = std::move (other.get ());
|
||||
else
|
||||
{
|
||||
if (other.m_instantiated)
|
||||
this->emplace (std::move (other.get ()));
|
||||
else
|
||||
this->reset ();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
optional &
|
||||
operator= (const T &other)
|
||||
{
|
||||
if (m_instantiated)
|
||||
this->get () = other;
|
||||
else
|
||||
this->emplace (other);
|
||||
return *this;
|
||||
}
|
||||
|
||||
optional &
|
||||
operator= (T &&other)
|
||||
noexcept (And<std::is_nothrow_move_constructible<T>,
|
||||
std::is_nothrow_move_assignable<T>> ())
|
||||
{
|
||||
if (m_instantiated)
|
||||
this->get () = std::move (other);
|
||||
else
|
||||
this->emplace (std::move (other));
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename... Args>
|
||||
T &emplace (Args &&... args)
|
||||
{
|
||||
this->reset ();
|
||||
new (&m_item) T (std::forward<Args>(args)...);
|
||||
m_instantiated = true;
|
||||
return this->get ();
|
||||
}
|
||||
|
||||
/* Observers. */
|
||||
constexpr const T *operator-> () const
|
||||
{ return std::addressof (this->get ()); }
|
||||
|
||||
T *operator-> ()
|
||||
{ return std::addressof (this->get ()); }
|
||||
|
||||
constexpr const T &operator* () const &
|
||||
{ return this->get (); }
|
||||
|
||||
T &operator* () &
|
||||
{ return this->get (); }
|
||||
|
||||
T &&operator* () &&
|
||||
{ return std::move (this->get ()); }
|
||||
|
||||
constexpr const T &&operator* () const &&
|
||||
{ return std::move (this->get ()); }
|
||||
|
||||
constexpr explicit operator bool () const noexcept
|
||||
{ return m_instantiated; }
|
||||
|
||||
constexpr bool has_value () const noexcept
|
||||
{ return m_instantiated; }
|
||||
|
||||
/* 'reset' is a 'safe' operation with no precondition. */
|
||||
void reset () noexcept
|
||||
{
|
||||
if (m_instantiated)
|
||||
this->destroy ();
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
/* Destroy the object. */
|
||||
void destroy ()
|
||||
{
|
||||
gdb_assert (m_instantiated);
|
||||
m_instantiated = false;
|
||||
m_item.~T ();
|
||||
}
|
||||
|
||||
/* The get operations have m_instantiated as a precondition. */
|
||||
T &get () noexcept
|
||||
{
|
||||
#if defined(_GLIBCXX_DEBUG) && __cplusplus >= 201402L
|
||||
gdb_assert (this->has_value ());
|
||||
#endif
|
||||
return m_item;
|
||||
}
|
||||
constexpr const T &get () const noexcept
|
||||
{
|
||||
#if defined(_GLIBCXX_DEBUG) && __cplusplus >= 201402L
|
||||
gdb_assert (this->has_value ());
|
||||
#endif
|
||||
return m_item;
|
||||
}
|
||||
|
||||
/* The object. */
|
||||
union
|
||||
{
|
||||
struct { } m_dummy;
|
||||
T m_item;
|
||||
volatile char dont_use; /* Silences -Wmaybe-uninitialized warning, see
|
||||
PR gcc/80635. */
|
||||
};
|
||||
|
||||
/* True if the object was ever emplaced. */
|
||||
bool m_instantiated = false;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif /* COMMON_GDB_OPTIONAL_H */
|
Loading…
x
Reference in New Issue
Block a user