adobe-source-commits

[Foster B. <fos...@us...>]

Update of /cvsroot/adobe-source/adobe-source/adobe
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv1031/adobe

Modified Files:
	Jamfile.v2 adam.hpp adam_evaluate.hpp adam_parser.hpp 
	algorithm.hpp array.hpp array_fwd.hpp circular_queue.hpp 
	cmath.hpp config.hpp conversion.hpp copy_on_write.hpp 
	counter.hpp dancing_links.hpp dictionary.hpp 
	dictionary_fwd.hpp empty.hpp eve.hpp eve_evaluate.hpp 
	eve_parser.hpp extents.hpp final.hpp forest.hpp functional.hpp 
	istream.hpp istream_fwd.hpp iterator.hpp md5.hpp mismatch.hpp 
	name.hpp name_fwd.hpp numeric.hpp once.hpp regular_object.hpp 
	sha.hpp static_table.hpp string.hpp table_index.hpp 
	thread_id.hpp typeinfo.hpp unicode.hpp value.hpp value_fwd.hpp 
	virtual_machine.hpp xstring.hpp zuid.hpp 
Added Files:
	basic_sheet.hpp 
Log Message:
asl 1.0.13

Index: copy_on_write.hpp
===================================================================
RCS file: /cvsroot/adobe-source/adobe-source/adobe/copy_on_write.hpp,v
retrieving revision 1.7
retrieving revision 1.8
diff -C2 -d -r1.7 -r1.8
*** copy_on_write.hpp	6 Jan 2006 18:35:02 -0000	1.7
--- copy_on_write.hpp	3 Feb 2006 18:20:41 -0000	1.8
***************
*** 1,6 ****
  /*
! 	Copyright 2005-2006 Adobe Systems Incorporated
! 	Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
! 	or a copy at http://opensource.adobe.com/licenses.html)
  */
  
--- 1,6 ----
  /*
!     Copyright 2005-2006 Adobe Systems Incorporated
!     Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
!     or a copy at http://opensource.adobe.com/licenses.html)
  */
  
***************
*** 32,88 ****
  {
  public:
! 	typedef T value_type;
! 	
! 	explicit copy_on_write(const value_type& x = value_type()) :
! 		object_m(new implementation_t(x))
! 	{ }
  
! 	copy_on_write(const copy_on_write& x) :
! 		object_m(x.object_m)
! 	{
! 		object_m->ref_count_m.increment();
! 	}
  
! 	~copy_on_write()
! 	{
! 		if (object_m->ref_count_m.decrement()) delete object_m;
! 	}
  
! 	copy_on_write& operator = (const copy_on_write& x)
! 	{
! 		x.object_m->ref_count_m.increment();
! 		if (object_m->ref_count_m.decrement()) delete object_m;
! 		object_m = x.object_m;
! 		return *this;
! 	}
  
! 	value_type& write()
! 	{
! 		if (!object_m->ref_count_m.is_one())
! 		{
! 			implementation_t* temp = new implementation_t(object_m->value_m);
! 			object_m->ref_count_m.decrement();
! 			object_m = temp;
! 		}
  
! 		return object_m->value_m;
! 	}
! 	
! 	operator const value_type& () const
! 	{ return object_m->value_m; }
  
! 	const value_type& operator*() const { return object_m->value_m; }
! 	const value_type* operator->() const { return &object_m->value_m; }
  
! 	bool unique_instance() const { return object_m->ref_count_m.is_one(); }
! 	bool identity(const copy_on_write<T>& x) const { return object_m == x.object_m; }
! 	
  private:
! 	friend inline void swap(copy_on_write& x, copy_on_write& y)
! 	{ adobe::adl_swap(x.object_m, y.object_m); }
  
  #if !defined(ADOBE_NO_DOCUMENTATION)
! 	struct implementation_t;
! 	implementation_t*	object_m;
  #endif
  };
--- 32,88 ----
  {
  public:
!     typedef T value_type;
!     
!     explicit copy_on_write(const value_type& x = value_type()) :
!         object_m(new implementation_t(x))
!     { }
  
!     copy_on_write(const copy_on_write& x) :
!         object_m(x.object_m)
!     {
!         object_m->ref_count_m.increment();
!     }
  
!     ~copy_on_write()
!     {
!         if (object_m->ref_count_m.decrement()) delete object_m;
!     }
  
!     copy_on_write& operator = (const copy_on_write& x)
!     {
!         x.object_m->ref_count_m.increment();
!         if (object_m->ref_count_m.decrement()) delete object_m;
!         object_m = x.object_m;
!         return *this;
!     }
  
!     value_type& write()
!     {
!         if (!object_m->ref_count_m.is_one())
!         {
!             implementation_t* temp = new implementation_t(object_m->value_m);
!             object_m->ref_count_m.decrement();
!             object_m = temp;
!         }
  
!         return object_m->value_m;
!     }
!     
!     operator const value_type& () const
!     { return object_m->value_m; }
  
!     const value_type& operator*() const { return object_m->value_m; }
!     const value_type* operator->() const { return &object_m->value_m; }
  
!     bool unique_instance() const { return object_m->ref_count_m.is_one(); }
!     bool identity(const copy_on_write<T>& x) const { return object_m == x.object_m; }
!     
  private:
!     friend inline void swap(copy_on_write& x, copy_on_write& y)
!     { adobe::adl_swap(x.object_m, y.object_m); }
  
  #if !defined(ADOBE_NO_DOCUMENTATION)
!     struct implementation_t;
!     implementation_t*   object_m;
  #endif
  };
***************
*** 93,101 ****
  
  /*
! 	NOTE (sparent) : We cannot use boost::totaly_ordered to implement these operations portably
! 	(although it works with most compilers, it doesn't with CW 9.6). The problem is that 
! 	we do not know if T satifies the requirments for totally ordered or not - copy_on_write is
! 	only totally ordered if T is. By splitting the operations out to seperate template functions
! 	they are only instantiated if and where they are used.
  */
  
--- 93,101 ----
  
  /*
!     NOTE (sparent) : We cannot use boost::totaly_ordered to implement these operations portably
!     (although it works with most compilers, it doesn't with CW 9.6). The problem is that 
!     we do not know if T satifies the requirments for totally ordered or not - copy_on_write is
!     only totally ordered if T is. By splitting the operations out to seperate template functions
!     they are only instantiated if and where they are used.
  */
  
***************
*** 129,136 ****
  struct copy_on_write<T>::implementation_t : private boost::noncopyable
  {
! 	implementation_t(const value_type& x) : value_m(x) { }
  
!  	value_type			value_m;
!  	adobe::counter_t	ref_count_m;
  };
  
--- 129,136 ----
  struct copy_on_write<T>::implementation_t : private boost::noncopyable
  {
!     implementation_t(const value_type& x) : value_m(x) { }
  
!     value_type          value_m;
!     adobe::counter_t    ref_count_m;
  };
  

Index: thread_id.hpp
===================================================================
RCS file: /cvsroot/adobe-source/adobe-source/adobe/thread_id.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** thread_id.hpp	6 Jan 2006 18:35:02 -0000	1.3
--- thread_id.hpp	3 Feb 2006 18:20:41 -0000	1.4
***************
*** 1,6 ****
  /*
! 	Copyright 2005-2006 Adobe Systems Incorporated and others
! 	Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
! 	or a copy at http://opensource.adobe.com/licenses.html)
  */
  
--- 1,6 ----
  /*
!     Copyright 2005-2006 Adobe Systems Incorporated and others
!     Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
!     or a copy at http://opensource.adobe.com/licenses.html)
  */
  

Index: dictionary.hpp
===================================================================
RCS file: /cvsroot/adobe-source/adobe-source/adobe/dictionary.hpp,v
retrieving revision 1.5
retrieving revision 1.6
diff -C2 -d -r1.5 -r1.6
*** dictionary.hpp	6 Jan 2006 18:35:02 -0000	1.5
--- dictionary.hpp	3 Feb 2006 18:20:41 -0000	1.6
***************
*** 1,6 ****
  /*
! 	Copyright 2005-2006 Adobe Systems Incorporated
! 	Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
! 	or a copy at http://opensource.adobe.com/licenses.html)
  */
  
--- 1,6 ----
  /*
!     Copyright 2005-2006 Adobe Systems Incorporated
!     Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
!     or a copy at http://opensource.adobe.com/licenses.html)
  */
  
***************
*** 32,57 ****
  
  namespace adobe {
! 	
  /*************************************************************************************************/
  
  class dictionary_t::write_reference
! 	{
! 	public:
! 		value_t& operator[] (name_t key);
! 	protected:
! 		friend class dictionary_t;
! 		
! 		write_reference(dictionary_t& x) :
! 			fDictionary(x)
! 			{ }
! 	private:
! 		dictionary_t& fDictionary;
! 	};
  
  /*************************************************************************************************/
! 		
  inline dictionary_t::write_reference dictionary_t::write()
! 	{ return write_reference(*this); }
! 		
  /*************************************************************************************************/
  
--- 32,57 ----
  
  namespace adobe {
!     
  /*************************************************************************************************/
  
  class dictionary_t::write_reference
!     {
!     public:
!         value_t& operator[] (name_t key);
!     protected:
!         friend class dictionary_t;
!         
!         write_reference(dictionary_t& x) :
!             fDictionary(x)
!             { }
!     private:
!         dictionary_t& fDictionary;
!     };
  
  /*************************************************************************************************/
!         
  inline dictionary_t::write_reference dictionary_t::write()
!     { return write_reference(*this); }
!         
  /*************************************************************************************************/
  
***************
*** 61,66 ****
  template <class T>
  dictionary_t& dictionary_set(dictionary_t& object, name_t key, const T& x)
! 	{ return dictionary_set(object, key, value_t(x)); }
! 	
  /*************************************************************************************************/
  
--- 61,66 ----
  template <class T>
  dictionary_t& dictionary_set(dictionary_t& object, name_t key, const T& x)
!     { return dictionary_set(object, key, value_t(x)); }
!     
  /*************************************************************************************************/
  
***************
*** 68,74 ****
  struct dictionary_get<value_t>
  {
! 	const promote<value_t>::type& operator () (const dictionary_t& object, name_t key, select<value_t>);
  
! 	void operator () (const dictionary_t& object, name_t key, value_t& value);
  };
  
--- 68,74 ----
  struct dictionary_get<value_t>
  {
!     const promote<value_t>::type& operator () (const dictionary_t& object, name_t key, select<value_t>);
  
!     void operator () (const dictionary_t& object, name_t key, value_t& value);
  };
  
***************
*** 76,91 ****
  struct dictionary_get
  {
! 	const typename promote<T>::type& operator () (const dictionary_t& object, name_t key, select<T>)
! 	{
! 		return dictionary_get<value_t>()(object, key, select<value_t>()).template get<T>();
! 	}
  
! 	void operator () (const dictionary_t& object, name_t key, T& value)
! 	{
! 		value_t result;
  
! 		dictionary_get<value_t>()(object, key, result);
! 		result.get(value);
! 	}
  };
  
--- 76,91 ----
  struct dictionary_get
  {
!     const typename promote<T>::type& operator () (const dictionary_t& object, name_t key, select<T>)
!     {
!         return dictionary_get<value_t>()(object, key, select<value_t>()).template get<T>();
!     }
  
!     void operator () (const dictionary_t& object, name_t key, T& value)
!     {
!         value_t result;
  
!         dictionary_get<value_t>()(object, key, result);
!         result.get(value);
!     }
  };
  
***************
*** 94,188 ****
  template <typename T>
  inline const typename promote<T>::type& dictionary_t::get(name_t key) const
! 	{ return dictionary_get<T>()(*this, key, select<T>()); }
! 	
  template <typename T>
  inline void dictionary_t::get(name_t key, T& value) const
! 	{ dictionary_get<T>()(*this, key, value); }
! 	
  /*************************************************************************************************/
  
  template <class InputIterator>
  dictionary_t dictionary_ctor(InputIterator first, InputIterator last)
! 	{
! 	dictionary_t result;
! 	std::copy(first, last, result.inserter());
! 	return result;
! 	}
! 	
  /*************************************************************************************************/
  
  template <typename T>
  dictionary_t dictionary_ctor(const char* k0, const T& v0)
! 	{
! 	dictionary_t result;
! 	result.set(name_t(k0), v0);
! 	return result;
! 	}
  
  template <typename K0, typename V0, typename K1, typename V1>
! dictionary_t dictionary_ctor(	const K0& k0, const V0& v0,
! 							const K1& k1, const V1& v1 )
! 	{
! 	dictionary_t result;
! 	result.set(name_t(k0), v0);
! 	result.set(name_t(k1), v1);
! 	return result;
! 	}
! 	
  /*************************************************************************************************/
  
  class dictionary_t::const_iterator :
! 		public std::iterator<std::bidirectional_iterator_tag, dictionary_t::value_type,
! 			dictionary_t::difference_type, dictionary_t::const_pointer, dictionary_t::const_reference>
! 			
! 	{
! 	public:
! 		typedef dictionary_t::const_reference	const_reference;
! 		typedef dictionary_t::const_pointer	const_pointer;
! 		
! 		const_iterator(const const_iterator& x);
! 		~const_iterator() throw();
! 		
! 		const_iterator& operator= (const const_iterator& x);
  
! 		const_reference operator* () const throw();
! 		const_pointer operator -> () const throw();
! 		const_iterator& operator++ () throw();
! 		const_iterator operator++ (int);
! 		const_iterator& operator-- () throw();
! 		const_iterator operator-- (int);
! 		bool operator== (const const_iterator& rhs) const throw();
! 		bool operator!= (const const_iterator& rhs) const throw();
  
! 	protected:
! 		friend class dictionary_t;
! 		
! 		class begin { };
! 		class end { };
! 		
! 		const_iterator(const dictionary_t&, begin);
! 		const_iterator(const dictionary_t&, end);
! 		const_iterator(const dictionary_t&, name_t x); // Find form
! 	private:
! 		class implementation;
! 		const_iterator::implementation* object;
! 	};
! 		
  /*************************************************************************************************/
  
  inline dictionary_t::const_iterator dictionary_t::begin() const
! 	{ return const_iterator(*this, const_iterator::begin()); }
! 	
  inline dictionary_t::const_iterator dictionary_t::end() const
! 	{ return const_iterator(*this, const_iterator::end()); }
! 	
  inline dictionary_t::const_reverse_iterator dictionary_t::rbegin() const
! 	{ return const_reverse_iterator(end()); }
  
  inline dictionary_t::const_reverse_iterator dictionary_t::rend() const
! 	{ return const_reverse_iterator(begin()); }
  
  /*************************************************************************************************/
! 	
  } // namespace adobe
  
--- 94,188 ----
  template <typename T>
  inline const typename promote<T>::type& dictionary_t::get(name_t key) const
!     { return dictionary_get<T>()(*this, key, select<T>()); }
!     
  template <typename T>
  inline void dictionary_t::get(name_t key, T& value) const
!     { dictionary_get<T>()(*this, key, value); }
!     
  /*************************************************************************************************/
  
  template <class InputIterator>
  dictionary_t dictionary_ctor(InputIterator first, InputIterator last)
!     {
!     dictionary_t result;
!     std::copy(first, last, result.inserter());
!     return result;
!     }
!     
  /*************************************************************************************************/
  
  template <typename T>
  dictionary_t dictionary_ctor(const char* k0, const T& v0)
!     {
!     dictionary_t result;
!     result.set(name_t(k0), v0);
!     return result;
!     }
  
  template <typename K0, typename V0, typename K1, typename V1>
! dictionary_t dictionary_ctor(   const K0& k0, const V0& v0,
!                             const K1& k1, const V1& v1 )
!     {
!     dictionary_t result;
!     result.set(name_t(k0), v0);
!     result.set(name_t(k1), v1);
!     return result;
!     }
!     
  /*************************************************************************************************/
  
  class dictionary_t::const_iterator :
!         public std::iterator<std::bidirectional_iterator_tag, dictionary_t::value_type,
!             dictionary_t::difference_type, dictionary_t::const_pointer, dictionary_t::const_reference>
!             
!     {
!     public:
!         typedef dictionary_t::const_reference   const_reference;
!         typedef dictionary_t::const_pointer const_pointer;
!         
!         const_iterator(const const_iterator& x);
!         ~const_iterator() throw();
!         
!         const_iterator& operator= (const const_iterator& x);
  
!         const_reference operator* () const throw();
!         const_pointer operator -> () const throw();
!         const_iterator& operator++ () throw();
!         const_iterator operator++ (int);
!         const_iterator& operator-- () throw();
!         const_iterator operator-- (int);
!         bool operator== (const const_iterator& rhs) const throw();
!         bool operator!= (const const_iterator& rhs) const throw();
  
!     protected:
!         friend class dictionary_t;
!         
!         class begin { };
!         class end { };
!         
!         const_iterator(const dictionary_t&, begin);
!         const_iterator(const dictionary_t&, end);
!         const_iterator(const dictionary_t&, name_t x); // Find form
!     private:
!         class implementation;
!         const_iterator::implementation* object;
!     };
!         
  /*************************************************************************************************/
  
  inline dictionary_t::const_iterator dictionary_t::begin() const
!     { return const_iterator(*this, const_iterator::begin()); }
!     
  inline dictionary_t::const_iterator dictionary_t::end() const
!     { return const_iterator(*this, const_iterator::end()); }
!     
  inline dictionary_t::const_reverse_iterator dictionary_t::rbegin() const
!     { return const_reverse_iterator(end()); }
  
  inline dictionary_t::const_reverse_iterator dictionary_t::rend() const
!     { return const_reverse_iterator(begin()); }
  
  /*************************************************************************************************/
!     
  } // namespace adobe
  

Index: static_table.hpp
===================================================================
RCS file: /cvsroot/adobe-source/adobe-source/adobe/static_table.hpp,v
retrieving revision 1.5
retrieving revision 1.6
diff -C2 -d -r1.5 -r1.6
*** static_table.hpp	6 Jan 2006 18:35:02 -0000	1.5
--- static_table.hpp	3 Feb 2006 18:20:41 -0000	1.6
***************
*** 1,6 ****
  /*
! 	Copyright 2005-2006 Adobe Systems Incorporated
! 	Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
! 	or a copy at http://opensource.adobe.com/licenses.html)
  */
  
--- 1,6 ----
  /*
!     Copyright 2005-2006 Adobe Systems Incorporated
!     Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
!     or a copy at http://opensource.adobe.com/licenses.html)
  */
  
***************
*** 27,56 ****
  struct static_table_traits
  {
! 	typedef bool							result_type;
! 	typedef	KeyType							key_type;
! 	typedef	ValueType						value_type;
! 	typedef	std::pair<key_type, value_type>	entry_type;
  
! 	result_type operator()(const entry_type& x, const entry_type& y) const
! 	{
! 		return (*this)(x, y.first);
! 	}
  
! 	// revisit: MM. For debugging purposes, VC 8 requires the definition of
! 	// this (unnecessary overload) in debug versions.
! 	result_type operator()(const key_type& x, const entry_type& y) const
! 	{
! 		return x < y.first;
! 	}
  
! 	result_type operator()(const entry_type& x, const key_type& y) const
! 	{
! 		return x.first < y;
! 	}
  
! 	result_type equal(const key_type& x, const key_type& y) const
! 	{
! 		return x == y;
! 	}
  };
  
--- 27,56 ----
  struct static_table_traits
  {
!     typedef bool                            result_type;
!     typedef KeyType                         key_type;
!     typedef ValueType                       value_type;
!     typedef std::pair<key_type, value_type> entry_type;
  
!     result_type operator()(const entry_type& x, const entry_type& y) const
!     {
!         return (*this)(x, y.first);
!     }
  
!     // revisit: MM. For debugging purposes, VC 8 requires the definition of
!     // this (unnecessary overload) in debug versions.
!     result_type operator()(const key_type& x, const entry_type& y) const
!     {
!         return x < y.first;
!     }
  
!     result_type operator()(const entry_type& x, const key_type& y) const
!     {
!         return x.first < y;
!     }
  
!     result_type equal(const key_type& x, const key_type& y) const
!     {
!         return x == y;
!     }
  };
  
***************
*** 60,97 ****
  struct static_table
  {
! 	typedef Traits								traits_type;
! 	typedef	typename traits_type::key_type		key_type;
! 	typedef	typename traits_type::value_type	value_type;
! 	typedef	typename traits_type::entry_type	entry_type;
  
! 	const value_type& operator()(const key_type& key) const
! 	{
! 		const entry_type* iter(adobe::lower_bound(table_m, key, traits_type()));
  
! 		if (iter == boost::end(table_m) || !traits_type().equal(iter->first, key))
! 			throw std::logic_error("static_table key not found");
  
! 		return iter->second;
! 	}
  
! 	bool operator()(const key_type& key, value_type& result) const
! 	{
! 		const entry_type* iter(adobe::lower_bound(table_m, key, traits_type()));
  
! 		if (iter == boost::end(table_m) || !traits_type().equal(iter->first, key))
! 			return false;
  
! 		result = iter->second;
  
! 		return true;
! 	}
  
! 	void sort()
! 	{
! 		adobe::sort(table_m, traits_type());
! 	}
  
  public:
! 	entry_type table_m[Size];
  };
  
--- 60,97 ----
  struct static_table
  {
!     typedef Traits                              traits_type;
!     typedef typename traits_type::key_type      key_type;
!     typedef typename traits_type::value_type    value_type;
!     typedef typename traits_type::entry_type    entry_type;
  
!     const value_type& operator()(const key_type& key) const
!     {
!         const entry_type* iter(adobe::lower_bound(table_m, key, traits_type()));
  
!         if (iter == boost::end(table_m) || !traits_type().equal(iter->first, key))
!             throw std::logic_error("static_table key not found");
  
!         return iter->second;
!     }
  
!     bool operator()(const key_type& key, value_type& result) const
!     {
!         const entry_type* iter(adobe::lower_bound(table_m, key, traits_type()));
  
!         if (iter == boost::end(table_m) || !traits_type().equal(iter->first, key))
!             return false;
  
!         result = iter->second;
  
!         return true;
!     }
  
!     void sort()
!     {
!         adobe::sort(table_m, traits_type());
!     }
  
  public:
!     entry_type table_m[Size];
  };
  

Index: extents.hpp
===================================================================
RCS file: /cvsroot/adobe-source/adobe-source/adobe/extents.hpp,v
retrieving revision 1.6
retrieving revision 1.7
diff -C2 -d -r1.6 -r1.7
*** extents.hpp	6 Jan 2006 18:35:02 -0000	1.6
--- extents.hpp	3 Feb 2006 18:20:41 -0000	1.7
***************
*** 1,6 ****
  /*
! 	Copyright 2005-2006 Adobe Systems Incorporated
! 	Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
! 	or a copy at http://opensource.adobe.com/licenses.html)
  */
  
--- 1,6 ----
  /*
!     Copyright 2005-2006 Adobe Systems Incorporated
!     Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
!     or a copy at http://opensource.adobe.com/licenses.html)
  */
  
***************
*** 27,56 ****
  struct point_2d : boost::equality_comparable<point_2d<T> >
  {
! 	point_2d() :
! 		x_m(T()), y_m(T())
! 	{ }
  
! 	point_2d(const T& x, const T& y) :
! 		x_m(x), y_m(y)
! 	{ }
  
! 	T	x_m;
! 	T	y_m;
! 	
! 	friend inline void swap(const point_2d& x, const point_2d& y)
! 	{
! 		adobe::adl_swap(x.x_m, y.x_m);
! 		adobe::adl_swap(x.y_m, y.y_m);
! 	}
! 	
! 	friend inline void operator==(const point_2d& x, const point_2d& y)
! 	{
! 		return (x.x_m == y.x_m) && (x.y_m == y.y_m);
! 	}
  };
  
! typedef std::pair<long, long>	pair_long_t;
! typedef	point_2d<long>			point_2d_t;
! typedef	std::vector<long>		guide_set_t;
  
  // REVISIT (sparent) : points of interest need to be named entities. This will become:
--- 27,56 ----
  struct point_2d : boost::equality_comparable<point_2d<T> >
  {
!     point_2d() :
!         x_m(T()), y_m(T())
!     { }
  
!     point_2d(const T& x, const T& y) :
!         x_m(x), y_m(y)
!     { }
  
!     T   x_m;
!     T   y_m;
!     
!     friend inline void swap(const point_2d& x, const point_2d& y)
!     {
!         adobe::adl_swap(x.x_m, y.x_m);
!         adobe::adl_swap(x.y_m, y.y_m);
!     }
!     
!     friend inline void operator==(const point_2d& x, const point_2d& y)
!     {
!         return (x.x_m == y.x_m) && (x.y_m == y.y_m);
!     }
  };
  
! typedef std::pair<long, long>   pair_long_t;
! typedef point_2d<long>          point_2d_t;
! typedef std::vector<long>       guide_set_t;
  
  // REVISIT (sparent) : points of interest need to be named entities. This will become:
***************
*** 59,64 ****
  struct guide_set_t
  {
! 	adobe::name_t name_m;
! 	long		offset_m;
  };
  typedef std::vector<guide_set_t> point_of_interest_set_t;
--- 59,64 ----
  struct guide_set_t
  {
!     adobe::name_t name_m;
!     long        offset_m;
  };
  typedef std::vector<guide_set_t> point_of_interest_set_t;
***************
*** 69,73 ****
  struct extents_slices_t
  {
! 	enum slice_select_t { horizontal, vertical };
  };
  
--- 69,73 ----
  struct extents_slices_t
  {
!     enum slice_select_t { horizontal, vertical };
  };
  
***************
*** 76,110 ****
  struct extents_t :
  #if !defined(ADOBE_NO_DOCUMENTATION)
! 	private extents_slices_t, boost::equality_comparable<extents_t>
  #endif
  {
! 	struct slice_t : boost::equality_comparable<slice_t>
! 	{
! 		slice_t() : length_m(0) { };
  
! 		long		length_m;
! 		pair_long_t	outset_m;
! 		pair_long_t	frame_m;
! 		pair_long_t	inset_m;
! 		guide_set_t	poi_m;
! 		
! 		friend bool operator ==(const slice_t& x, const slice_t& y);
! 	};
  
! 	boost::array<slice_t, 2>	slice_m;
  
! 	slice_t&					vertical()			{ return slice_m[extents_slices_t::vertical]; }
! 	slice_t&					horizontal()		{ return slice_m[extents_slices_t::horizontal]; }
  
! 	const slice_t&				vertical() const	{ return slice_m[extents_slices_t::vertical]; }
! 	const slice_t&				horizontal() const	{ return slice_m[extents_slices_t::horizontal]; }
  
! 	long&						height()			{ return vertical().length_m; }
! 	long&						width()				{ return horizontal().length_m; }
  
! 	const long&					height() const		{ return vertical().length_m; }
! 	const long&					width() const		{ return horizontal().length_m; }
! 	
! 	friend  bool operator == (const extents_t& x, const extents_t& y);
  };
  
--- 76,110 ----
  struct extents_t :
  #if !defined(ADOBE_NO_DOCUMENTATION)
!     private extents_slices_t, boost::equality_comparable<extents_t>
  #endif
  {
!     struct slice_t : boost::equality_comparable<slice_t>
!     {
!         slice_t() : length_m(0) { };
  
!         long        length_m;
!         pair_long_t outset_m;
!         pair_long_t frame_m;
!         pair_long_t inset_m;
!         guide_set_t poi_m;
!         
!         friend bool operator ==(const slice_t& x, const slice_t& y);
!     };
  
!     boost::array<slice_t, 2>    slice_m;
  
!     slice_t&                    vertical()          { return slice_m[extents_slices_t::vertical]; }
!     slice_t&                    horizontal()        { return slice_m[extents_slices_t::horizontal]; }
  
!     const slice_t&              vertical() const    { return slice_m[extents_slices_t::vertical]; }
!     const slice_t&              horizontal() const  { return slice_m[extents_slices_t::horizontal]; }
  
!     long&                       height()            { return vertical().length_m; }
!     long&                       width()             { return horizontal().length_m; }
  
!     const long&                 height() const      { return vertical().length_m; }
!     const long&                 width() const       { return horizontal().length_m; }
!     
!     friend  bool operator == (const extents_t& x, const extents_t& y);
  };
  
***************
*** 112,120 ****
  
  #if defined(ADOBE_SERIALIZATION)
! std::ostream&	operator <<	(std::ostream& s, const adobe::extents_t& x);
  #endif
  
  #if defined(ADOBE_SERIALIZATION)
! std::ostream&	operator <<	(std::ostream& s, const adobe::extents_t::slice_t& x);
  #endif
  
--- 112,120 ----
  
  #if defined(ADOBE_SERIALIZATION)
! std::ostream&   operator << (std::ostream& s, const adobe::extents_t& x);
  #endif
  
  #if defined(ADOBE_SERIALIZATION)
! std::ostream&   operator << (std::ostream& s, const adobe::extents_t::slice_t& x);
  #endif
  
***************
*** 129,137 ****
  template <> inline void swap(adobe::extents_t::slice_t& x, adobe::extents_t::slice_t& y)
  {
! 	adobe::adl_swap(x.length_m, y.length_m);
! 	adobe::adl_swap(x.outset_m, y.outset_m);
! 	adobe::adl_swap(x.frame_m, y.frame_m);
! 	adobe::adl_swap(x.inset_m, y.inset_m);
! 	adobe::adl_swap(x.poi_m, y.poi_m);
  }
  
--- 129,137 ----
  template <> inline void swap(adobe::extents_t::slice_t& x, adobe::extents_t::slice_t& y)
  {
!     adobe::adl_swap(x.length_m, y.length_m);
!     adobe::adl_swap(x.outset_m, y.outset_m);
!     adobe::adl_swap(x.frame_m, y.frame_m);
!     adobe::adl_swap(x.inset_m, y.inset_m);
!     adobe::adl_swap(x.poi_m, y.poi_m);
  }
  

Index: functional.hpp
===================================================================
RCS file: /cvsroot/adobe-source/adobe-source/adobe/functional.hpp,v
retrieving revision 1.7
retrieving revision 1.8
diff -C2 -d -r1.7 -r1.8
*** functional.hpp	6 Jan 2006 18:35:02 -0000	1.7
--- functional.hpp	3 Feb 2006 18:20:41 -0000	1.8
***************
*** 1,6 ****
  /*
! 	Copyright 2005-2006 Adobe Systems Incorporated
! 	Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
! 	or a copy at http://opensource.adobe.com/licenses.html)
  */
  
--- 1,6 ----
  /*
!     Copyright 2005-2006 Adobe Systems Incorporated
!     Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
!     or a copy at http://opensource.adobe.com/licenses.html)
  */
  
***************
*** 27,31 ****
  struct element
...
 
[truncated message content]