|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r67291 - trunk/boost/spirit/home/support/utree
From: hartmut.kaiser_at_[hidden]
Date: 2010-12-17 21:29:51
Author: hkaiser
Date: 2010-12-17 21:29:50 EST (Fri, 17 Dec 2010)
New Revision: 67291
URL: http://svn.boost.org/trac/boost/changeset/67291
Log:
Spirit: whitespace fixes
Text files modified:
trunk/boost/spirit/home/support/utree/utree.hpp | 155 +++++++++++++++++++--------------------
1 files changed, 77 insertions(+), 78 deletions(-)
Modified: trunk/boost/spirit/home/support/utree/utree.hpp
==============================================================================
--- trunk/boost/spirit/home/support/utree/utree.hpp (original)
+++ trunk/boost/spirit/home/support/utree/utree.hpp 2010-12-17 21:29:50 EST (Fri, 17 Dec 2010)
@@ -38,8 +38,8 @@
{
//[utree_exceptions
// All exceptions thrown by utree are derived from utree_exception.
- struct utree_exception : std::exception {};
-
+ struct utree_exception : std::exception {};
+
// bad_type_exception is thrown whenever somebody calls a member function
// which applies to certain stored utree_type's only, but this precondition
// is violated as the utree instance holds some other type.
@@ -51,7 +51,7 @@
}
};
//]
-
+
//[utree_types
struct utree_type
{
@@ -66,12 +66,12 @@
// where F is an unary function object taking a
// scope as it's parameter and returning a
// utree.
-
+
// numeric atoms
bool_type,
int_type,
double_type,
-
+
// text atoms (utf8)
string_type,
string_range_type,
@@ -80,12 +80,12 @@
};
};
//]
-
+
///////////////////////////////////////////////////////////////////////////
// The nil type
///////////////////////////////////////////////////////////////////////////
struct nil {};
-
+
///////////////////////////////////////////////////////////////////////////
// A typed string with parametric Base storage. The storage can be any
// range or (stl container) of chars.
@@ -94,34 +94,34 @@
struct basic_string : Base
{
static utree_type::info const type = type_;
-
+
basic_string()
: Base() {}
-
+
basic_string(Base const& base)
: Base(base) {}
-
+
template <typename Iterator>
basic_string(Iterator bits, std::size_t len)
: Base(bits, bits + len) {}
-
+
template <typename Iterator>
basic_string(Iterator first, Iterator last)
: Base(first, last) {}
-
+
basic_string& operator=(basic_string const& other)
{
Base::operator=(other);
return *this;
}
-
+
basic_string& operator=(Base const& other)
{
Base::operator=(other);
return *this;
}
};
-
+
//[utree_strings
// Binary string
typedef basic_string<
@@ -132,7 +132,7 @@
std::string,
utree_type::binary_type>
binary_string;
-
+
// UTF-8 string
typedef basic_string<
boost::iterator_range<char const*>,
@@ -142,7 +142,7 @@
std::string,
utree_type::string_type>
utf8_string_type;
-
+
// UTF-8 symbol
typedef basic_string<
boost::iterator_range<char const*>,
@@ -153,13 +153,13 @@
utree_type::symbol_type>
utf8_symbol;
//]
-
+
///////////////////////////////////////////////////////////////////////////
// Our function type
///////////////////////////////////////////////////////////////////////////
class utree;
class scope;
-
+
//[utree_function_object_interface
struct function_base
{
@@ -170,7 +170,7 @@
// function_base instance
// that is equal to f.
};
-
+
template <typename F>
struct stored_function : function_base
{
@@ -181,21 +181,21 @@
virtual function_base* clone() const;
};
//]
-
+
///////////////////////////////////////////////////////////////////////////
// Shallow tag. Instructs utree to hold an iterator_range
// as-is without deep copying the range.
///////////////////////////////////////////////////////////////////////////
struct shallow_tag {};
shallow_tag const shallow = {};
-
+
///////////////////////////////////////////////////////////////////////////
// A void* plus type_info
///////////////////////////////////////////////////////////////////////////
class any_ptr
{
public:
-
+
template <typename Ptr>
typename boost::disable_if<
boost::is_polymorphic<
@@ -209,32 +209,32 @@
}
throw std::bad_cast();
}
-
+
template <typename T>
any_ptr(T* p)
: p(p), i(&typeid(T*))
{}
-
+
friend bool operator==(any_ptr const& a, any_ptr const& b)
{
return (a.p == b.p) && (*a.i == *b.i);
}
-
+
private:
-
+
// constructor is private
any_ptr(void* p, std::type_info const* i)
: p(p), i(i) {}
-
+
template <typename UTreeX, typename UTreeY>
friend struct detail::visit_impl;
-
+
friend class utree;
-
+
void* p;
std::type_info const* i;
};
-
+
//[utree
class utree {
public:
@@ -243,40 +243,40 @@
typedef utree const& const_reference;
typedef std::ptrdiff_t difference_type;
typedef std::size_t size_type;
-
+
typedef detail::list::node_iterator<utree>
iterator;
typedef detail::list::node_iterator<utree const>
const_iterator;
typedef detail::list::node_iterator<boost::reference_wrapper<utree> >
ref_iterator;
-
+
typedef boost::iterator_range<iterator> range;
typedef boost::iterator_range<const_iterator> const_range;
-
+
// dtor
~utree();
-
+
////////////////////////////////////////////////////////////////////////
// ctors and assignment operators
-
+
// nil
utree();
-
+
// boolean
utree(bool);
reference operator=(bool);
-
+
// integer
utree(unsigned int);
utree(int);
reference operator=(unsigned int);
reference operator=(int);
-
+
// double
utree(double);
reference operator=(double);
-
+
// string
utree(char);
utree(char const*);
@@ -286,81 +286,81 @@
reference operator=(char);
reference operator=(char const*);
reference operator=(std::string const&);
-
+
// reference
utree(boost::reference_wrapper<utree>);
reference operator=(boost::reference_wrapper<utree>);
-
+
// any
utree(any_ptr const&);
reference operator=(any_ptr const&);
-
+
// range
template <class Iter>
utree(boost::iterator_range<Iter>);
template <class Iter>
reference operator=(boost::iterator_range<Iter>);
-
+
// function object
template <class F>
utree(stored_function<F> const&);
template <class F>
reference operator=(stored_function<F> const&);
-
+
// typed string
template <class Base, utree_type::info type_>
utree(basic_string<Base, type_> const&);
template <class Base, utree_type::info type_>
reference operator=(basic_string<Base, type_> const&);
-
+
// copy
utree(const_reference);
reference operator=(const_reference);
-
+
// range
utree(range, shallow_tag);
utree(const_range, shallow_tag);
-
+
// assign dispatch
template <class Iter>
void assign(Iter, Iter);
-
+
////////////////////////////////////////////////////////////////////////
-
+
////////////////////////////////////////////////////////////////////////
// function object visitation interface
-
+
// single dispatch
template <class F>
typename boost::result_of<F(utree const&)>::type
static visit(utree const&, F);
-
+
template <class F>
typename boost::result_of<F(utree&)>::type
static visit(utree&, F);
-
+
// double dispatch
template <class F>
typename boost::result_of<F(utree const&, utree const&)>::type
static visit(utree const&, utree const&, F);
-
+
template <class F>
typename boost::result_of<F(utree&, utree const&)>::type
static visit(utree&, utree const&, F);
-
+
template <class F>
typename boost::result_of<F(utree const&, utree&)>::type
static visit(utree const&, utree&, F);
-
+
template <class F>
typename boost::result_of<F(utree&, utree&)>::type
static visit(utree&, utree&, F);
-
+
////////////////////////////////////////////////////////////////////////
-
+
////////////////////////////////////////////////////////////////////////
// STL Container interface
-
+
// insertion
template <class T>
void push_back(T const&);
@@ -372,71 +372,70 @@
void insert(iterator, std::size_t, T const&);
template <class Iter>
void insert(iterator, Iter, Iter);
-
+
// erasure
void pop_front();
void pop_back();
iterator erase(iterator);
iterator erase(iterator, iterator);
-
+
// front access
reference front();
const_reference front() const;
iterator begin();
const_iterator begin() const;
ref_iterator ref_begin();
-
+
// back access
reference back();
const_reference back() const;
iterator end();
const_iterator end() const;
ref_iterator ref_end();
-
+
// random access
reference operator[](size_type);
const_reference operator[](size_type) const;
-
+
void clear();
-
+
void swap(utree&);
-
+
bool empty() const;
size_type size() const;
-
+
////////////////////////////////////////////////////////////////////////
-
+
utree_type::info which() const;
-
+
template <class T>
T get() const;
-
+
reference deref();
const_reference deref() const;
-
+
short tag() const;
void tag(short);
-
+
utree eval(scope const&) const;
-
+
//<-
private:
typedef utree_type type;
-
+
template <class UTreeX, class UTreeY>
friend struct detail::visit_impl;
friend struct detail::index_impl;
friend struct detail::assign_impl;
-
+
template <class T>
friend struct detail::get_impl;
-
+
type::info get_type() const;
void set_type(type::info);
void ensure_list_type();
void free();
void copy(const_reference);
-
union {
detail::fast_string s;
@@ -453,7 +452,7 @@
//->
};
//]
-
+
//[utree_scope
class scope: public boost::iterator_range<utree*> {
public:
@@ -472,7 +471,7 @@
return parent;
}
//->
-
+
std::size_t level() const
//<-
{
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk