# C++ skeleton for Bison
-# Copyright (C) 2002-2012 Free Software Foundation, Inc.
+# Copyright (C) 2002-2013 Free Software Foundation, Inc.
# 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
typedef variant<S> self_type;
/// Empty construction.
- inline
variant ()]b4_parse_assert_if([
: built (false)
, tname (YY_NULL)])[
/// Instantiate a \a T in here.
template <typename T>
- inline T&
+ T&
build ()
{]b4_parse_assert_if([
//YYASSERT (!built);
/// Instantiate a \a T in here from \a t.
template <typename T>
- inline T&
+ T&
build (const T& t)
{]b4_parse_assert_if([
//YYASSERT (!built);
/// Construct and fill.
template <typename T>
- inline
variant (const T& t)]b4_parse_assert_if([
: built (true)
, tname (typeid (T).name ())])[
/// Accessor to a built \a T.
template <typename T>
- inline T&
+ T&
as ()
{]b4_parse_assert_if([
YYASSERT (built);
/// Const accessor to a built \a T (for %printer).
template <typename T>
- inline const T&
+ const T&
as () const
{]b4_parse_assert_if([
YYASSERT (built);
}
/// Swap the content with \a other, of same type.
- /// Both variants must be built beforehand.
+ /// Both variants must be built beforehand, because swapping the actual
+ /// data requires reading it (with as()), and this is not possible on
+ /// unconstructed variants: it would require some dynamic testing, which
+ /// should not be the variant's responsability.
+ /// Swapping between built and ((possibly) non-built is done with
+ /// variant::move ().
template <typename T>
- inline void
+ void
swap (variant<S>& other)
{]b4_parse_assert_if([
YYASSERT (built);
/// Assign the content of \a other to this.
/// Destroys \a other.
template <typename T>
- inline void
- build (variant<S>& other)
- {
+ void
+ move (variant<S>& other)
+ {]b4_parse_assert_if([
+ YYASSERT (! built);])[
build<T>();
swap<T>(other);
other.destroy<T>();
/// Copy the content of \a other to this.
/// Destroys \a other.
template <typename T>
- inline void
+ void
copy (const variant<S>& other)
{
build<T> (other.as<T> ());
/// Destroy the stored \a T.
template <typename T>
- inline void
+ void
destroy ()
{
as<T> ().~T ();]b4_parse_assert_if([
}
/// Prohibit blind copies.
- // private:
+ private:
self_type& operator=(const self_type&)
{
abort ();