Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r76942 - in branches/release: . libs libs/iostreams libs/iostreams/doc/classes libs/iostreams/doc/tutorial
From: dnljms_at_[hidden]
Date: 2012-02-07 15:45:42

Author: danieljames
Date: 2012-02-07 15:45:41 EST (Tue, 07 Feb 2012)
New Revision: 76942
URL: http://svn.boost.org/trac/boost/changeset/76942

Log:
Iostreams: Merge doc fixes to release. Refs #6530.
Properties modified:
   branches/release/ (props changed)
   branches/release/libs/ (props changed)
   branches/release/libs/iostreams/ (props changed)
Text files modified:
   branches/release/libs/iostreams/doc/classes/grep_filter.html | 2 +-
   branches/release/libs/iostreams/doc/tutorial/dictionary_filters.html | 6 +++---
   branches/release/libs/iostreams/doc/tutorial/filter_usage.html | 2 +-
   branches/release/libs/iostreams/doc/tutorial/shell_comments_filters.html | 2 +-
   branches/release/libs/iostreams/doc/tutorial/writing_devices.html | 2 +-
   branches/release/libs/iostreams/doc/tutorial/writing_filters.html | 14 +++++++-------
   6 files changed, 14 insertions(+), 14 deletions(-)

Modified: branches/release/libs/iostreams/doc/classes/grep_filter.html
==============================================================================
--- branches/release/libs/iostreams/doc/classes/grep_filter.html (original)
+++ branches/release/libs/iostreams/doc/classes/grep_filter.html 2012-02-07 15:45:41 EST (Tue, 07 Feb 2012)
@@ -30,7 +30,7 @@
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 grep (<A CLASS="bib_ref" HREF="../bibliography.html#grep">[IEEE]</A>). The filter uses regular expressions from the Boost Regular Expression Library (<A CLASS="bib_ref" HREF="../bibliography.html#maddock">[Maddock]</A>).


- 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 -x had been passed to the command-line utility) or only those lines that do not contain a match (as if the option -v had been passed to the command-line utility).
+ 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 -x had been passed to the command-line utility) or only those lines that do not contain a match (as if the option -v had been passed to the command-line utility).


A running count of the lines in the filtered character sequence is available via the member function <code>count</code>.

Modified: branches/release/libs/iostreams/doc/tutorial/dictionary_filters.html
==============================================================================
--- branches/release/libs/iostreams/doc/tutorial/dictionary_filters.html (original)
+++ branches/release/libs/iostreams/doc/tutorial/dictionary_filters.html 2012-02-07 15:45:41 EST (Tue, 07 Feb 2012)
@@ -27,11 +27,11 @@
<H2>2.2.6. Dictionary Filters</H2>


- A dictionary filter 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 — I'll call such a collection a dictionary, and refer to the pairs it contains as definitions. 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.
+ A dictionary filter 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 — I'll call such a collection a dictionary, and refer to the pairs it contains as definitions. 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.



- The basic algorithm is as follows.: You examine characters one at a time, appending them to a string which I'll call the current word. 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.
+ The basic algorithm is as follows: You examine characters one at a time, appending them to a string which I'll call the current word. 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.



@@ -59,7 +59,7 @@
} } } // End namespace boost::iostreams:example</PRE>


- 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.
+ 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.


<A NAME="dictionary_stdio_filter"></A>

Modified: branches/release/libs/iostreams/doc/tutorial/filter_usage.html
==============================================================================
--- branches/release/libs/iostreams/doc/tutorial/filter_usage.html (original)
+++ branches/release/libs/iostreams/doc/tutorial/filter_usage.html 2012-02-07 15:45:41 EST (Tue, 07 Feb 2012)
@@ -52,7 +52,7 @@



- 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">[2]</A>
+ 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">[2]</A>


<PRE CLASS="broken_ie">

Modified: branches/release/libs/iostreams/doc/tutorial/shell_comments_filters.html
==============================================================================
--- branches/release/libs/iostreams/doc/tutorial/shell_comments_filters.html (original)
+++ branches/release/libs/iostreams/doc/tutorial/shell_comments_filters.html 2012-02-07 15:45:41 EST (Tue, 07 Feb 2012)
@@ -217,7 +217,7 @@
 template<typename Sink>
 bool put(Sink& dest, int c)
 {
- // Attempt to consume the given character of unfilitered
+ // Attempt to consume the given character of unfiltered
 // data, writing filtered data to dest as appropriate. 
 // Return true if the character was successfully consumed.
 }

Modified: branches/release/libs/iostreams/doc/tutorial/writing_devices.html
==============================================================================
--- branches/release/libs/iostreams/doc/tutorial/writing_devices.html (original)
+++ branches/release/libs/iostreams/doc/tutorial/writing_devices.html 2012-02-07 15:45:41 EST (Tue, 07 Feb 2012)
@@ -41,7 +41,7 @@

Here <CODE>io::stream_buffer<my_device></CODE> is a derived class of <CODE>std::basic_streambuf</CODE>, and <CODE>io::stream<my_device></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 mode of my_device, i.e., depending on which of the fundamental i/o operations read, write and seek it supports.

-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. E.g.,
+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. E.g.,

<PRE CLASS="broken_ie">#include <ostream>
#include <A CLASS="HEADER" HREF="../../../../boost/iostreams/device/file.hpp"><boost/iostreams/device/file.hpp></A>

Modified: branches/release/libs/iostreams/doc/tutorial/writing_filters.html
==============================================================================
--- branches/release/libs/iostreams/doc/tutorial/writing_filters.html (original)
+++ branches/release/libs/iostreams/doc/tutorial/writing_filters.html 2012-02-07 15:45:41 EST (Tue, 07 Feb 2012)
@@ -27,15 +27,15 @@
<A NAME="filter_overview"></A>
<H2>2.2.1. Overview: InputFilters, OutputFilters and Filter Helpers</H2>

-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.
+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.

<A NAME="input_filters_and_output_filters"></A>
<H4>InputFilters and OutputFilters</H4>

-The Iostreams library supports two basic categories of Filters InputFilters and OutputFilters. InputFilters represent a “pull” model of filtering: a source of unfilitered data is provided — represented as a Source — 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. OutputFilters represent a “push” model of filtering: a sequence of unfiltered characters and a Sink are provided, and the Filter is expected to filter the characters and write them to the Sink. Like InputFilters, OutputFilters also process data incrementally.
+The Iostreams library supports two basic categories of Filters, InputFilters and OutputFilters. InputFilters represent a “pull” model of filtering: a source of unfiltered data is provided — represented as a Source — 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. OutputFilters represent a “push” model of filtering: a sequence of unfiltered characters and a Sink are provided, and the Filter is expected to filter the characters and write them to the Sink. Like InputFilters, OutputFilters also process data incrementally.

-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 Multi-Character fiters.
+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 Multi-Character filters.

<A NAME="filter_helpers"></A>
<H4>Filter Helpers</H4>
@@ -43,13 +43,13 @@
The Iostreams library provides several utilities to make Filter writing easier:
<UL>
 <LI>
- aggregate_filter 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>.
+ aggregate_filter 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>.
 </LI>
 <LI>
- stdio_filter allows a programmer to define a Filter by reading unfilitered data from standard input and writing filtered data to standard output.
+ stdio_filter allows a programmer to define a Filter by reading unfiltered data from standard input and writing filtered data to standard output.
 </LI>
 <LI>
- symmetric_filter allows a programmer to define a Filter by reading unfilitered data from one array and writing filtered data to another array.
+ symmetric_filter allows a programmer to define a Filter by reading unfiltered data from one array and writing filtered data to another array.
 </LI>
 <LI>
 <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.
@@ -60,7 +60,7 @@
<H4>Selecting a Filter Concept</H4>


- Suppose you need to write a Filter to perform a given filtering task. How do you decide whether to write an InputFilters or OutputFilters, or to use one of the Filter helpers? The first two Filter helpers mentioned above, aggregate_filter and stdio_filter, 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, symmetric_filter, 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 Output
Filter 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 vice versa. In such cases, you can write the filter whichever way is easier, and use the class template inverse or the function template invert to turn an InputFilter into an OutputFilter or vice versa.
+ Suppose you need to write a Filter to perform a given filtering task. How do you decide whether to write an InputFilter or OutputFilter, or to use one of the Filter helpers? The first two Filter helpers mentioned above, aggregate_filter and stdio_filter, 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, symmetric_filter, 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 OutputFi
lter 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 vice versa. In such cases, you can write the filter whichever way is easier, and use the class template inverse or the function template invert to turn an InputFilter into an OutputFilter or vice versa.

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk