Index: boost/xml/dom/attribute.hpp
===================================================================
--- boost/xml/dom/attribute.hpp	(revision 7403)
+++ boost/xml/dom/attribute.hpp	(working copy)
@@ -15,7 +15,7 @@
 template <typename S>
 class attribute : public node<S>
 {
-  friend node_ptr<attribute<S> > detail::ptr_factory<attribute<S> >(xmlNode *);
+  friend node_ptr<attribute<S> > ptr_factory<attribute<S> >(xmlNode *);
   friend class element<S>;
 public:
   S name() const { return converter<S>::out(this->impl()->name);}
Index: boost/xml/dom/detail.hpp
===================================================================
--- boost/xml/dom/detail.hpp	(revision 7403)
+++ boost/xml/dom/detail.hpp	(working copy)
@@ -22,6 +22,15 @@
   COMMENT,
 };
 
+template <typename N>
+node_ptr<N> ptr_factory(xmlNode *n) { return N(n);}
+
+template <typename S>
+std::auto_ptr<document<S> > factory(xmlDoc *d)
+{
+  return std::auto_ptr<document<S> >(new document<S>(d));}
+
+
 namespace detail
 {
 
@@ -51,7 +60,7 @@
 
 template <typename T> class wrapper;
 
-//. 
+//.
 class accessor
 {
 protected:
@@ -70,6 +79,7 @@
   friend class accessor;
 public:
   wrapper(T t) : impl_(t) {}
+  operator bool() const { return 0 != this->impl();}
 
 protected:
   using accessor::impl;
@@ -80,17 +90,11 @@
 };
 
 template <typename N>
-node_ptr<N> ptr_factory(xmlNode *n) { return N(n);}
-
-template <typename S>
-std::auto_ptr<document<S> > factory(xmlDoc *d)
-{
-  return std::auto_ptr<document<S> >(new document<S>(d));}
-
-template <typename N>
 class node_iterator : public wrapper<xmlNode*>
 {
 public:
+  typedef std::bidirectional_iterator_tag iterator_category;
+  typedef size_t difference_type;
   typedef node_iterator<N> self;
   typedef node_ptr<N> value_type;
   typedef value_type &reference;
@@ -99,7 +103,7 @@
   node_iterator(xmlNode *current = 0) : detail::wrapper<xmlNode*>(current) {}
   bool operator == (self i) { return impl() == impl(i);}
   bool operator != (self i) { return !operator==(i);}
-  value_type operator *() { return detail::ptr_factory<N>(impl());}
+  value_type operator *() { return ptr_factory<N>(impl());}
   pointer operator ->() { return &(operator *());}
   self operator ++(int) { increment(); return *this;}
   self operator ++() { self tmp = *this; increment(); return tmp;}
Index: boost/xml/dom/document.hpp
===================================================================
--- boost/xml/dom/document.hpp	(revision 7403)
+++ boost/xml/dom/document.hpp	(working copy)
@@ -20,7 +20,7 @@
 template <typename S>
 class document : public detail::wrapper<xmlDoc*>
 {
-  friend std::auto_ptr<document<S> > detail::factory<>(xmlDoc *);
+  friend std::auto_ptr<document<S> > factory<>(xmlDoc *);
   friend void process_xinclude<>(document<S> &);
 public:
   document(std::string const &version = "1.0")
@@ -29,18 +29,17 @@
   std::string encoding() const;
   dtd_ptr<S> internal_subset() const;
   dtd_ptr<S> create_internal_subset(std::string const &name,
-				    std::string const &external_id,
-				    std::string const &system_id);
+                std::string const &external_id,
+                std::string const &system_id);
 
   node_ptr<element<S> const> root() const;
   node_ptr<element<S> > root();
   node_ptr<element<S> > create_root(std::string const &name,
-				    std::string const &ns = std::string(),
-				    std::string const &ns_prefix = std::string());
+                std::string const &ns = std::string(),
+                std::string const &ns_prefix = std::string());
 
   void write_to_file(const std::string &filename,
-		     const std::string &encoding = std::string())
-    throw(std::runtime_error);
+           const std::string &encoding = std::string());
 private:
   document(xmlDoc *doc) : detail::wrapper<xmlDoc*>(doc) {}
 };
@@ -63,13 +62,13 @@
 template <typename S>
 inline dtd_ptr<S>
 document<S>::create_internal_subset(std::string const &name,
-				    std::string const &external_id,
-				    std::string const &system_id)
+                std::string const &external_id,
+                std::string const &system_id)
 {
   xmlDtd *d = xmlCreateIntSubset(this->impl(),
-				 reinterpret_cast<xmlChar const *>(name.c_str()),
-				 reinterpret_cast<xmlChar const *>(external_id.c_str()),
-				 reinterpret_cast<xmlChar const *>(system_id.c_str()));
+             reinterpret_cast<xmlChar const *>(name.c_str()),
+             reinterpret_cast<xmlChar const *>(external_id.c_str()),
+             reinterpret_cast<xmlChar const *>(system_id.c_str()));
   return dtd<S>(d);
 }
 
@@ -78,7 +77,7 @@
 {
   xmlNode *root = xmlDocGetRootElement(this->impl());
   assert(root);
-  return detail::ptr_factory<element<S> const>(root);
+  return ptr_factory<element<S> const>(root);
 }
 
 template <typename S>
@@ -90,16 +89,16 @@
 }
 
 template <typename S>
-inline node_ptr<element<S> > 
+inline node_ptr<element<S> >
 document<S>::create_root(std::string const &name,
-			 std::string const &ns_href,
-			 std::string const &ns_prefix)
+          std::string const &ns_href,
+          std::string const &ns_prefix)
 {
   xmlNode *node = xmlNewDocNode(this->impl(), 0, (xmlChar *)name.c_str(), 0);
   if(!ns_prefix.empty())
     xmlNewNs(node,
-	     (xmlChar *)(ns_href.empty() ? 0 : ns_href.c_str()),
-	     (xmlChar *) ns_prefix.c_str());
+        (xmlChar *)(ns_href.empty() ? 0 : ns_href.c_str()),
+        (xmlChar *) ns_prefix.c_str());
 
   xmlDocSetRootElement(this->impl(), node);
 
@@ -108,13 +107,12 @@
 
 template <typename S>
 inline void document<S>::write_to_file(const std::string &filename,
-				       const std::string &encoding)
-  throw(std::runtime_error)
+                   const std::string &encoding)
 {
   int result = 0;
   if(!encoding.empty())
     result = xmlSaveFormatFileEnc(filename.c_str(),
-				  this->impl(), encoding.c_str(), 1);
+              this->impl(), encoding.c_str(), 1);
   else
     result = xmlSaveFormatFile(filename.c_str(), this->impl(), 1);
 
Index: boost/xml/dom/element.hpp
===================================================================
--- boost/xml/dom/element.hpp	(revision 7403)
+++ boost/xml/dom/element.hpp	(working copy)
@@ -7,6 +7,7 @@
 #include <boost/xml/dom/comment.hpp>
 #include <boost/xml/dom/pi.hpp>
 #include <boost/xml/dom/cdata.hpp>
+#include <boost/xml/dom/detail.hpp>
 
 namespace boost
 {
@@ -19,7 +20,8 @@
 class element : public node<S>
 {
   friend class document<S>;
-  friend node_ptr<element<S> > detail::ptr_factory<>(xmlNode *);
+  friend class node_ptr<element<S> >;
+  friend node_ptr<element<S> > ptr_factory<>(xmlNode *);
 public:
   typedef detail::node_iterator<node<S> > child_iterator;
   typedef detail::node_iterator<node<S> const> const_child_iterator;
@@ -36,21 +38,21 @@
   //. Remove the attribute with the given name and value, if it exists.
   void unset_attribute(S const &name);
 
-  attribute_iterator begin_attributes() 
+  attribute_iterator begin_attributes()
   {
     xmlAttr *attr = this->impl()->properties;
     return attribute_iterator(reinterpret_cast<xmlNode *>(attr));
   }
-  const_attribute_iterator begin_attributes() const 
+  const_attribute_iterator begin_attributes() const
   {
     xmlAttr *attr = this->impl()->properties;
     return const_attribute_iterator(reinterpret_cast<xmlNode *>(attr));
   }
-  attribute_iterator end_attributes() 
+  attribute_iterator end_attributes()
   {
     return attribute_iterator();
   }
-  const_attribute_iterator end_attributes() const 
+  const_attribute_iterator end_attributes() const
   {
     return const_attribute_iterator();
   }
@@ -89,13 +91,13 @@
   void set_content(S const &content);
   void append_content(S const &content);
 
-  child_iterator begin_children() 
+  child_iterator begin_children()
   { return child_iterator(this->impl()->children);}
-  const_child_iterator begin_children() const 
+  const_child_iterator begin_children() const
   { return const_child_iterator(this->impl()->children);}
-  child_iterator end_children() 
+  child_iterator end_children()
   { return child_iterator();}
-  const_child_iterator end_children() const 
+  const_child_iterator end_children() const
   { return const_child_iterator();}
 
   //. Declare the namespace prefix to be an alias for uri.
@@ -136,13 +138,13 @@
 }
 
 template <typename S>
-inline node_ptr<attribute<S> > 
+inline node_ptr<attribute<S> >
 element<S>::set_attribute(S const &name, S const &value)
 {
   xmlAttr *attr = xmlSetProp(this->impl(),
                              converter<S>::in(name),
                              converter<S>::in(value));
-  return dom::attribute<S>(attr);
+  return dom::attribute<S>((xmlNode *)attr);
 }
 
 template <typename S>
@@ -152,7 +154,7 @@
 }
 
 template <typename S>
-inline node_ptr<element<S> > 
+inline node_ptr<element<S> >
 element<S>::append_element(S const &name)
 {
   xmlNode *node = xmlAddChild(this->impl(), xmlNewNode(0, converter<S>::in(name)));
@@ -160,7 +162,7 @@
 }
 
 template <typename S>
-inline node_ptr<element<S> > 
+inline node_ptr<element<S> >
 element<S>::insert_element(child_iterator i, S const &name)
 {
   xmlNode *node = xmlNewNode(0, converter<S>::in(name));
@@ -172,7 +174,7 @@
 }
 
 template <typename S>
-inline node_ptr<text<S> > 
+inline node_ptr<text<S> >
 element<S>::append_text(S const &name)
 {
   xmlNode *node = xmlAddChild(this->impl(), xmlNewText(converter<S>::in(name)));
@@ -180,7 +182,7 @@
 }
 
 template <typename S>
-inline node_ptr<text<S> > 
+inline node_ptr<text<S> >
 element<S>::insert_text(child_iterator i, S const &name)
 {
   xmlNode *node = xmlNewText(converter<S>::in(name));
@@ -196,7 +198,7 @@
 element<S>::append_comment(S const &content)
 {
   xmlNode *node = xmlAddChild(this->impl(),
-			      xmlNewComment(converter<S>::in(content)));
+               xmlNewComment(converter<S>::in(content)));
   return comment<S>(node);
 }
 
@@ -217,15 +219,15 @@
 element<S>::append_pi(S const &name, S const &content)
 {
   xmlNode *node = xmlAddChild(this->impl(), xmlNewPI(converter<S>::in(name),
-						     converter<S>::in(content)));
+                       converter<S>::in(content)));
   return pi<S>(node);
 }
 
 template <typename S>
 inline node_ptr<pi<S> >
 element<S>::insert_pi(child_iterator i,
-		      S const &name,
-		      S const &content)
+            S const &name,
+            S const &content)
 {
   xmlNode *node = xmlNewPI(converter<S>::in(name), converter<S>::in(content));
   if (impl(i))
@@ -263,7 +265,7 @@
 
 template <typename S>
 inline node_ptr<node<S> > element<S>::insert(child_iterator i,
-					     node_ptr<node<S> > child)
+                    node_ptr<node<S> > child)
 {
   xmlUnlinkNode(impl(*child));
   if (impl(i))
@@ -273,7 +275,7 @@
 }
 
 template <typename S>
-inline void element<S>::remove(element<S>::child_iterator i)
+inline void element<S>::remove(typename element<S>::child_iterator i)
 {
   if (i != end_children())
   {
@@ -318,7 +320,7 @@
 }
 
 template <typename S>
-typename element<S>::const_child_iterator 
+typename element<S>::const_child_iterator
 element<S>::find(node_ptr<node<S> const> n) const
 {
   xmlNode *child = impl(*n);
@@ -328,7 +330,7 @@
 }
 
 template <typename S>
-typename element<S>::child_iterator 
+typename element<S>::child_iterator
 element<S>::find(node_ptr<node<S> const> n)
 {
   //  xmlNode *child = impl(*n);
Index: boost/xml/dom/node.hpp
===================================================================
--- boost/xml/dom/node.hpp	(revision 7403)
+++ boost/xml/dom/node.hpp	(working copy)
@@ -3,6 +3,7 @@
 
 #include <boost/xml/dom/nodefwd.hpp>
 #include <boost/xml/dom/detail.hpp>
+#include <string>
 #include <stdexcept>
 
 namespace boost
@@ -15,13 +16,14 @@
 class invalid_cast : public std::invalid_argument
 {
 public:
-  invalid_cast(std::string const &msg) 
+  invalid_cast(std::string const &msg)
     : std::invalid_argument("invalid cast from " + msg) {}
 };
 
 template <typename N>
 class node_ptr
 {
+  friend class node_ptr<N>;
 public:
   node_ptr() : impl_(0) {}
   node_ptr(N const &n) : impl_(n) {}
@@ -31,7 +33,7 @@
   N &operator*() { return this->impl_;}
   N *operator->() { return &this->impl_;}
   N *get() { return &this->impl_;}
-  operator bool() const { return this->impl_.impl();}
+  operator bool() const { return this->impl_;}
 
 private:
   N impl_;
@@ -45,8 +47,8 @@
   friend class node_ptr<node<S> const>;
   friend class element<S>;
   friend class xpath<S>;
-  friend node_ptr<node<S> > detail::ptr_factory<node<S> >(xmlNode *);
-  friend node_ptr<node<S> const> detail::ptr_factory<node<S> const>(xmlNode *);
+  friend node_ptr<node<S> > ptr_factory<node<S> >(xmlNode *);
+  friend node_ptr<node<S> const> ptr_factory<node<S> const>(xmlNode *);
   template <typename T, typename N> friend T cast(node_ptr<N>);
 
 public:
@@ -59,19 +61,19 @@
   S path() const;
   //. Return the node's active base (See XBase).
   S base() const;
-  //. Return the node's active language.
+  //. Return the node's active language.  
   S lang() const;
 
   //. Return the parent node, if any.
-  node_ptr<element<S> const> parent() const 
-  { return detail::ptr_factory<element<S> >(this->impl()->parent);}
-  node_ptr<element<S> > parent() 
-  { return detail::ptr_factory<element<S> >(this->impl()->parent);}
+  node_ptr<element<S> const> parent() const
+  { return ptr_factory<element<S> >(this->impl()->parent);}
+  node_ptr<element<S> > parent()
+  { return ptr_factory<element<S> >(this->impl()->parent);}
 
 protected:
   node(xmlNode *n) : detail::wrapper<xmlNode*>(n) {}
   node(node<S> const &n) : detail::wrapper<xmlNode*>(n) {}
-  node<S> &operator=(node<S> const &n) 
+  node<S> &operator=(node<S> const &n)
   {
     detail::wrapper<xmlNode*>::operator=(n);
     return *this;
@@ -105,16 +107,16 @@
   return retn;
 }
 
-template <typename T, typename N> 
+template <typename T, typename N>
 inline T cast(node_ptr<N> n)
 {
-  if (n->impl() && 
+  if (n->impl() &&
       detail::node_type_table[n->impl()->type] != detail::target<T>::type)
   {
     node_type type = detail::node_type_table[n->impl()->type];
     throw invalid_cast(detail::node_type_names[type]);
   }
-  return detail::ptr_factory<typename detail::pointee<T>::type>(n->impl());
+  return ptr_factory<typename detail::pointee<T>::type>(n->impl());
 }
 
 } // namespace boost::xml::dom
Index: boost/xml/dom/node_set.hpp
===================================================================
--- boost/xml/dom/node_set.hpp	(revision 7403)
+++ boost/xml/dom/node_set.hpp	(working copy)
@@ -21,12 +21,12 @@
   ~node_set() { xmlXPathFreeNodeSet(this->impl());}
 
   size_t size() const { return this->impl()->nodeNr;}
-  node_ptr<node<S> > operator[] (size_t i) 
+  node_ptr<node<S> > operator[] (size_t i)
   {
-    return detail::ptr_factory<node<S> >(this->impl()->nodeTab[i]);
+    return ptr_factory<node<S> >(this->impl()->nodeTab[i]);
   }
 
-  iterator begin() 
+  iterator begin()
   {
     if (!this->impl()) return iterator(0, 0);
     else return iterator(this->impl()->nodeTab, this->impl()->nodeNr);
@@ -49,7 +49,7 @@
   iterator(xmlNode **array, int rest)
     : current_(array),
       rest_(rest ? --rest : 0),
-      tmp_(detail::ptr_factory<node<S> >(current_ ? *current_ : 0))
+      tmp_(ptr_factory<node<S> >(current_ ? *current_ : 0))
   {
   }
   bool operator == (iterator i) { return current_ == i.current_;}
@@ -59,13 +59,13 @@
   iterator operator ++(int) { increment(); return *this;}
   iterator operator ++() { iterator tmp = *this; increment(); return tmp;}
 private:
-  void increment() 
+  void increment()
   {
     if (rest_)
     {
       --rest_;
       ++current_;
-      tmp_ = detail::ptr_factory<node<S> >(*current_);
+      tmp_ = ptr_factory<node<S> >(*current_);
     }
     else
     {
Index: boost/xml/dom/parser.hpp
===================================================================
--- boost/xml/dom/parser.hpp	(revision 7403)
+++ boost/xml/dom/parser.hpp	(working copy)
@@ -99,9 +99,9 @@
     throw parse_error("Document not well-formed.");
   }
 
-  std::auto_ptr<document<S> > doc = detail::factory<S>(context->myDoc);
+  std::auto_ptr<document<S> > doc = factory<S>(context->myDoc);
 
-  bool well_formed = context->wellFormed;
+  bool well_formed = 0 != context->wellFormed;
 
   xmlFreeParserCtxt(context);