Menu
▾
▴
adobe-source-commits
Update of /cvsroot/adobe-source/sandbox/visual_refactor/adobe/documentation/sources/asl In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv27679/adobe/documentation/sources/asl Added Files: adam.dox adam_evaluate.dox adam_parser.dox algorithm.dox array_t.dox circular_queue.dox conversion.dox copy_on_write.dox counter_t.dox defgroup_libraries.dox dictionary_t.dox empty_t.dox eve.dox eve_evaluate.dox eve_parser.dox final.dox forest.dox functional.dox istream.dox iterator.dox name_t.dox once.dox rectangle_t.dox static_table.dox string.dox table_index.dox typeinfo.dox value_t.dox virtual_machine_t.dox xstr.dox Log Message: SO SORRY for the large qty of emails -- creating a branch for Adobe Begin refactoring. --- NEW FILE: adam_parser.dox --- //***************************************************************************// //***************************************************************************// //***************************************************************************// /*! \defgroup adamparser Adam Parser \ingroup asl_libraries */ /*! \fn void adobe::parse(std::istream& stream, const adobe::line_position_t& position, const adobe::adam_callback_suite_t& callbacks) \ingroup adamparser The Adam parsing function. \param stream The input stream to be parsed. \param position The starting line position. \param callbacks The callback suite used for client code communication. */ /*! \fn adobe::array_t adobe::parse_adam_expression(const std::string& expression) \ingroup adamparser Parses an Adam expression. \param expression The expression to be parsed in tokenized form. */ //***************************************************************************// //***************************************************************************// //***************************************************************************// /*! \class adobe::adam_callback_suite_t adam_parser.hpp <adobe/adam_parser.hpp> \ingroup adamparser \brief Callback class for the Adam parser. Client-defined callback function used by the Adam parser to communicate with the client code. The Adam parser will discover cell declarations and will signal callbacks herein of those declarations. */ /*! \typedef adobe::adam_callback_suite_t::add_cell_proc_t A callback function signature for a \ref concept_convertible_to_function that needs to be supplied. During the parsing of an Adam definition, the client will receive cell declaration notifications through this callback. \param type cell type declared in the defintion. \param cell_name name of the cell specified. \param position position in the parse of the declaration. \param expr_or_init array of tokens representing one of several things. \param brief trailing comment to this cell. \param detailed leading comment to this cell. */ /*! \typedef adobe::adam_callback_suite_t::add_interface_proc_t A callback function signature for a \ref concept_convertible_to_function that needs to be supplied. During the parsing of an Adam definition, the client will receive interface cell declaration notifications through this callback. \param cell_name name of the cell specified. \param linked specifies if the output cell is back-linked to the input cell. \param position1 position1 in the parse of the declaration. \param initializer array of tokens representing the input cell initializer. \param position2 position2 in the parse of the declaration. \param expression array of tokens representing the output cell relation expression. \param brief trailing comment to this cell. \param detailed leading comment to this cell. */ /*! \typedef adobe::adam_callback_suite_t::add_relation_proc_t A callback function signature for a \ref concept_convertible_to_function that needs to be supplied. During the parsing of an Adam definition, the client will receive relation declaration notifications through this callback. \param position position in the parse of the relation set declaration \param conditional tokenized expression array representing the optional conditional enabling this relation set. \param first first relation in the set. \param last one-past-the-last relation in the set. \param brief trailing comment to relation set. \param detailed leading comment to relation set. \sa \ref adobe::adam_callback_suite_t::relation_t for more information on the relation_t type. */ /*! \enum adobe::adam_callback_suite_t::cell_type_t Enumeration type denoting the kind of cell found in the parse. */ /*! \var adobe::adam_callback_suite_t::cell_type_t adobe::adam_callback_suite_t::input_k Specifies a linked input cell for the \c add_cell_proc_m callback routine. If this cell type is specified the expression in the array_t is the cell initializer. */ /*! \var adobe::adam_callback_suite_t::cell_type_t adobe::adam_callback_suite_t::output_k Specifies an output cell for the \c add_cell_proc_m callback routine. If this cell type is specified the expression in the array_t is the relation expression. */ /*! \var adobe::adam_callback_suite_t::cell_type_t adobe::adam_callback_suite_t::constant_k Specifies a constant cell for the \c add_cell_proc_m callback routine. If this cell type is specified the expression in the array_t is the cell initializer. */ /*! \var adobe::adam_callback_suite_t::cell_type_t adobe::adam_callback_suite_t::logic_k Specifies a logic cell for the \c add_cell_proc_m callback routine. If this cell type is specified the expression in the array_t is the relation expression. */ /*! \var adobe::adam_callback_suite_t::cell_type_t adobe::adam_callback_suite_t::invariant_k Specifies an invariant cell for the \c add_cell_proc_m callback routine. If this cell type is specified the expression in the array_t is the relation expression. */ //***************************************************************************// //***************************************************************************// //***************************************************************************// /*! \class adobe::adam_callback_suite_t::relation_t \ingroup adamparser \brief Struct containing details of a relation expression for client callbacks from the Adam parser. Every relation declared in an Adam expression is parsed and packed into this struct for the client code. */ /*! \var adobe::adam_callback_suite_t::relation_t::name_m Name of the cell being operated upon by this relation. */ /*! \var adobe::adam_callback_suite_t::relation_t::position_m Position in the parse of the relation declaration. */ /*! \var adobe::adam_callback_suite_t::relation_t::expression_m Tokenized expression array of the relation. */ /*! \var adobe::adam_callback_suite_t::relation_t::detailed_m Leading comment for the relation. */ /*! \var adobe::adam_callback_suite_t::relation_t::brief_m Trailing comment for the relation. */ --- NEW FILE: final.dox --- /*! \defgroup adobe_final Final \ingroup asl_libraries */ /*! \def ADOBE_FINAL \ingroup adobe_final \par A mixin class to ensure that a class cannot be derived from. The term "final" is a Java keyword, for which there is no C++ equivalent. \par See CUJ May 2001, Page 51 for more information. \par Credit to Shanker Chandrabose for the idea. \author <a href="mailto:da...@ad...">Doug Ahmann</a> \date 05/10/2001 - created \example \code class foo : ADOBE_FINAL { }; \endcode \example \code class bar { }; class foo : public bar, ADOBE_FINAL { }; \endcode */ --- NEW FILE: empty_t.dox --- /*! \class adobe::empty_t empty.hpp <adobe/empty.hpp> \ingroup asl_libraries \model_of - \ref concept_regular_type - \ref stldoc_LessThanComparable \brief An empty regular- and less-than-comparable- type. \rationale empty_t is useful for default values. For example, value_t() will construct a value_t containing an empty_t by default. */ --- NEW FILE: functional.dox --- /*! \defgroup adobe_functional Functional \ingroup asl_libraries */ /*! \class adobe::delete_ptr<T*> functional.hpp <adobe/functional.hpp> \ingroup adobe_functional \brief A function object for type \c T that invokes \c delete on a \c T*. adobe::delete_ptr is similar to boost::lambda::delete_ptr except it inhereits from std::unary_function so it can also be used with boost::bind. That requirement changes the interface so the pointer type must be provided in advance. This is as of boost 1.28. This functionality may be included in later releases of boost. */ /*! \class adobe::delete_ptr<T(*)[]> functional.hpp <adobe/functional.hpp> \ingroup adobe_functional \brief A function object for type \c T that invokes \c delete[] on an array of \c T. adobe::delete_ptr is similar to boost::lambda::delete_ptr except it inhereits from std::unary_function so it can also be used with boost::bind. That requirement changes the interface so the pointer type must be provided in advance. This is as of boost 1.28. This functionality may be included in later releases of boost. */ /*! \class adobe::constructor functional.hpp <adobe/functional.hpp> \ingroup adobe_functional \brief A function object for type \c T that constructs a new T with parameters. adobe::constructor is similar to boost::lambda::constructor except it defines \c result_type so it can also be used with \c boost::bind. This is as of boost 1.32.0. Also had to add the \c const \c A1 parameters to compile with CodeWarrior 9.3. */ /*! \class adobe::generator_t functional.hpp <adobe/functional.hpp> \ingroup adobe_functional \brief A function object for value generation within a domain. */ /*! \class adobe::sequence_t functional.hpp <adobe/functional.hpp> \ingroup adobe_functional \brief A function object for sequence generation within a domain. */ /*! \defgroup compare_members Object Member Comparsion \ingroup adobe_functional The library provides basic function object classes for comparing two member variables between object instances. */ /*! \class adobe::compare_members_t functional.hpp <adobe/functional.hpp> \ingroup compare_members \brief Utility class for adobe::compare_members. */ /*! \fn adobe::compare_members_t<T, R, std::less<R> > adobe::compare_members(R T::* member) \ingroup compare_members Used to compare members in two objects of type \c T using \c std::less<R>. \param member Name of the member to compare. \return An adobe::compare_members_t which can be used to make the comparison. */ /*! \fn adobe::compare_members_t<T, R, Compare> adobe::compare_members(R T::* member, Compare compare) \ingroup compare_members Used to compare members in two objects of type \c T using a provided comparsion function object. \param member Name of the member to compare. \param compare \ref concept_convertible_to_function object used for comparing the instance members. \return An adobe::compare_members_t which can be used to make the comparison. */ /*! \defgroup transform_member Object Member Transformation \ingroup adobe_functional The library provides basic function object classes for transforming a class instance into a member variable of that class. */ /*! \class adobe::transform_member_t functional.hpp <adobe/functional.hpp> \ingroup transform_member \brief Adaptor similar to \c boost::mem_fn() used by \c boost::bind. Unlike boost::mem_fn() this is of use when you want to use a pointer to a member and have it return a non-const reference. \todo (sparent) Propose this addition back to Boost. */ /*! \fn adobe::transform_member_t<T, R> adobe::make_transform(R T::* member) \ingroup transform_member Used to transform an object as a contained member variable. \param member Name of the member to which to transform. \return An adobe::transform_member_t which can be used to make the transformation. */ /*! \class adobe::indirect_t functional.hpp <adobe/functional.hpp> \ingroup adobe_functional \brief Adapter used to convert pointers to references. */ /*! \defgroup bitwise_operators Bitwise Operations \ingroup adobe_functional The library provides basic function object classes for all of the bitwise logical operators in the language. */ /*! \class adobe::bitwise_or functional.hpp <adobe/functional.hpp> \ingroup bitwise_operators \brief \c operator() returns <code>x | y</code>. */ /*! \class adobe::bitwise_and functional.hpp <adobe/functional.hpp> \ingroup bitwise_operators \brief \c operator() returns <code>x & y</code>. */ /*! \class adobe::bitwise_xor functional.hpp <adobe/functional.hpp> \ingroup bitwise_operators \brief \c operator() returns <code>x ^ y</code>. */ --- NEW FILE: eve_parser.dox --- /*! \defgroup eveparser Eve Parser \ingroup asl_libraries */ /*! \typedef adobe::eve::position_t \ingroup eveparser Client-defined type that contains relevant client-dependent information. Passed as a parameter to the assemble_t function to denote the parent of a node being created. */ /*! \typedef adobe::eve::assemble_t \ingroup eveparser Client-defined callback function used by the Eve parser to communicate with the client code. The Eve parser will discover view class declarations and will notify this callback of those declarations. \param parent The parent view's position_t of the view currently being created. \param parse_location The line position of the view currently being created. \param name The name of the view currently being created. \param parameters An expression which will evaluate to a dictionary_t containing the view attributes. \param brief The contents of the trailing comment (if any) after this view class declaration \param detailed The contents of the lead comment (if any) before this view class declaration \return The client callback should return an adobe::eve::position_t, which is a user-defined type that will be propagated to any immediate children of this view class declaration (if any). */ /*! \fn adobe::line_position_t adobe::eve::parse(std::istream& in, const adobe::line_position_t&, const adobe::eve::position_t&, const adobe::eve::assemble_t&) \ingroup eveparser The Eve parsing function. \param in The input stream to be parsed. \param line_position The starting line position. \param position The initial client-specific data to be used for the root view declaration(s). \param assembler The client-defined callback function to be called whenever a new view class declaration is encountered. \exception adobe::stream_error_t Thrown upon parsing failure. See documentation on adobe::stream_error_t for more information about this type. \return Stream position information regarding where the parse finished. */ --- NEW FILE: typeinfo.dox --- /*! \class adobe::bad_cast typeinfo.hpp <adobe/typeinfo.hpp> \ingroup asl_libraries \brief An exception class thrown during ASL failures to cast. <code>adobe::bad_cast</code> is a decendant of <code>std::exception</code>. It is intended to provide detailed type information regarding the parameters into a cast that failed. If no <code>typeid()</code> information was used to construct the object, it simply relays "bad_cast". */ /*! \fn adobe::bad_cast::bad_cast(const std::type_info& from, const std::type_info& to) \param from <code>typeid()</code> result for the source object. \param to <code>typeid()</code> result for the destination type. */ /*! \fn const char* adobe::bad_cast::what() const throw() \return Either: - The string "bad_cast" - A string detailing the source and destination types that could not be cast successfully. */ --- NEW FILE: array_t.dox --- /*! \class adobe::array_t array.hpp <adobe/array.hpp> \ingroup asl_libraries \brief A copy-on-write array of <code>adobe::value_t</code>. array_t is an array of heterogeneous types. array_t is copy-on-write, intended for usage where copies are frequent, but writing is infrequent. Constructing an empty array will never throw an exception - no allocations are required until something is stored into it. Likewise, copying with assignment or copy constructor will not throw. \model_of - \ref concept_regular_type \note When copy-on-write semantics are not important, it is advised to use <code>std::vector<adobe::value_t></code> or another container type instead of array_t. \note \anchor _1 [1] Because an array_t is copy-on-write, modifications through an iterator are not supported except via back_insert_iterator. \tutorial A tutorial for \ref asl_tutorials_array_t is available. */ /*! \typedef adobe::array_t::size_type An unsigned integral type. */ /*! \typedef adobe::array_t::difference_type A signed integral type. */ /*! \typedef adobe::array_t::value_type The type of object, <code>adobe::value_t</code>, stored in the <code>array_t</code>. */ /*! \typedef adobe::array_t::reference Reference to <code>adobe::value_t</code>. */ /*! \typedef adobe::array_t::const_reference Const reference to <code>adobe::value_t</code>. */ /*! \typedef adobe::array_t::pointer Pointer to <code>adobe::value_t</code>. */ /*! \typedef adobe::array_t::const_pointer Const pointer to <code>adobe::value_t</code>. */ /*! \typedef adobe::array_t::iterator A random access iterator for the array \ref _1 "[1]". */ /*! \typedef adobe::array_t::const_iterator Equivalent to <code>array_t::iterator</code>. */ /*! \typedef adobe::array_t::reverse_iterator A reverse iterator into the array \ref _1 "[1]". */ /*! \typedef adobe::array_t::const_reverse_iterator Equivalent to <code>array_t:: reverse_iterator</code>. */ /*! \fn adobe::array_t::array_t(size_type n, const value_t& item) Initializes the array_t with <code>n</code> items of value <code>item</code>. */ /*! \fn adobe::array_t::const_reference adobe::array_t::at(adobe::array_t::size_type index) const \param index The index at which the element to be referenced resides. \note Identical semantics to operator[](). \return A const_reference to the element specified. */ /*! \fn adobe::array_t::const_reference adobe::array_t::operator[](adobe::array_t::size_type index) const \param index The index at which the element to be referenced resides. \note Identical semantics to at(). \return A const_reference to the element specified. */ /*! \fn T adobe::array_t::get(adobe::array_t::size_type index) const \param index The index at which the element to be referenced resides. \return A copy of the element at the specified index. \exception std::exception Throws when the index is out-of-range. */ /*! \fn void adobe::array_t::get(adobe::array_t::size_type index, T& value) const \param index The index at which the element to be referenced resides. \param value Assigned the result if successful. Otherwise, <code>value</code> is untouched. \exception None. Guaranteed not to throw. */ /*! \fn adobe::array_t::const_reference adobe::array_t::front() const \return A const_reference to the first element in the array. */ /*! \fn adobe::array_t::const_reference adobe::array_t::back() const \return A const_reference to the last element in the array. Note this returns a different element than end(). */ /*! \fn adobe::array_t::write_reference adobe::array_t::write() \return A write_reference to the array. \note copy_on_write semantics mandate a copy of the internal implementation if it is being shared. */ /*! \fn adobe::array_t::array_t& adobe::array_t::set(adobe::array_t::size_type index, const T& value) \param index The index at which the element to be modified resides. \param value The value to which the element at <code>index</code> is assigned. \return A new array; a duplicate of this one with the new value set at index <code>index</code>. */ /*! \fn adobe::array_t::array_t& adobe::array_t::push_back(const T& value) \param value The value to be appended to the end of the array. \return A new array; a duplicate of this one with this value appended. */ /*! \fn bool adobe::array_t::empty() const \return <code>true</code> if the array is void of elements, <code>false</code> otherwise. */ /*! \fn adobe::array_t::size_type adobe::array_t::size() const \return A count of the number of elements in the array. */ /*! \fn adobe::array_t::size_type adobe::array_t::max_size() const \return Number of elements allowed to be added to the array before a memory reallocation is required. */ /*! \fn void adobe::array_t::resize(adobe::array_t::size_type n, const value_t& c) \param n Number of elements to resize the array to. \param c Value to which all new elements are initialized. */ /*! \fn void adobe::array_t::assign(adobe::array_t::size_type n, const value_t& c) \todo (fbrereto) Detail parameters */ /*! \fn size_type adobe::array_t::erase(adobe::array_t::size_type x) \param x index of the element to be removed. \todo (fbrereto) Detail return */ /*! \fn void adobe::array_t::pop_back() Erases the last element in the array. */ /*! \fn void adobe::array_t::clear() Resets the array's internals to a default state. \note This will not guarantee destruction of the elements formerly contained within the array, as other arrays may also be referring to them. */ /*! \fn adobe::array_t::const_iterator adobe::array_t::begin() const \return An iterator to the first element in the array */ /*! \fn adobe::array_t::const_iterator adobe::array_t::end() const \return An iterator to one past the last element in the array */ /*! \fn adobe::array_t::const_reverse_iterator adobe::array_t::rbegin() const \return An iterator to one past the last element in the array */ /*! \fn adobe::array_t::const_reverse_iterator adobe::array_t::rend() const \return An iterator to the first element in the array */ /*! \fn adobe::array_t::back_insert_iterator adobe::array_t::back_inserter() \return An insert iterator into the array allowing for backside appending of new elements. */ /*! \fn bool adobe::array_t::identity(const array_t& x) const \param x Array to compare this array against. \return <code>true</code> if this array and the argument refer to the same copy_on_write instance; <code>false</code> otherwise. \note This is not the same as <code>operator==</code>. This function will return <code>false</code> if the arrays are identical but do not refer to the same implementation instance. */ /*! \fn bool adobe::array_t::unique_instance() const \return <code>true</code> if this array is the only one referrring to its implementation instance (i.e., the implementation instance is currently not being shared). <code>false</code> otherwise. */ /*! \class adobe::array_t::back_insert_iterator array.hpp <adobe/array.hpp> \ingroup asl_libraries \brief a back insert iterator for appending to array_t. Assignment through a <code>back_insert_iterator</code> will insert an object after the last element of an <code>array_t</code>. \model_of - \ref output_iterator */ --- NEW FILE: adam_evaluate.dox --- //***************************************************************************// //***************************************************************************// //***************************************************************************// /*! \fn adobe::adam_callback_suite_t adobe::bind_to_sheet(adobe::sheet_t&) \ingroup adamparser \param sheet the sheet to be bound to this parse of an adam file \return A callback suite for the parser to communicate to the sheet */ --- NEW FILE: value_t.dox --- /*! \class adobe::value_t value.hpp <adobe/value.hpp> \ingroup asl_libraries \brief A descriminated type for single values. \model_of - \ref concept_regular_type \details \par Type Promotion \c adobe::value_t leverages <code>adobe::promote</code> while storing instance values. This is an exception to the discriminating union concept to which \c adobe::value_t adheres. \par Getting a Value \c adobe::value_t uses <code>get<>()</code> to get its instance value. It behaves like an explicit cast and an assignment: getting a value_t out will always succeed and simply returns the same value_t. \par Setting a Value \c adobe::value_t uses <code>set<>()</code> to set its instance value. It behaves like an explicit cast and an assignment: putting a value_t into a value_t simply assigns the values; it does not wrap them. \par How does adobe::value_t differ from boost::any? value_t differs from <a href="http://www.boost.org/doc/html/any.html"><code>boost::any</code></a> in several ways: - value_t models \ref stldoc_EqualityComparable, fully modeling a \ref concept_regular_type. - value_t supports type promotion. See <code>adobe::promote</code> for more details. - get<>() results are returned by reference, making value_t generally more efficient. \tutorial A tutorial for \ref asl_tutorials_value_t is available. */ /*! \fn adobe::value_t::value_t(const T& x) \param x Value to copy as the instance value of this object. \note What is stored is a copy of <code>x</code> promoted to <code>promote<T>::type</code>. */ /*! \fn const typename promote<T>::type& adobe::value_t::get() const \return A refernce to a promoted type for <code>T</code> containing the <code>value_t</code>'s instance value. \exception adobe::bad_cast Thrown if <code>adobe::promote<T></code> does not match the stored instance type. */ /*! \fn typename promote<T>::type& adobe::value_t::get() \return A refernce to a promoted type for <code>T</code> containing the <code>value_t</code>'s instance value. \exception adobe::bad_cast Thrown if <code>adobe::promote<T></code> does not match the stored instance type. */ /*! \fn bool adobe::value_t::get(T& x) const \param x Value that will be set to the value stored in the value_t. \return <code>true</code> if x was set successfully, <code>false</code> otherwise. \exception Undefined Will relay anything thrown by <code>x.operator=()</code>. */ /*! \fn adobe::value_t& adobe::value_t::set(const T& x) \param x The new value to assign to this value_t. \return The value_t with its new value set. */ /*! \fn const std::type_info& adobe::value_t::type() const \return The information returned by <code>typeid()</code> for the instance value. */ /*! \class adobe::value_t::transform value.hpp <adobe/value.hpp> \ingroup asl_libraries \brief Function object used in binding for instance value access. */ /*! \typedef adobe::value_t::transform::result_type The promoted value type from T that will be returned by this function object's <code>operator()</code>s. */ /*! \typedef adobe::value_t::transform::argument_type Parameter type required by this function object's <code>operator()</code>s. */ /*! \fn promote<T>::type& adobe::value_t::transform::operator()(value_t &x) const \param x The value from which the result is to be obtained. \return A reference to the instance value stored in this value_t. */ /*! \fn const promote<T>::type& adobe::value_t::transform::operator()(const value_t &x) const \param x The value from which the result is to be obtained. \return A reference to the instance value stored in this value_t. */ --- NEW FILE: copy_on_write.dox --- //***************************************************************************// //***************************************************************************// //***************************************************************************// /*! \class adobe::copy_on_write copy_on_write.hpp <adobe/copy_on_write.hpp> \ingroup asl_libraries \brief A wrapper class enabling copy on write semantics for a type. \model_of - \ref concept_regular_type \rationale Copy on write semantics treat an object such that a copying becomes "lazy", that is, a copy of an object will only take place when absolutely necessary. This happens whenever the value is written to, hence the name "copy on write". Internally the object stores a reference count to a commonly shared element, and copies the element off at write time. If there is only one copy_on_write object referencing that element, no copies are made at write time. \note The copy_on_write class is thread safe when compiled with BOOST_HAS_THREADS defined. */ /*! \typedef adobe::copy_on_write::value_type \brief A typedef of the type T used as the underlying value type of this object. */ /*! \fn adobe::copy_on_write::copy_on_write(const value_type& x) \brief Constructs a new copy_on_write object with a value <code>x</code>. \param x A default value to assign to this object */ /*! \fn adobe::copy_on_write::copy_on_write(const copy_on_write& x) \brief Constructs a new copy_on_write object using another copy_on_write object as its value. \param x Right hand side element to duplicate */ /*! \fn value_type& adobe::copy_on_write::write() \brief Obtain a reference to the object the object is referencing. This will copy the underlying value (if necessary) so changes to the value do not affect other copy_on_write objects. \return A reference to the underlying object */ /*! \fn adobe::copy_on_write::operator const value_type&() const \brief Obtain a reference to the underlying object. \return A reference to the underlying object */ /*! \fn const value_type& adobe::copy_on_write::operator*() const \brief Obtain a reference to the underlying object. This is provided because you cannot override <code>operator . ()</code>. It allows copy_on_write to be used with common transformation techniques, such as boost <code>indirect_iterator</code> and <code>transform_iterator</code>. It does not imply "pointer" semantics. \return A reference to the underlying object */ /*! \fn const value_type* adobe::copy_on_write::operator->() const \brief Obtain a pointer to the underlying object. This is provided because you cannot override <code>operator . ()</code>. It allows copy_on_write to be used with common transformation techniques, such as boost <code>indirect_iterator</code> and <code>transform_iterator</code>. It does not imply "pointer" semantics. \return A pointer to the underlying object */ /*! \fn bool adobe::copy_on_write::unique_instance() const \brief unique_instance returns whether or not the reference count to the object instance is one. This is useful if you want to determine if writing will cause a copy. \return Boolean; <code>true</code> if the ref count for the instance is one. */ /*! \fn bool adobe::copy_on_write::identity(const copy_on_write< T > &x) const \brief identity is used to see if two copy_on_write items refer to the same instance. \return Boolean; <code>true</code> if the underlying object instance is shared by both objects. */ /*! \fn adobe::copy_on_write& adobe::copy_on_write::op... [truncated message content] |
Thanks for helping keep SourceForge clean.
X