Ticket #6530: 20120207_fixed_typos_part_1.patch

File 20120207_fixed_typos_part_1.patch, 28.0 KB (added by Steven Samuel Cole <steven.samuel.cole@…>, 11 years ago)

patch file with typo fixes; created with svn diff in boost-trunk folder

  • boost/iostreams/stream.hpp

     
    3131    typedef Tr                                                 traits_type;
    3232    typedef typename category_of<Device>::type                 mode;
    3333    typedef typename
    34             iostreams::select< // Dismbiguation required for Tru64.
     34            iostreams::select< // Disambiguation required for Tru64.
    3535                mpl::and_<
    3636                    is_convertible<mode, input>,
    3737                    is_convertible<mode, output>
    … …  
    4343                BOOST_IOSTREAMS_BASIC_OSTREAM(char_type, traits_type)
    4444            >::type stream_type;
    4545    typedef typename
    46             iostreams::select< // Dismbiguation required for Tru64.
     46            iostreams::select< // Disambiguation required for Tru64.
    4747                mpl::and_<
    4848                    is_convertible<mode, input>,
    4949                    is_convertible<mode, output>
    … …  
    5757};
    5858
    5959// By encapsulating initialization in a base, we can define the macro
    60 // BOOST_IOSTREAMS_DEFINE_FORWARDING_FUNCTIONS to generate constuctors
     60// BOOST_IOSTREAMS_DEFINE_FORWARDING_FUNCTIONS to generate constructors
    6161// without base member initializer lists.
    6262template< typename Device,
    6363          typename Tr =
    … …  
    9696// Template name: stream.
    9797// Description: A iostream which reads from and writes to an instance of a
    9898//      designated device type.
    99 // Template paramters:
     99// Template parameters:
    100100//      Device - A device type.
    101101//      Alloc - The allocator type.
    102102//

  • boost/iostreams/detail/adapter/range_adapter.hpp

     
    3636//
    3737// Template name: range_adapter
    3838// Description: Device based on an instance of boost::iterator_range.
    39 // Template paramters:
     39// Template parameters:
    4040//     Mode - A mode tag.
    4141//     Range - An instance of iterator_range.
    4242//

  • boost/iostreams/detail/buffer.hpp

     
    3030//
    3131// Template name: buffer
    3232// Description: Character buffer.
    33 // Template paramters:
     33// Template parameters:
    3434//     Ch - The character type.
    3535//     Alloc - The Allocator type.
    3636//
    … …  
    6969// Template name: buffer
    7070// Description: Character buffer with two pointers accessible via ptr() and
    7171//      eptr().
    72 // Template paramters:
     72// Template parameters:
    7373//     Ch - A character type.
    7474//
    7575template< typename Ch,

  • boost/iostreams/detail/restrict_impl.hpp

     
    5656//
    5757// Template name: restricted_indirect_device.
    5858// Description: Provides an restricted view of an indirect Device.
    59 // Template paramters:
     59// Template parameters:
    6060//      Device - An indirect model of Device that models either Source or
    6161//          SeekableDevice.
    6262//
    … …  
    8888//
    8989// Template name: restricted_direct_device.
    9090// Description: Provides an restricted view of a Direct Device.
    91 // Template paramters:
     91// Template parameters:
    9292//      Device - A model of Direct and Device.
    9393//
    9494template<typename Device>
    … …  
    118118//
    119119// Template name: restricted_filter.
    120120// Description: Provides an restricted view of a Filter.
    121 // Template paramters:
     121// Template parameters:
    122122//      Filter - An indirect model of Filter.
    123123//
    124124template<typename Filter>

  • boost/iostreams/detail/streambuf/chainbuf.hpp

     
    3131// Template name: chainbuf.
    3232// Description: Stream buffer which operates by delegating to the first
    3333//      linked_streambuf in a chain.
    34 // Template paramters:
     34// Template parameters:
    3535//      Chain - The chain type.
    3636//
    3737template<typename Chain, typename Mode, typename Access>

  • boost/iostreams/tee.hpp

     
    3131
    3232//
    3333// Template name: tee_filter.
    34 // Template paramters:
     34// Template parameters:
    3535//      Device - A blocking Sink.
    3636//
    3737template<typename Device>
    … …  
    9999
    100100//
    101101// Template name: tee_device.
    102 // Template paramters:
     102// Template parameters:
    103103//      Device - A blocking Device.
    104104//      Sink - A blocking Sink.
    105105//

  • boost/iostreams/chain.hpp

     
    8484//
    8585// Concept name: Chain.
    8686// Description: Represents a chain of stream buffers which provides access
    87 //     to the first buffer in the chain and send notifications when the
     87//     to the first buffer in the chain and sends notifications when the
    8888//     streambufs are added to or removed from chain.
    8989// Refines: Closable device with mode equal to typename Chain::mode.
    9090// Models: chain, converting_chain.

  • boost/iostreams/filter/counter.hpp

     
    2525
    2626//
    2727// Template name: basic_counter.
    28 // Template paramters:
     28// Template parameters:
    2929//      Ch - The character type.
    3030// Description: Filter which counts lines and characters.
    3131//

  • boost/iostreams/filter/aggregate.hpp

     
    3333
    3434//
    3535// Template name: aggregate_filter.
    36 // Template paramters:
     36// Template parameters:
    3737//      Ch - The character type.
    3838//      Alloc - The allocator type.
    3939// Description: Utility for defining DualUseFilters which filter an

  • boost/iostreams/filter/line.hpp

     
    3131
    3232//
    3333// Template name: line_filter.
    34 // Template paramters:
     34// Template parameters:
    3535//      Ch - The character type.
    3636//      Alloc - The allocator type.
    3737// Description: Filter which processes data one line at a time.

  • boost/iostreams/compose.hpp

     
    5555//
    5656// Template name: composite_device.
    5757// Description: Provides a Device view of a Filter, Device pair.
    58 // Template paramters:
     58// Template parameters:
    5959//      Filter - A model of Filter.
    6060//      Device - An indirect model of Device.
    6161//
    … …  
    115115//
    116116// Template name: composite_device.
    117117// Description: Provides a Device view of a Filter, Device pair.
    118 // Template paramters:
     118// Template parameters:
    119119//      Filter - A model of Filter.
    120120//      Device - An indirect model of Device.
    121121//

  • boost/iostreams/close.hpp

     
    7373    boost::iostreams::close(t, snk, BOOST_IOS::out);
    7474}
    7575
    76 } // End namespaces detail.
     76} // End namespace detail.
    7777
    7878} } // End namespaces iostreams, boost.
    7979

  • boost/iostreams/invert.hpp

     
    3636
    3737//
    3838// Template name: inverse.
    39 // Template paramters:
     39// Template parameters:
    4040//      Filter - A model of InputFilter or OutputFilter.
    4141// Description: Generates an InputFilter from an OutputFilter or
    4242//      vice versa.
    … …  
    151151
    152152//
    153153// Template name: invert.
    154 // Template paramters:
     154// Template parameters:
    155155//      Filter - A model of InputFilter or OutputFilter.
    156156// Description: Returns an instance of an appropriate specialization of inverse.
    157157//

  • boost/iostreams/combine.hpp

     
    3737//
    3838// Template name: combined_device.
    3939// Description: Model of Device defined in terms of a Source/Sink pair.
    40 // Template paramters:
     40// Template parameters:
    4141//      Source - A model of Source, with the same char_type and traits_type
    4242//          as Sink.
    4343//      Sink - A model of Sink, with the same char_type and traits_type
    … …  
    7777//
    7878// Template name: combined_filter.
    7979// Description: Model of Device defined in terms of a Source/Sink pair.
    80 // Template paramters:
     80// Template parameters:
    8181//      InputFilter - A model of InputFilter, with the same char_type as
    8282//          OutputFilter.
    8383//      OutputFilter - A model of OutputFilter, with the same char_type as
    … …  
    179179//
    180180// Template name: combine.
    181181// Description: Takes a Source/Sink pair or InputFilter/OutputFilter pair and
    182 //      returns a Reource or Filter which performs input using the first member
     182//      returns a Source or Filter which performs input using the first member
    183183//      of the pair and output using the second member of the pair.
    184 // Template paramters:
     184// Template parameters:
    185185//      In - A model of Source or InputFilter, with the same char_type as Out.
    186186//      Out - A model of Sink or OutputFilter, with the same char_type as In.
    187187//

  • libs/iostreams/doc/classes/grep_filter.html

     
    3030    The class template <CODE>basic_grep_filter</CODE> filters a character sequence line by line using a regular expression provided at construction, in a manner similar to the command-line utility <i>grep</i> (<A CLASS="bib_ref" HREF="../bibliography.html#grep">[IEEE]</A>). The filter uses regular expressions from the <A HREF="http://www.boost.org/libs/regex" TARGET="_top">Boost Regular Expression Library</A> (<A CLASS="bib_ref" HREF="../bibliography.html#maddock">[Maddock]</A>).
    3131</P>
    3232<P>
    33     By default, the filtered character sequence consists of those lines of the unfilitered sequence that contain a subsequence matching the regular expression. By specifying appropriate options at construction, <CODE>basic_grep_filter</CODE> can be made to pass through only those lines which exactly match the regular expression (as if the option <i>-x</i> had been  passed to the command-line utility) or only those lines that <i>do not</i> contain a match (as if the option <i>-v</i> had been  passed to the command-line utility).
     33    By default, the filtered character sequence consists of those lines of the unfiltered sequence that contain a subsequence matching the regular expression. By specifying appropriate options at construction, <CODE>basic_grep_filter</CODE> can be made to pass through only those lines which exactly match the regular expression (as if the option <i>-x</i> had been  passed to the command-line utility) or only those lines that <i>do not</i> contain a match (as if the option <i>-v</i> had been  passed to the command-line utility).
    3434</P>
    3535<P>
    3636    A running count of the lines in the filtered character sequence is available via the member function <code><a href="#count">count</a></code>.

  • libs/iostreams/doc/tutorial/writing_devices.html

     
    4141
    4242<P>Here <CODE>io::stream_buffer&lt;my_device&gt;</CODE> is a derived class of <CODE>std::basic_streambuf</CODE>, and <CODE>io::stream&lt;my_device&gt;</CODE> is a derived class of <CODE>std::basic_istream</CODE>, <CODE>std::basic_ostream</CODE> or <CODE>std::basic_iostream</CODE> depending on the <A HREF="../guide/modes.html">mode</A> of my_device, <I>i.e.</I>, depending on which of the fundamental i/o operations <A HREF="../functions/read.html"><CODE>read</CODE></A>, <A HREF="../functions/write.html"><CODE>write</CODE></A> and <A HREF="../functions/seek.html"><CODE>seek</CODE></A> it supports.
    4343
    44 <P>The template <CODE>io::stream</CODE> is provided as a convenience. It's always possibly to avoid <CODE>io::stream</CODE> and simply use <CODE>io::stream_buffer</CODE> together with one of the standard library stream templates. <I>E.g.</I>,
     44<P>The template <CODE>io::stream</CODE> is provided as a convenience. It's always possible to avoid <CODE>io::stream</CODE> and simply use <CODE>io::stream_buffer</CODE> together with one of the standard library stream templates. <I>E.g.</I>,
    4545
    4646<PRE CLASS="broken_ie"><SPAN CLASS='preprocessor'>#include</SPAN> <SPAN CLASS='literal'>&lt;ostream&gt;</SPAN>
    4747<SPAN CLASS='preprocessor'>#include</SPAN> <A CLASS="HEADER" HREF="../../../../boost/iostreams/device/file.hpp"><SPAN CLASS='literal'>&lt;boost/iostreams/device/file.hpp&gt;</SPAN></A>

  • libs/iostreams/doc/tutorial/dictionary_filters.html

     
    2727<H2>2.2.6. Dictionary Filters</H2>
    2828
    2929<P>
    30     A <SPAN CLASS='term'>dictionary filter</SPAN> is a Filter which peforms text substitution in the following manner. It maintains a collection of pairs of strings whose first components are words and whose second components represent replacement text &#8212; I'll call such a collection a <SPAN CLASS='term'>dictionary</SPAN>, and refer to the pairs it contains as <SPAN CLASS='term'>definitions</SPAN>.  When a dictionary filter encounters a word which appears as the first component of a definition, it forwards the replacement text instead of the original word. Other words, whitespace and punctuation are forwarded unchanged.
     30    A <SPAN CLASS='term'>dictionary filter</SPAN> is a Filter which performs text substitution in the following manner. It maintains a collection of pairs of strings whose first components are words and whose second components represent replacement text &#8212; I'll call such a collection a <SPAN CLASS='term'>dictionary</SPAN>, and refer to the pairs it contains as <SPAN CLASS='term'>definitions</SPAN>.  When a dictionary filter encounters a word which appears as the first component of a definition, it forwards the replacement text instead of the original word. Other words, whitespace and punctuation are forwarded unchanged.
    3131</P>
    3232
    3333<P>
    34     The basic algorithm is as follows.: You examine characters one at a time, appending them to a string which I'll call the <SPAN CLASS='term'>current word</SPAN>. When you encounter a non-alphabetic character, you consult the dictionary to determine whether the current word appears as the first component of a definition. If it does, you forward the replacement text followed by the non-alphabetic character. Otherwise, you forward the current word followed by the non-alphabetic character. When the end-of-stream is reached, you consult the dictionary again and forward either the curent word or its replacement, as appropriate.
     34    The basic algorithm is as follows: You examine characters one at a time, appending them to a string which I'll call the <SPAN CLASS='term'>current word</SPAN>. When you encounter a non-alphabetic character, you consult the dictionary to determine whether the current word appears as the first component of a definition. If it does, you forward the replacement text followed by the non-alphabetic character. Otherwise, you forward the current word followed by the non-alphabetic character. When the end-of-stream is reached, you consult the dictionary again and forward either the curent word or its replacement, as appropriate.
    3535</P>
    3636
    3737<P>
    … …  
    5959} } } <SPAN CLASS="comment">// End namespace boost::iostreams:example</SPAN></PRE>
    6060
    6161<P>
    62     The member function <CODE>add</CODE> converts <CODE>key</CODE> to lower case then added the pair <CODE>key</CODE>, <CODE>value</CODE> to the dictionary. The member function <CODE>replace</CODE> searches for a definition whose first component is equal to the result of converting <CODE>key</CODE> to lower case. If it finds such a definition, it assigns the replacement text to <CODE>key</CODE>, adjusting the case of the first character to match the case of the first character of <CODE>key</CODE>. Otherwise, it does nothing.
     62    The member function <CODE>add</CODE> converts <CODE>key</CODE> to lower case and adds the pair <CODE>key</CODE>, <CODE>value</CODE> to the dictionary. The member function <CODE>replace</CODE> searches for a definition whose first component is equal to the result of converting <CODE>key</CODE> to lower case. If it finds such a definition, it assigns the replacement text to <CODE>key</CODE>, adjusting the case of the first character to match the case of the first character of <CODE>key</CODE>. Otherwise, it does nothing.
    6363</P>
    6464
    6565<A NAME="dictionary_stdio_filter"></A>

  • libs/iostreams/doc/tutorial/shell_comments_filters.html

     
    217217    <SPAN CLASS="keyword">template</SPAN>&lt;<SPAN CLASS="keyword">typename</SPAN> Sink&gt;
    218218    <SPAN CLASS='keyword'>bool</SPAN> put(Sink& dest, <SPAN CLASS='keyword'>int</SPAN> c)
    219219    {
    220         <SPAN CLASS='comment'>// Attempt to consume the given character of unfilitered</SPAN>
     220        <SPAN CLASS='comment'>// Attempt to consume the given character of unfiltered</SPAN>
    221221        <SPAN CLASS='comment'>// data, writing filtered data to dest as appropriate. </SPAN>
    222222        <SPAN CLASS='comment'>// Return true if the character was successfully consumed.</SPAN>
    223223    }

  • libs/iostreams/doc/tutorial/filter_usage.html

     
    5252</P>
    5353   
    5454<P>
    55     Now suppose you want to recoved the original data. If you have appropriate InputFilters <CODE>decompressor</CODE> and <CODE>base64_decoder</CODE>, you can accomplish this as follows as follows:<A CLASS='footnote_ref' NAME='note_2_ref' HREF="#note_2"><SUP>[2]</SUP></A>
     55    Now suppose you want to recover the original data. If you have appropriate InputFilters <CODE>decompressor</CODE> and <CODE>base64_decoder</CODE>, you can accomplish this as follows:<A CLASS='footnote_ref' NAME='note_2_ref' HREF="#note_2"><SUP>[2]</SUP></A>
    5656</P>
    5757
    5858<PRE CLASS="broken_ie">

  • libs/iostreams/doc/tutorial/writing_filters.html

     
    2727<A NAME="filter_overview"></A>
    2828<H2>2.2.1. Overview: InputFilters, OutputFilters and Filter Helpers</H2>
    2929
    30 <P>Filters are used to modified character sequences. For example, you might use a filter to replace all instances of one word with another, to convert all alphabetic characters to lower case or to encrypt a document. Sometimes the filter is a mere observer; in this case the filtered character sequence if the same as the unfiltered sequence. For example, you might use a filter to count the number of occurences of a given word.</P>
     30<P>Filters are used to modify character sequences. For example, you might use a filter to replace all instances of one word with another, to convert all alphabetic characters to lower case or to encrypt a document. Sometimes the filter is a mere observer; in this case the filtered character sequence if the same as the unfiltered sequence. For example, you might use a filter to count the number of occurences of a given word.</P>
    3131
    3232
    3333<A NAME="input_filters_and_output_filters"></A>
    3434<H4>InputFilters and OutputFilters</H4>
    3535
    36 <P>The Iostreams library supports two basic categories of Filters <A HREF="../concepts/input_filter.html">InputFilters</A> and <A HREF="../concepts/output_filter.html">OutputFilters</A>. InputFilters represent a &#8220;pull&#8221; model of filtering: a source of unfilitered data is provided &#8212; represented as a <A HREF="../concepts/source.html">Source</A> &#8212; and the Filter is expected to generate a certain number characters of the filtered sequence. The filtered sequence is generated incrementally, meaning that to filter a given character sequence the Filter typically must be invoked several times. <A HREF="../concepts/output_filter.html">OutputFilters</A> represent a &#8220;push&#8221; model of filtering: a sequence of unfiltered characters and a <A HREF="../concepts/sink.html">Sink</A> are provided, and the Filter is expected to filter the characters and write them to the Sink. Like InputFilters, OutputFilters also process data incrementally.</P>
     36<P>The Iostreams library supports two basic categories of Filters, <A HREF="../concepts/input_filter.html">InputFilters</A> and <A HREF="../concepts/output_filter.html">OutputFilters</A>. InputFilters represent a &#8220;pull&#8221; model of filtering: a source of unfiltered data is provided &#8212; represented as a <A HREF="../concepts/source.html">Source</A> &#8212; and the Filter is expected to generate a certain number of characters of the filtered sequence. The filtered sequence is generated incrementally, meaning that to filter a given character sequence the Filter typically must be invoked several times. <A HREF="../concepts/output_filter.html">OutputFilters</A> represent a &#8220;push&#8221; model of filtering: a sequence of unfiltered characters and a <A HREF="../concepts/sink.html">Sink</A> are provided, and the Filter is expected to filter the characters and write them to the Sink. Like InputFilters, OutputFilters also process data incrementally.</P>
    3737
    38 <P>The simplest InputFilters and OutputFilters process characters one at a time. This type of Filter is easy to write, but is less efficient than Filters that process several characters at a time. Filters which process several characters at a time are called <A HREF="../concepts/multi_character.html">Multi-Character</A> fiters.</P>
     38<P>The simplest InputFilters and OutputFilters process characters one at a time. This type of Filter is easy to write, but is less efficient than Filters that process several characters at a time. Filters which process several characters at a time are called <A HREF="../concepts/multi_character.html">Multi-Character</A> filters.</P>
    3939
    4040<A NAME="filter_helpers"></A>
    4141<H4>Filter Helpers</H4>
    … …  
    4343<P>The Iostreams library provides several utilities to make Filter writing easier:</P>
    4444<UL>
    4545    <LI>
    46         <A HREF="../classes/aggregate.html"><CODE>aggregate_filter</CODE></A> allows a programmer to define a Filter by reading unfilitered data from one <CODE>std::vector</CODE> and writing filtered data to another <CODE>std::vector</CODE>.
     46        <A HREF="../classes/aggregate.html"><CODE>aggregate_filter</CODE></A> allows a programmer to define a Filter by reading unfiltered data from one <CODE>std::vector</CODE> and writing filtered data to another <CODE>std::vector</CODE>.
    4747    </LI>
    4848    <LI>
    49         <A HREF="../classes/stdio_filter.html"><CODE>stdio_filter</CODE></A> allows a programmer to define a Filter by reading unfilitered data from standard input and writing filtered data to standard output.
     49        <A HREF="../classes/stdio_filter.html"><CODE>stdio_filter</CODE></A> allows a programmer to define a Filter by reading unfiltered data from standard input and writing filtered data to standard output.
    5050    </LI>
    5151    <LI>
    52         <A HREF="../classes/symmetric_filter.html"><CODE>symmetric_filter</CODE></A> allows a programmer to define a Filter by reading unfilitered data from one array and writing filtered data to another array.
     52        <A HREF="../classes/symmetric_filter.html"><CODE>symmetric_filter</CODE></A> allows a programmer to define a Filter by reading unfiltered data from one array and writing filtered data to another array.
    5353    </LI>
    5454    <LI>
    5555        <A HREF="finite_state_filters.html"><CODE>finite_state_filter</CODE></A> allows a programmer to define a Filter as a finite state machine. This component is included with the example filters; it is not currently an official part of the library.
    … …  
    6060<H4>Selecting a Filter Concept</H4>
    6161
    6262<P>
    63     Suppose you need to write a Filter to perform a given filtering task. How do you decide whether to write an <A HREF="../concepts/input_filter.html">InputFilters</A> or <A HREF="../concepts/output_filter.html">OutputFilters</A>, or to use one of the Filter helpers? The first two Filter helpers mentioned above, <A HREF="../classes/aggregate.html"><CODE>aggregate_filter</CODE></A> and <A HREF="../classes/stdio_filter.html"><CODE>stdio_filter</CODE></A>, have high-memory usage and only work with character sequences that have a well-defined end. They allow filtering algorithms to be expressed in a very straightforward way, however, and so provide a good introduction to filtering. The third Filter helper, <A HREF="../classes/symmetric_filter.html"><CODE>symmetric_filter</CODE></A>, is useful for defining filter based on C-language API such as zlib, libbz2 or OpenSSL. If none of the Filter helpers are appropriate, you should generally write an InputFilter if you plan to use the filter for reading and an OutputFilter if you plan to use it for writing. In some cases, however, it is much easier to express an algorithm as an InputFilter than as an OutputFilter, or <I>vice versa</I>. In such cases, you can write the filter whichever way is easier, and use the class template <A HREF="../functions/invert.html#inverse"><CODE>inverse</CODE></A> or the function template <A HREF="../functions/invert.html"><CODE>invert</CODE></A> to turn an InputFilter into an OutputFilter or <I>vice versa</I>.
     63    Suppose you need to write a Filter to perform a given filtering task. How do you decide whether to write an <A HREF="../concepts/input_filter.html">InputFilter</A> or <A HREF="../concepts/output_filter.html">OutputFilter</A>, or to use one of the Filter helpers? The first two Filter helpers mentioned above, <A HREF="../classes/aggregate.html"><CODE>aggregate_filter</CODE></A> and <A HREF="../classes/stdio_filter.html"><CODE>stdio_filter</CODE></A>, have high-memory usage and only work with character sequences that have a well-defined end. They allow filtering algorithms to be expressed in a very straightforward way, however, and so provide a good introduction to filtering. The third Filter helper, <A HREF="../classes/symmetric_filter.html"><CODE>symmetric_filter</CODE></A>, is useful for defining filter based on C-language API such as zlib, libbz2 or OpenSSL. If none of the Filter helpers are appropriate, you should generally write an InputFilter if you plan to use the filter for reading and an OutputFilter if you plan to use it for writing. In some cases, however, it is much easier to express an algorithm as an InputFilter than as an OutputFilter, or <I>vice versa</I>. In such cases, you can write the filter whichever way is easier, and use the class template <A HREF="../functions/invert.html#inverse"><CODE>inverse</CODE></A> or the function template <A HREF="../functions/invert.html"><CODE>invert</CODE></A> to turn an InputFilter into an OutputFilter or <I>vice versa</I>.
    6464</P>
    6565
    6666<P>