rust/rust-compile-pattern.o \
rust/rust-compile-fnparam.o \
rust/rust-base62.o \
- rust/rust-optional-test.o \
rust/rust-compile-item.o \
rust/rust-compile-implitem.o \
rust/rust-compile-stmt.o \
Location locus, bool is_semi_coloned = false)
{
return std::unique_ptr<MacroInvocation> (
- new MacroInvocation (InvocKind::Regular, Optional<BuiltinMacro>::none (),
- invoc_data, outer_attrs, locus, is_semi_coloned,
- {}));
+ new MacroInvocation (InvocKind::Regular, tl::nullopt, invoc_data,
+ outer_attrs, locus, is_semi_coloned, {}));
}
/**
bool is_semi_coloned = false)
{
return std::unique_ptr<MacroInvocation> (
- new MacroInvocation (InvocKind::Builtin,
- Optional<BuiltinMacro>::some (kind), invoc_data,
- outer_attrs, locus, is_semi_coloned,
+ new MacroInvocation (InvocKind::Builtin, kind, invoc_data, outer_attrs,
+ locus, is_semi_coloned,
std::move (pending_eager_invocations)));
}
bool has_semicolon () const { return is_semi_coloned; }
InvocKind get_kind () const { return kind; }
- Optional<BuiltinMacro> get_builtin_kind () const { return builtin_kind; }
+ tl::optional<BuiltinMacro> get_builtin_kind () const { return builtin_kind; }
/**
* Turn the current MacroInvocation into a builtin macro invocation
void map_to_builtin (BuiltinMacro macro)
{
kind = InvocKind::Builtin;
- builtin_kind = Optional<BuiltinMacro>::some (macro);
+ builtin_kind = macro;
}
/**
private:
/* Full constructor */
MacroInvocation (
- InvocKind kind, Optional<BuiltinMacro> builtin_kind,
+ InvocKind kind, tl::optional<BuiltinMacro> builtin_kind,
MacroInvocData invoc_data, std::vector<Attribute> outer_attrs,
Location locus, bool is_semi_coloned,
std::vector<std::unique_ptr<MacroInvocation>> &&pending_eager_invocs)
InvocKind kind;
/* If it is a builtin macro, which one */
- Optional<BuiltinMacro> builtin_kind = Optional<BuiltinMacro>::none ();
+ tl::optional<BuiltinMacro> builtin_kind = tl::nullopt;
/**
* Pending invocations within a builtin macro invocation. This vector is empty
rust_assert (ok); // found
rust_assert (trait_item_ref->is_optional ()); // has definition
- // FIXME Optional means it has a definition and an associated
+ // FIXME tl::optional means it has a definition and an associated
// block which can be a default implementation, if it does not
// contain an implementation we should actually return
// error_mark_node
Analysis::Mappings &mappings, Resolver::Resolver &resolver,
const Rust::Resolver::TypeCheckContext &ty_ctx)
: mappings (mappings), resolver (resolver), ty_ctx (ty_ctx),
- current_module (Optional<NodeId>::none ())
+ current_module (tl::nullopt)
{}
void
case ModuleVisibility::Restricted: {
// If we are in the crate, everything is restricted correctly, but we
// can't get a module for it
- if (current_module.is_none ())
+ if (!current_module.has_value ())
return;
auto module = mappings.lookup_defid (vis.get_module_id ());
// We are in the module referenced by the pub(restricted) visibility.
// This is valid
- if (mod_node_id == current_module.get ())
+ if (mod_node_id == current_module.value ())
break;
// FIXME: This needs a LOT of TLC: hinting about the definition, a
// string to say if it's a module, function, type, etc...
- if (!is_child_module (mappings, mod_node_id, current_module.get ()))
+ if (!is_child_module (mappings, mod_node_id, current_module.value ()))
valid = false;
}
break;
// FIXME: We also need to think about module privacy
auto old_module = current_module;
- current_module
- = Optional<NodeId>::some (module.get_mappings ().get_nodeid ());
+ current_module = module.get_mappings ().get_nodeid ();
for (auto &item : module.get_items ())
item->accept_vis (*this);
const Rust::Resolver::TypeCheckContext &ty_ctx;
// `None` means we're in the root module - the crate
- Optional<NodeId> current_module;
+ tl::optional<NodeId> current_module;
};
} // namespace Privacy
{
const auto &name_str = item->as_string ();
auto tname = Feature::as_name (name_str);
- if (!tname.is_none ())
+ if (tname.has_value ())
{
- auto name = tname.get ();
+ auto name = tname.value ();
valid_features.insert (name);
}
case Feature::Name::ASSOCIATED_TYPE_BOUNDS:
return Feature (Feature::Name::ASSOCIATED_TYPE_BOUNDS,
Feature::State::ACCEPTED, "associated_type_bounds",
- "1.34.0", 52662,
- Optional<CompileOptions::Edition>::none (), "");
+ "1.34.0", 52662, tl::nullopt, "");
case Feature::Name::INTRINSICS:
return Feature (Feature::Name::INTRINSICS, Feature::State::ACCEPTED,
- "intrinsics", "1.0.0", 0,
- Optional<CompileOptions::Edition>::none (), "");
+ "intrinsics", "1.0.0", 0, tl::nullopt, "");
case Feature::Name::RUSTC_ATTRS:
return Feature (Feature::Name::RUSTC_ATTRS, Feature::State::ACCEPTED,
- "rustc_attrs", "1.0.0", 0,
- Optional<CompileOptions::Edition>::none (), "");
+ "rustc_attrs", "1.0.0", 0, tl::nullopt, "");
case Feature::Name::DECL_MACRO:
return Feature (Feature::Name::DECL_MACRO, Feature::State::ACCEPTED,
- "decl_macro", "1.0.0", 0,
- Optional<CompileOptions::Edition>::none (), "");
+ "decl_macro", "1.0.0", 0, tl::nullopt, "");
case Feature::Name::EXTERN_TYPES:
return Feature (Feature::Name::EXTERN_TYPES, Feature::State::ACTIVE,
- "extern_types", "1.23.0", 43467,
- Optional<CompileOptions::Edition>::none (), "");
+ "extern_types", "1.23.0", 43467, tl::nullopt, "");
default:
gcc_unreachable ();
}
{"extern_types", Feature::Name::EXTERN_TYPES},
}; // namespace Rust
-Optional<Feature::Name>
+tl::optional<Feature::Name>
Feature::as_name (const std::string &name)
{
if (Feature::name_hash_map.count (name))
- return Optional<Feature::Name>::some (Feature::name_hash_map.at (name));
- return Optional<Feature::Name>::none ();
+ return Feature::name_hash_map.at (name);
+
+ return tl::nullopt;
}
} // namespace Rust
\ No newline at end of file
#define RUST_FEATURE_H
#include "rust-session-manager.h"
-#include "rust-optional.h"
+#include "optional.h"
namespace Rust {
State state () { return m_state; }
unsigned issue () { return m_issue; }
- static Optional<Name> as_name (const std::string &name);
+ static tl::optional<Name> as_name (const std::string &name);
static Feature create (Name name);
private:
Feature (Name name, State state, const char *name_str,
const char *rustc_since, unsigned issue_number,
- const Optional<CompileOptions::Edition> &edition,
+ const tl::optional<CompileOptions::Edition> &edition,
const char *description)
: m_state (state), m_name (name), m_name_str (name_str),
m_rustc_since (rustc_since), m_issue (issue_number), edition (edition),
std::string m_name_str;
std::string m_rustc_since;
unsigned m_issue;
- Optional<CompileOptions::Edition> edition;
+ tl::optional<CompileOptions::Edition> edition;
std::string m_description;
static const std::map<std::string, Name> name_hash_map;
{"Hash", MacroBuiltin::proc_macro_builtin},
};
-// FIXME: This should return an Optional
+// FIXME: This should return an tl::optional
BuiltinMacro
builtin_macro_from_string (const std::string &identifier)
{
Lexer::Lexer (const std::string &input)
: input (RAIIFile::create_error ()), current_line (1), current_column (1),
- line_map (nullptr), dump_lex_out (Optional<std::ofstream &>::none ()),
+ line_map (nullptr), dump_lex_out ({}),
raw_input_source (new BufferInputSource (input, 0)),
input_queue{*raw_input_source}, token_queue (TokenSource (this))
{}
Lexer::Lexer (const char *filename, RAIIFile file_input, Linemap *linemap,
- Optional<std::ofstream &> dump_lex_opt)
+ tl::optional<std::ofstream &> dump_lex_opt)
: input (std::move (file_input)), current_line (1), current_column (1),
line_map (linemap), dump_lex_out (dump_lex_opt),
raw_input_source (new FileInputSource (input.get_raw ())),
Lexer::skip_token (int n)
{
// dump tokens if dump-lex option is enabled
- if (dump_lex_out.is_some ())
+ if (dump_lex_out.has_value ())
dump_and_skip (n);
else
token_queue.skip (n);
void
Lexer::dump_and_skip (int n)
{
- std::ofstream &out = dump_lex_out.get ();
+ std::ofstream &out = dump_lex_out.value ();
bool found_eof = false;
const_TokenPtr tok;
for (int i = 0; i < n + 1; i++)
#include "rust-linemap.h"
#include "rust-buffered-queue.h"
#include "rust-token.h"
-#include "rust-optional.h"
+#include "optional.h"
#include "selftest.h"
namespace Rust {
public:
// Construct lexer with input file and filename provided
Lexer (const char *filename, RAIIFile input, Linemap *linemap,
- Optional<std::ofstream &> dump_lex_opt
- = Optional<std::ofstream &>::none ());
+ tl::optional<std::ofstream &> dump_lex_opt = tl::nullopt);
// Lex the contents of a string instead of a file
Lexer (const std::string &input);
* allocating new linemap */
static const int max_column_hint = 80;
- Optional<std::ofstream &> dump_lex_out;
+ tl::optional<std::ofstream &> dump_lex_out;
// The input source for the lexer.
// InputSource input_source;
if (resolved_node_id == UNKNOWN_NODEID
&& previous_resolved_node_id == module_scope_id)
{
- Optional<CanonicalPath &> resolved_child
+ tl::optional<CanonicalPath &> resolved_child
= mappings->lookup_module_child (module_scope_id,
ident_seg.as_string ());
- if (resolved_child.is_some ())
+ if (resolved_child.has_value ())
{
NodeId resolved_node = resolved_child->get_node_id ();
if (resolver->get_name_scope ().decl_was_declared_here (
continue;
}
- Optional<CanonicalPath &> resolved_child
+ tl::optional<CanonicalPath &> resolved_child
= mappings->lookup_module_child (module_scope_id,
segment.get_segment_name ());
- if (resolved_child.is_some ())
+ if (resolved_child.has_value ())
{
NodeId resolved_node = resolved_child->get_node_id ();
if (resolver->get_name_scope ().decl_was_declared_here (
if (resolved_node_id == UNKNOWN_NODEID
&& previous_resolved_node_id == module_scope_id)
{
- Optional<CanonicalPath &> resolved_child
+ tl::optional<CanonicalPath &> resolved_child
= mappings->lookup_module_child (module_scope_id,
ident_seg.as_string ());
- if (resolved_child.is_some ())
+ if (resolved_child.has_value ())
{
NodeId resolved_node = resolved_child->get_node_id ();
if (resolver->get_name_scope ().decl_was_declared_here (
#include "rust-cfg-parser.h"
#include "rust-privacy-ctx.h"
#include "rust-ast-resolve-item.h"
-#include "rust-optional.h"
#include "rust-lex.h"
+#include "optional.h"
#include <mpfr.h>
// note: header files must be in this order or else forward declarations don't
rust_privacy_ctx_test ();
rust_crate_name_validation_test ();
rust_simple_path_resolve_test ();
- rust_optional_test ();
}
} // namespace selftest
// parse file here
/* create lexer and parser - these are file-specific and so aren't instance
* variables */
- Optional<std::ofstream &> dump_lex_opt = Optional<std::ofstream &>::none ();
+ tl::optional<std::ofstream &> dump_lex_opt = tl::nullopt;
std::ofstream dump_lex_stream;
if (options.dump_option_enabled (CompileOptions::LEXER_DUMP))
{
dump_lex_stream.open (kLexDumpFile);
if (dump_lex_stream.fail ())
- {
- rust_error_at (UNKNOWN_LOCATION, "cannot open %s:%m; ignored",
- kLexDumpFile);
- }
- auto stream = Optional<std::ofstream &>::some (dump_lex_stream);
- dump_lex_opt = std::move (stream);
+ rust_error_at (UNKNOWN_LOCATION, "cannot open %s:%m; ignored",
+ kLexDumpFile);
+
+ dump_lex_opt = dump_lex_stream;
}
Lexer lex (filename, std::move (file_wrap), linemap, dump_lex_opt);
{
for (const auto &value : pairs.second)
{
- if (value.is_some ())
- out << pairs.first + ": \"" + value.get () + "\"\n";
+ if (value.has_value ())
+ out << pairs.first + ": \"" + value.value () + "\"\n";
else
out << pairs.first + "\n";
}
#include "coretypes.h"
#include "options.h"
-#include "rust-optional.h"
+#include "optional.h"
namespace Rust {
// parser forward decl
{
/* TODO: maybe make private and access through helpers to allow changes to
* impl */
- std::unordered_map<std::string, std::unordered_set<Optional<std::string>>>
+ std::unordered_map<std::string, std::unordered_set<tl::optional<std::string>>>
features;
public:
{
auto it = features.find (key);
return it != features.end ()
- && it->second.find (Optional<std::string>::none ())
- != it->second.end ();
+ && it->second.find (tl::nullopt) != it->second.end ();
}
// Returns whether a key exists with the given value in the feature set.
if (it != features.end ())
{
auto set = it->second;
- auto it2 = set.find (Optional<std::string>::some (value));
+ auto it2 = set.find (value);
if (it2 != set.end ())
return true;
}
if (it != features.end ())
{
auto set = it->second;
- if (set.size () == 1 && set.begin ()->is_some ())
- return set.begin ()->get ();
+ if (set.size () == 1 && set.begin ()->has_value ())
+ return set.begin ()->value ();
}
return "";
}
return {};
for (auto &val : it->second)
- if (val.is_some ())
- ret.insert (val.get ());
+ if (val.has_value ())
+ ret.insert (val.value ());
return ret;
}
auto it = features.find (key);
if (it == features.end ())
- it = features
- .insert (
- std::make_pair (std::move (key),
- std::unordered_set<Optional<std::string>> ()))
- .first;
-
- return it->second.insert (Optional<std::string>::none ()).second;
+ it
+ = features
+ .insert (
+ std::make_pair (std::move (key),
+ std::unordered_set<tl::optional<std::string>> ()))
+ .first;
+
+ return it->second.insert (tl::nullopt).second;
}
// Inserts a key-value pair into the feature set.
auto it = features.find (key);
if (it == features.end ())
- it = features
- .insert (
- std::make_pair (std::move (key),
- std::unordered_set<Optional<std::string>> ()))
- .first;
-
- it->second.insert (Optional<std::string>::some (std::move (value)));
+ it
+ = features
+ .insert (
+ std::make_pair (std::move (key),
+ std::unordered_set<tl::optional<std::string>> ()))
+ .first;
+
+ it->second.insert (std::move (value));
}
// Dump all target options to stderr.
it->second.emplace_back (child);
}
-Optional<std::vector<NodeId> &>
+tl::optional<std::vector<NodeId> &>
Mappings::lookup_module_children (NodeId module)
{
auto it = module_child_map.find (module);
if (it == module_child_map.end ())
- return Optional<std::vector<NodeId> &>::none ();
+ return tl::nullopt;
- return Optional<std::vector<NodeId> &>::some (it->second);
+ return it->second;
}
void
it->second.emplace_back (child);
}
-Optional<std::vector<Resolver::CanonicalPath> &>
+tl::optional<std::vector<Resolver::CanonicalPath> &>
Mappings::lookup_module_chidren_items (NodeId module)
{
auto it = module_child_items.find (module);
if (it == module_child_items.end ())
- return Optional<std::vector<Resolver::CanonicalPath> &>::none ();
+ return tl::nullopt;
- return Optional<std::vector<Resolver::CanonicalPath> &>::some (it->second);
+ return it->second;
}
-Optional<Resolver::CanonicalPath &>
+tl::optional<Resolver::CanonicalPath &>
Mappings::lookup_module_child (NodeId module, const std::string &item_name)
{
- Optional<std::vector<Resolver::CanonicalPath> &> children
+ tl::optional<std::vector<Resolver::CanonicalPath> &> children
= lookup_module_chidren_items (module);
- if (children.is_none ())
- return Optional<Resolver::CanonicalPath &>::none ();
+ if (!children.has_value ())
+ return tl::nullopt;
// lookup the children to match the name if we can
- for (auto &child : children.get ())
+ for (auto &child : children.value ())
{
const std::string &raw_identifier = child.get ();
bool found = raw_identifier.compare (item_name) == 0;
if (found)
- return Optional<Resolver::CanonicalPath &>::some (child);
+ return child;
}
- return Optional<Resolver::CanonicalPath &>::none ();
+
+ return tl::nullopt;
}
void
child_to_parent_module_map.insert ({child_item, parent_module});
}
-Optional<NodeId>
+tl::optional<NodeId>
Mappings::lookup_parent_module (NodeId child_item)
{
auto it = child_to_parent_module_map.find (child_item);
if (it == child_to_parent_module_map.end ())
- return Optional<NodeId>::none ();
+ return tl::nullopt;
- return Optional<NodeId>::some (it->second);
+ return it->second;
}
bool
#ifndef RUST_HIR_MAP_H
#define RUST_HIR_MAP_H
-#include "rust-optional.h"
+#include "optional.h"
#include "rust-system.h"
#include "rust-location.h"
#include "rust-mapping-common.h"
bool lookup_visibility (NodeId id, Privacy::ModuleVisibility &def);
void insert_module_child (NodeId module, NodeId child);
- Optional<std::vector<NodeId> &> lookup_module_children (NodeId module);
+ tl::optional<std::vector<NodeId> &> lookup_module_children (NodeId module);
void insert_module_child_item (NodeId module, Resolver::CanonicalPath item);
- Optional<std::vector<Resolver::CanonicalPath> &>
+ tl::optional<std::vector<Resolver::CanonicalPath> &>
lookup_module_chidren_items (NodeId module);
- Optional<Resolver::CanonicalPath &>
+ tl::optional<Resolver::CanonicalPath &>
lookup_module_child (NodeId module, const std::string &item_name);
void insert_child_item_to_parent_module_mapping (NodeId child_item,
NodeId parent_module);
- Optional<NodeId> lookup_parent_module (NodeId child_item);
+ tl::optional<NodeId> lookup_parent_module (NodeId child_item);
bool node_is_module (NodeId query);
void insert_ast_item (AST::Item *item);
+++ /dev/null
-// Copyright (C) 2020-2024 Free Software Foundation, Inc.
-
-// This file is part of GCC.
-
-// GCC 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.
-
-// GCC 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 GCC; see the file COPYING3. If not see
-// <http://www.gnu.org/licenses/>.
-
-#include "rust-system.h"
-#include "rust-optional.h"
-#include "selftest.h"
-
-#if CHECKING_P
-
-static void
-rust_optional_create ()
-{
- auto opt = Rust::Optional<int>::some (15);
-
- ASSERT_TRUE (opt.is_some ());
- ASSERT_EQ (opt.get (), 15);
-
- Rust::Optional<int> const_opt = Rust::Optional<int>::some (15);
- const int &value = const_opt.get ();
-
- ASSERT_EQ (value, 15);
-}
-
-static void
-rust_optional_operators ()
-{
- auto opt = Rust::Optional<int>::some (15);
-
- // as bool
- ASSERT_TRUE (opt);
-
- // deref
- ASSERT_EQ (*opt, 15);
-
- class Methodable
- {
- public:
- int method () { return 15; }
- };
-
- auto m_opt = Rust::Optional<Methodable>::some (Methodable ());
- ASSERT_EQ (m_opt->method (), 15);
-}
-
-static void
-rust_optional_take ()
-{
- auto opt = Rust::Optional<int>::some (15);
- auto value = opt.take ();
-
- ASSERT_EQ (value, 15);
- ASSERT_TRUE (opt.is_none ());
-}
-
-static void
-rust_optional_map ()
-{
- auto opt = Rust::Optional<int>::some (15);
- auto twice = opt.map<int> ([] (int value) { return value * 2; });
-
- ASSERT_FALSE (opt);
- ASSERT_TRUE (twice);
- ASSERT_EQ (*twice, 30);
-}
-
-static void
-rust_optional_reference ()
-{
- auto value = std::vector<std::string> ();
- value.emplace_back ("rust");
- value.emplace_back ("+");
- value.emplace_back ("gcc");
- value.emplace_back ("=");
- value.emplace_back ("<3");
-
- auto opt = Rust::Optional<std::vector<std::string> &>::some (value);
-
- ASSERT_EQ (opt->at (0), "rust");
- ASSERT_EQ (opt->at (2), "gcc");
-}
-
-#endif /* #if CHECKING_P */
-
-void
-rust_optional_test ()
-{
-#if CHECKING_P
- rust_optional_create ();
- rust_optional_operators ();
- rust_optional_take ();
- rust_optional_map ();
- rust_optional_reference ();
-
-#endif /* #if CHECKING_P */
-}
+++ /dev/null
-// Copyright (C) 2020-2024 Free Software Foundation, Inc.
-
-// This file is part of GCC.
-
-// GCC 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.
-
-// GCC 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 GCC; see the file COPYING3. If not see
-// <http://www.gnu.org/licenses/>.
-
-#ifndef RUST_OPTIONAL_H
-#define RUST_OPTIONAL_H
-
-#include "config.h"
-#include "rust-system.h"
-
-#include "selftest.h"
-
-namespace Rust {
-
-/**
- * Tagged union to try and simulate a sum type. This is safer and more ergonomic
- * than one of the two alternatives we're currently using in the compiler:
- *
- * 1. Storing a raw pointer, which can be `nullptr` or valid
- *
- * This is wildly unsafe, and usable in conjunction with local references, stack
- * variables, or pointers managed elsewhere, which can cause crashes, hard to
- * debug issues or undefined behavior. Likewise, if you do not check for the
- * pointer's validity, this will cause a crash.
- *
- * 2. Storing an extra boolean alongside the object
- *
- * This causes implementors to use a "dummy object": Either an empty version or
- * an error version. But what happens if what you really wanted to store was
- * the empty or error version? You can also easily incorporate logic bugs if you
- * forget to check for the associated boolean.
- *
- * The `Optional<T>` type has the same "ergonomic" cost: You need to check
- * whether your option is valid or not. However, the main advantage is that it
- * is more restrictive: You can only acess the member it contains "safely".
- * It is similar to storing a value + an associated boolean, but has the
- * advantage of making up only one member in your class.
- * You also benefit from some helper methods such as `map()`.
- *
- * You also get helper functions and operator overloading to "seamlessly"
- * replace raw pointer alternatives.
- *
- * ```c++
- * MyType *raw_pointer = something_that_can_fail();
- * if (raw_pointer)
- * raw_pointer->method();
- *
- * // or
- *
- * Optional<MyType> opt = something_that_can_fail2();
- * if (opt)
- * opt->method();
- *
- * // equivalent to
- *
- * if (opt.is_some())
- * opt.get().method();
- * ```
- */
-template <typename T> class Optional
-{
-private:
- struct tag_some
- {
- };
- struct tag_none
- {
- };
-
- bool field_is_some;
-
- union
- {
- T value;
- // prevents initialization warnings
- // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80635#c53
- // FIXME: remove
- volatile char unused;
- };
-
- Optional (tag_some, const T &value) : field_is_some (true), value (value) {}
- Optional (tag_some, T &&value) : field_is_some (true), value (value) {}
-
- Optional (tag_none) : field_is_some (false) {}
-
-public:
- Optional (const Optional &other)
- {
- if ((field_is_some = other.field_is_some))
- new (&value) T (other.value);
- }
-
- Optional (Optional &&other)
- {
- if ((field_is_some = other.field_is_some))
- new (&value) T (other.value);
- }
-
- Optional &operator= (const Optional &other)
- {
- if (is_some ())
- value.~T ();
- if ((field_is_some = other.field_is_some))
- new (&value) T (other.value);
- return *this;
- }
-
- Optional &operator= (Optional &&other)
- {
- if (is_some ())
- value.~T ();
- if ((field_is_some = other.field_is_some))
- new (&value) T (other.value);
- return *this;
- }
-
- ~Optional ()
- {
- if (is_some ())
- value.~T ();
- }
-
- static Optional some (const T &value)
- {
- return Optional (tag_some (), value);
- }
-
- static Optional some (T &&value) { return Optional (tag_some (), value); }
-
- static Optional none () { return Optional (tag_none ()); }
-
- bool is_some () const { return field_is_some; }
- bool is_none () const { return !is_some (); }
-
- /**
- * Enable boolean-like comparisons.
- */
- operator bool () { return is_some (); }
-
- /**
- * Enables dereferencing to access the contained value
- */
- T &operator* () { return get (); }
- const T &operator* () const { return get (); }
- T *operator-> () { return &get (); }
- const T *operator-> () const { return &get (); }
-
- const T &get () const
- {
- rust_assert (is_some ());
-
- return value;
- }
-
- T &get ()
- {
- rust_assert (is_some ());
-
- return value;
- }
-
- T take ()
- {
- rust_assert (is_some ());
-
- T to_return = std::move (value);
- value.~T ();
-
- field_is_some = false;
-
- return to_return;
- }
-
- template <typename U> Optional<U> map (std::function<U (T)> functor)
- {
- if (is_none ())
- return Optional::none ();
-
- auto value = functor (take ());
-
- return Optional::some (value);
- }
-};
-
-template <typename T> class Optional<T &>
-{
-private:
- T *inner;
-
- Optional (T *inner) : inner (inner) {}
-
-public:
- static Optional<T &> some (T &value) { return Optional (&value); }
-
- static Optional<T &> none () { return Optional (nullptr); }
-
- bool is_some () const { return inner; }
- bool is_none () const { return !is_some (); }
-
- // FIXME: Can we factor this in a single class?
-
- /**
- * Enable boolean-like comparisons.
- */
- operator bool () { return is_some (); }
-
- /**
- * Enables dereferencing to access the contained value
- */
- T &operator* () { return get (); }
- const T &operator* () const { return get (); }
- T *operator-> () { return &get (); }
- const T *operator-> () const { return &get (); }
-
- T &get () const
- {
- rust_assert (is_some ());
-
- return *inner;
- }
-
- T &take ()
- {
- rust_assert (is_some ());
-
- T *to_return = inner;
- inner = nullptr;
-
- return *to_return;
- }
-
- template <typename U> Optional<U &> map (std::function<U &(T &)> functor)
- {
- if (is_none ())
- return Optional::none ();
-
- auto value = functor (take ());
-
- return Optional::some (value);
- }
-};
-
-template <typename T, typename U>
-bool
-operator== (const Optional<T> &t, const Optional<U> &u)
-{
- if (t.is_some ())
- return u.is_some () && t.get () == u.get ();
- else
- return u.is_none ();
-}
-
-} // namespace Rust
-
-namespace std {
-
-template <typename T> struct hash<Rust::Optional<T>>
-{
- size_t operator() (const Rust::Optional<T> &op) const
- {
- return op.is_some () ? std::hash<T> () (op.get ()) : 0;
- }
-};
-
-} // namespace std
-
-#ifdef CHECKING_P
-
-void
-rust_optional_test ();
-
-#endif // !CHECKING_P
-
-#endif // !RUST_OPTIONAL_H
projects / thirdparty / gcc.git / commitdiff
