Read more on MyCentralJersey.com

Read more on Business Wire via Yahoo! Finance

Read more on Northville Record

Read more on Roxbury Register

Read more on Downtown Gazette

Read more on The Observer

Read more on Onalaska Holmen Courier-Life

 The Online Vegas software offers realistic 3D graphics. After the software has been installed, a tutorial will help the player understand the software. The downloadable program is also free from viruses, spyware or other malware.

 REGISTRATION

A player has the option to play for free or for real money. With Free Play, a player can practice playing the casino games for as long as they want, free of charge. To play for real money, a player has to register with the casino. A user name and password will be provided (password can be changed by player) to log-on to the software. Upon registration, players are given the option to become a part of the mailing list of Online Vegas. By becoming part of the mailing list, the player may be invited by Online Vegas to participate in various promotional offers, such as deposit bonuses and giveaways.

 ONLINE CASINO GAMES

More than 100 casino games are offered. Online Vegas offers card games, including Blackjack, Tri Card Poker, Caribbean Stud Poker, 10 High Hold ‘Em, and more than 10 varieties of Video Poker; Table Games, such as European Roulette, Baccarat and Craps; and Slot Machines, including 3-reel slots, bonus slots and video slots. Online Vegas also offers several online casino games with Progressive Jackpots. These include Progressive Blackjack, Island Stud Poker, and several kinds of Progressive Slots. By playing a progressive online casino game, a player is given a chance to win all or part of the Jackpot!

TOURNAMENTS

Online Vegas Online Casino has monthly Guaranteed Prize Pools over $200,000 . There are Tournaments ranging from $100 up to $25,000 Guaranteed. Entry fees range as low as $0 and $1.99 up to $25, so no matter what your budget is, there is a Tournament for everybody. Not just Slots, but every Monday through Thursday look for specialty game Tournaments featuring Blackjack, Roulette, Casino Hold ‘Em and Video Poker.

In addition to the daily Slot Tournaments, Online Vegas sends invitations and free entries to special Tournaments. With Guaranteed Prize Pools as high as $75K and more on the way, Online Vegas Tournaments are the easiest and most fun way to get in on the action!

 There’s always a Tourney starting and you can enter as many Tournaments as you want so don’t forget to check the Tournament lobby often.

 CASINO BONUS AND PROMOTIONS

Online Vegas Online Casino has created the most unique and generous Welcome Bonus, an amazing first 10 Deposit Bonuses totaling over $5000 Free that is taking the industry by storm! OnlineVegas.com doesn’t stop there – they have a 1st class rewards program and the comp points collected can be used for wagering on any game without restrictions. Online Vegas offers bonuses and comps weekly. These bonuses mostly depend on the frequency an individual plays.

 CONCLUSION

Online Vegas Online Casino is a terrific online casino with great 24/7 live Support, quick and easy payouts, high payout percentages, frequent and generous tournaments, super cool graphics, and a massive selection of the most exciting games. We highly recommend them as one of our top 10 online casino pick.

I would like to thank the people who developed the following projects – they made the implementation of this project easier:

Boost: Spirit Parser Framework Program options Pool library Testing Framework Other Utils: Bind, Function, Scope Exit, String Algorithms Library

I want to say a personal thank you to Silviu Simen for his article “INI file reader using the Spirit library”.

Background and history of this task

There was a project in which I took part and we needed to test the working of a parser for Windows hive Registry files. These files are stored in binary representation and the structure of such a file is not documented by Microsoft. But, by means of research, my colleagues managed to clear out this structure, and after that, the question of verifying the parser work appeared.

To perform testing, I decided to use the functionality of exporting of Registry in two formats: hive and reg. Thus, I could obtain two different files for the same Registry key and after that check the working of the Windows hive Registry file parser.

The structure of the Registry file – I’ll give an example below – is very similar to the structure of the ini file, so you can use standard Windows functions for reading values in this file. But the problem is that, functions work very slow for big files, and that is why this parser was developed – a parser for reg files where I use the Boost Spirit Parser Framework. The reasons why standard Windows functions are slow will be considered below in this article.

What is a reg file?

Let’s consider the general view of a reg file structure first, and some special complicated cases will be considered as necessary.

I’ve taken the following material from here http://en.wikipedia.org/wiki/Windows_Registry.

.REG files (also known as Registration entries) are text-based human-readable files for storing portions of the Registry. On Windows 2000 and later NT-based Operating Systems, they contain the string Windows Registry Editor Version 5.00 at the beginning and are Unicode-based. On Windows 9x and NT 4.0 systems, they contain the string REGEDIT4 and are ANSI-based. Windows 9x format .REG files are compatible with Windows 2000 and later NT-based systems. The Registry Editor on Windows on these systems also supports exporting .REG files in Windows 9x/NT format. Data is stored in .REG files in the following syntax:

[<Hive Name>\<Key Name>\<Subkey Name>]
“Value Name”=<Value type>:<Value data>

Example 1 (different types):

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft]
“Value A”=”<String value data>”
“Value B”=hex:<Binary data>
“Value C”=dword:<DWORD value integer>
“Value D”=hex(7):<Multi-string value data>

“Value E”=hex(2):<Expandable string value data>

Example 2 (real):

[HKEY_CURRENT_USER\Key]
“Value string”=”B”
“Value dword”=dword:00000001
“Value hard”=hex(1000800c):53,00,65,00,72,00,76,00,69,00,63,00,65,00,53,00,\
74,00,61,00,72,00,74,00,54,00,79,00,70,00,65,00,00,00,4d,00,61,00,78,00,44

Making a little digression, I want to stress that the number in the line ” hex(1000800c) ” is the type identifier and it can be anything. It’s often used as the data in the security branch [HKEY_LOCAL_MACHINE\SAM].

And now, let’s try to extend the information about the possible contents of the reg file. Here, I represent some facts obtained during our research process:

1) Key Name may consist of alphabetical symbols and ” , \ , [ , ].
2) Number of values of one key can be from 0 to infinite
3) Value Name can be:
– symbol ‘@’ – it means default
– “text” – any symbols can be in this “text”
even these ones: \n , ” , \ , [ , ]
but it always ends with “\n symbols in sequence
4) Value data can be:
– “text” – any symbols can be in this “text”
but it always ends with ” and \n in sequence
– binary:
– dword:XX
– hex:XX
– hex(N):XX
Comments:
XX can be the pairs of number symbols separated by comas and
it can end with ‘\’ symbol that means that
data continue in the next line
Example:
dword:72,…,00,\
00,..,20 Two approaches and their comparison

As it was mentioned, the structures of reg files and ini files are quite the same, so I started to search for methods for working with ini files. I found the standard Windows functions.

Using the Windows API functions

Windows gives a lot of functions to work with INI files; we are interested in two of them for our task:

GetPrivateProfileSectionNames<link>: Retrieves the names of all the sections in an initialization file. GetPrivateProfileSection<link>: Retrieves all the keys and values for the specified section of an initialization file.

So, we should call GetPrivateProfileSectionNames one time to obtain the list of keys and then call GetPrivateProfileSection to obtain the values inside the keys.

The problem is that if the file is quite big, i.e., there are a lot of keys in it, then we should call GetPrivateProfileSection several times to read from the file. Here is some row test data: file size: 30 MB, file includes about 30,000 keys, the parsing of this file takes about 20 minutes. And, I should say that reg files are often bigger than 100 MB.

So, the problem:

Unjustified number of readings from the file.

Solution:

It’s necessary to load the file to the memory at one time or in some parts and then parse its content using your own tools.

Using a custom parser

When parsing a reg file content using your our own tools, it’s good idea to use already developed work. Thus, I came across the article about the ini file reader using the Spirit library. Using the example of the ini file parser, I developed my reg file parser.

Why boost::spirit ?

The Spirit Parser Framework is an object oriented recursive descent parser generator framework implemented using template metaprogramming techniques. Expression templates allow users to approximate the syntax of Extended Backus Naur Form (EBNF) completely in C++.

I was also attracted by these factors:

There are no intermediate conversions to some code needed, and also no external applications except for the compiler. You need to include only two header files and no libraries to use the Spirit Parser Framework.

Useful links:

Boost Spirit Parser Framework Wikipedia about Spirit Parser Framework Fleeting glance on boost::spirit

The main idea of using boost::spirit is in using the rules. Usually, several basic rules are defined, and then other rules are defined by means of overridden operators as a combinations of basic rules. The following example shows the creation of rules using “AND” and “NOT” operators:

RuleType simpleRule = ~ch_t(‘A’) &amp; ~ch_t(‘B’);

This rule works for any symbol except for ‘A’ and ‘B’.

Below in this article, each rule will be described in detail, but now, I want to give some quick information about possible operators – to let you imagine what the possible operations with the rules are.

Set operators:
a | b Union Match a or b. Also referred to as alternative
a &amp; b Intersection Match a and b
a – b Difference Match a but not b. If both match and b’s matched text
is shorter than a’s matched text, a successful
match is made
a ^ b XOR Match a or b, but not both

Sequencing Operators:
a >> b Sequence Match a and b in sequence
a &amp;&amp; b Sequential-and Sequential-and. Same as above,
match a and b in sequence
a || b Sequential-or Match a or b in sequence

Optional and Loops:
*a – Match a zero (0) or more times
+a – Match a one (1) or more times
!a – Match a zero (0) or one (1) time
a % b – Match a list of one or more repetitions
of a separated by occurrences of b.
This is the same as a >> *(b >> a).
Note that a must not also match b

Single character parsers:
anychar_p Matches any single character
(including the null terminator: ‘\0′)
alnum_p Matches alpha-numeric characters
alpha_p Matches alphabetic characters
blank_p Matches spaces or tabs
cntrl_p Matches control characters
digit_p Matches numeric digits
graph_p Matches non-space printing characters
lower_p Matches lower case letters
print_p Matches printable characters
punct_p Matches punctuation symbols
space_p Matches spaces, tabs, returns, and newlines
upper_p Matches upper case letters
xdigit_p Matches hexadecimal digits

Other comments:
negation ~
Example: ~ch_t(‘x’) – matches any character except ‘x’ Introduction to the parser development

Further in this article, I’ll try to keep the high level of clearness so I’m sorry in advance if you think that my descriptions are too detailed.

The description starts from the heart of the parser – its algorithm. The algorithm is described in parts, and then the wrapper for this algorithm is described, and then other auxiliary classes. At the end, we’ll consider a concrete usage example and test.

Algorithm description

The algorithm is represented by a function and interface:

template<class charT>

struct IResultProcessor
{
virtual ~IResultProcessor(){}

virtual void OnKeyFound(const charT* begin, const charT* end)=0;
virtual void OnValueNameFound(const charT* begin, const charT* end)=0;
virtual void OnValueDataFound(const charT* begin, const charT* end)=0;
};

template<class charT>
inline bool ParseRegFileImpl(const charT* buffer,
IResultProcessor<charT>* resultProc);

It follows from the function names that the algorithm will call the OnKeyFound function for each key name found, OnValueNameFound for each value name found, and OnValueDataFound for the value content.

An observant reader can ask a question: “Why is the processing of value separated into two functions, OnValueNameFound and OnValueDataFound, after all it it one single entity?” The answer is simple: “The implementation of this processing inside the algorithm would be hard and so the algorithm entrusts calling inside it the processing of these two parts”.

Preparatory work

At this stage, we will prepare the environment for the convenient work. In particular, we should use namespaces, shorten the line for rule creation, and define frequently used rules.

using namespace boost::spirit;
typedef rule<scanner<const charT*> > RuleType;
typedef chlit<charT> ch_t; // Single character
typedef chset<charT> chs_t; // Character set
typedef IResultProcessor<charT> ResProcT;

chs_t anychar_t(anychar_p); // Pattern anychar to character set
chs_t eol_CR(‘\r’); // End of line CR
chs_t eol_LF(‘\n’); // End of line LF
chs_t eol_t(eol_CR);// CR or LF end of line
eol_t |= eol_LF; Auxiliary rules // Matches spaces or tabs
RuleType blanks = * blank_p;

// Symbols ‘]’and ‘[' - separate Key Name
RuleType not_name_separator = ~ch_t(']‘) &amp; ~ch_t(‘[');

// empty data
RuleType empty_data = blanks >> (eol_t | ch_t('\0'));

// Data that we don't interested
// @ - it's default value name , " - requires additional processing
RuleType other_data = *(anychar_t &amp; not_name_separator &amp;
~ch_t('@')&amp; ~ch_t('"'));

The first rule is to omit the blanks and tabs. Asterisk means that the rule can work several times in a row or not work at all.

The second rule is to make sure that the current symbol is not the name separator.

The third rule is to omit empty data. The operator >> means that the rule at the left side of the operator and the rule at the right side should be performed in sequence, one after another.

The forth rule is assigned to free data not part of the separators. Any symbol matches this rule except for name separators, @ - the identifier of value by default, and the symbol " that signals the end of the line. This rule can work either several times or never.

Rule for the key name RuleType ident_kname_continue = ch_t(']‘) >> ~eol_t;
RuleType ident_key_name = *(anychar_t &amp; ~ch_t(‘]’)) ||
ident_kname_continue >> ident_key_name;

This rule can be illustrated on the scheme:

Rule ident_kname_continue is an auxiliary for ident_key_name. First of all, ident_key_name is the recursive rule, and after the process meets symbol ], it tries to define if it is the end of the name or the part of the name. If symbol ] is the part of the name, i.e., there is no symbol of line end after it, and then this rule starts itself again and continues parsing.

Let’s consider the following case for example:

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\_HARD_NAME[123]_ABCD]

In this example, the symbol ] is the part of the name and that’s why it’s necessary to check if there is the symbol of line end after it. You can see such names in the Registry.

Rule for the Value name // if “= symbols sequence is found – value name ends
RuleType ident_vname_continue = +ch_t(‘”‘) >> ~ch_t(‘=’);
// If ‘”‘ symbol is found – check if value name ends,
// if it doesn’t parsing continues.
RuleType ident_vname_sz_skip = ch_t(‘\\’) >> ch_t(‘”‘);
RuleType ident_vname_sz_body = *(anychar_t &amp; ~ch_t(‘”‘) ||
ident_vname_sz_skip );
RuleType ident_vname_sz =
ident_vname_sz_body >> *(ident_vname_continue >> ident_vname_sz_body);
// Rule for default value name
RuleType ident_vname_sz_impl = ch_t(‘”‘) >> ident_vname_sz >> +ch_t(‘”‘);
RuleType ident_vname_def = ch_t(‘@’);
// “text” or DEFAULT
RuleType ident_value_name = ident_vname_def | ident_vname_sz_impl;

This rule can be represented on the scheme:

Rule for the value content // if value content is binary
// Data can be any character except for ‘\\’ and ‘\n’ in sequence
RuleType vdata_bin_body =*(anychar_t &amp; ~ch_t(‘\0′) &amp;
~eol_t &amp; ~ch_t(‘\\’));
RuleType vdata_bin_continue = ch_t(‘\\’) >> eol_t;
// if ‘\\’ and ‘\n’ in sequence data continue on the next line
RuleType vdata_bin = vdata_bin_body >>
*(vdata_bin_continue >> vdata_bin_body);

// if value content is string
// String data always ends with ‘”‘ and ‘\n’ symbols in sequence
RuleType vdata_sz_continue = +ch_t(‘”‘) >> ~eol_t;
RuleType vdata_sz_body_impl = *(anychar_t &amp; ~ch_t(‘”‘));
RuleType vdata_sz_body = vdata_sz_body_impl >>
*(vdata_sz_continue >> vdata_sz_body_impl);
// String data always starts and ends with ‘”‘ symbol
RuleType ident_vdata_sz = ch_t(‘”‘) >> vdata_sz_body >> +ch_t(‘”‘);

// Check value data format
RuleType ident_vdata = ident_vdata_sz | vdata_bin;

This rule can be represented on the scheme like this:

Rule that describes the line with the key name // line with key name
RuleType l_key =
other_data>> // Can be comments or start title
ch_t(‘[') >> // start of the key name
// Call OnKeyFound function if rule succeeds
ident_key_name [bind(&amp;CRegFileParserImpl::OnKeyFound,
this, _1,_2) ] >>
blanks >> // can be blanks
ch_t(‘]’) >> // end of the key name
blanks >> // can be blanks
*eol_t; // one or more end of line symbols

This rule requires the execution of several rules in sequence. The new idea here is to use the operator []. In this case, it means that when the rule is activated, the functor transferred as the parameter should be called. And, the range where this rule worked will be transferred to this functor via two parameters.

Rule that describes the line with the Value // lines with value name and data
RuleType l_values =
other_data>> // Can be comments or start title
// Call OnValueNameFound function if rule succeed
ident_value_name
[bind(&amp;CRegFileParserImpl::OnValueNameFound, this, _1,_2) ] >>
blanks >> // can be blanks
ch_t(‘=’) >> // always separates value name and value data
blanks >> // can be blanks
// Call OnValueDataFound function if rule succeeded
value_data
[bind(&amp;CRegFileParserImpl::OnValueDataFound, this, _1,_2) ] >>

blanks >> // can be blanks
*eol_t; // one or more end of line symbols

This rule is much like the previous one. At this moment, we can return to the question stated during the interface discussion: “Why is the processing of Value separated into two functions OnValueNameFound and OnValueDataFound, after all it is one single entity?”. Now, we can give a more detailed answer. As it’s seen from the code above, it’s hard to support an interface corresponding to the reg file structure by means of boost::spirit – a function call with 4 parameters for the whole value.

Gathering everything together // Any line can satisfy one of the three rules
RuleType lines = l_key | l_values | empty_data;

// Start lexeme_d pars that compares also additional symbols
// if does just *lines, symbols ‘ ‘,’\t’,'\n’ are not compared
RuleType reg_file = lexeme_d [*lines] ;

// Execute parse
return (parse(buffer, reg_file).full);

So, we finished the algorithm of reg file parsing. The rules for the key name are set, the value is aggregated, and the file parsing starts.

The whole function looks like the following:

template<class charT>
inline bool ParseRegFileImpl(const charT* buffer,
IResultProcessor<charT>* resultProc)
{
using namespace boost::spirit;
typedef rule<scanner<const charT*> > RuleType;
typedef chlit<charT> ch_t; // Single character
typedef chset<charT> chs_t; // Character set
typedef IResultProcessor<charT> ResProcT;

chs_t anychar_t(anychar_p); // Pattern to char set
chs_t eol_CR(‘\r’); // End of line CR
chs_t eol_LF(‘\n’); // End of line LF
chs_t eol_t(eol_CR);// CR or LF end of line
eol_t |= eol_LF;

/* ————————————————————– */
/* Help rules*/

// Matches spaces or tabs
RuleType blanks = * blank_p;
// Symbols ‘]’and ‘[' - separate Key Name
RuleType not_name_separator = ~ch_t(']‘) &amp; ~ch_t(‘[');
// empty data
RuleType empty_data = blanks >> (eol_t | ch_t('\0'));
// Data in what we aren't interested
// @ - it's default value name, "

// - requires additional processing
RuleType other_data = *(anychar_t &amp; not_name_separator &amp;
~ch_t('@')&amp; ~ch_t('"'));

/* -------------------------------------------------------------- */
/* Rules that describe identifier of key name */

RuleType ident_kname_continue = ch_t(']‘) >> ~eol_t;
RuleType ident_key_name = *(anychar_t &amp; ~ch_t(‘]’)) ||
ident_kname_continue >> ident_key_name;

/* ————————————————————– */
/* Rules that describe identifier of value name */

// Skip \” sequence
RuleType ident_vname_sz_skip = ch_t(‘\\’) >> ch_t(‘”‘);
RuleType ident_vname_sz_impl =
*(anychar_t &amp; ~ch_t(‘”‘) || ident_vname_sz_skip );
// Add trailing symbols to match pattern
RuleType ident_vname_sz = ch_t(‘”‘) >>
ident_vname_sz_impl >> +ch_t(‘”‘);
// Rule for default value name
RuleType ident_vname_def = ch_t(‘@’);
// “text” or DEFAULT
RuleType ident_value_name = ident_vname_def | ident_vname_sz;

/* ————————————————————– */
/* Rules that describe value content */

// if value content is binary
// Data can be any character except for ‘\\’ and ‘\n’ in sequence
RuleType vdata_bin_body =
*(anychar_t &amp; ~ch_t(‘\0′) &amp; ~eol_t &amp; ~ch_t(‘\\’));
RuleType vdata_bin_continue = ch_t(‘\\’) >> eol_t;
// if ‘\\’ and ‘\n’ in sequence then
// data continue on the next line
RuleType vdata_bin = vdata_bin_body >>
*(vdata_bin_continue >> vdata_bin_body);

// if value content is string
// String data always end with ‘”‘ and ‘\n’ symbols in sequence
RuleType vdata_sz_continue = +ch_t(‘”‘) >> ~eol_t;
RuleType vdata_sz_body_impl = *(anychar_t &amp; ~ch_t(‘”‘));
RuleType vdata_sz_body = vdata_sz_body_impl >>
*(vdata_sz_continue >> vdata_sz_body_impl);
// String data always start and end with ‘”‘ symbol
RuleType ident_vdata_sz = ch_t(‘”‘) >>
vdata_sz_body >> +ch_t(‘”‘);

// Check value content format
RuleType ident_vdata = ident_vdata_sz | vdata_bin;

/* ————————————————————– */
/* Put all rules together */

// line with key name
RuleType l_key =
other_data>> // Can be comments or start title
ch_t(‘[') >> // starts key name
// Call OnKeyFound function if rule succeed
ident_key_name [bind(&amp;ResProcT::OnKeyFound,
resultProc, _1,_2) ] >>

blanks >> // can be blanks
ch_t(‘]’) >> // ends key name
blanks >> // can be blanks
*eol_t; // one or more end of line symbols

// lines with value name and data
RuleType l_values =
other_data>> // Can be comments or start title
// Call OnValueNameFound function if rule succeed
ident_value_name [bind(&amp;ResProcT::OnValueNameFound,
resultProc, _1,_2) ] >>
blanks >> // can be blanks
ch_t(‘=’) >> // always separates value name and value data
blanks >> // can be blanks
// Call OnValueDataFound function if rule succeed
ident_vdata [bind(&amp;ResProcT::OnValueDataFound,
resultProc, _1,_2) ] >>

blanks >> // can be blanks
*eol_t; // one or more end of line symbols

// Any line can satisfy one of three rules
RuleType lines = l_key | l_values | empty_data;

// Do lexeme_d pars that compare also additional symbols
// if do just *lines, symbols ‘ ‘,’\t’,'\n’ are not compared
RuleType reg_file = lexeme_d [*lines] ;

// Execute parse
return (parse(buffer, reg_file).full);
} CRegFileParser

It’s time to consider the wrapper class for this algorithm. This class assumes the processing of the value name and the value content. In other words, this class supports the following intrface:

template<class charT>
struct IRegFileObserver
{
virtual ~IRegFileObserver(){}

virtual void OnKeyFound(const charT* begin, const charT* end)=0;
virtual void OnValueFound(const charT* nameBegin, const charT* nameEnd,
const charT* dataBegin, const charT* dataEnd)=0;
};

And the class itself:

template<class charT>
class CRegFileParser:public IResultProcessor<charT>
{
typedef std::pair<const charT*,const charT*> BuferRange;
BuferRange lastVName_;

IRegFileObserver<charT>* pObserver_;

bool bLastVNameProcessed_;
public:
CRegFileParser(IRegFileObserver<charT>* pObserver)
: pObserver_(pObserver)
, bLastVNameProcessed_(true)
{}

bool Parse(const charT* buffer)
{
return ParseRegFileImpl(buffer,this);
}

private:
void OnKeyFound(const charT* begin, const charT* end)
{
CheckVNameProcessed(true);

pObserver_->OnKeyFound(begin,end);
}
void OnValueNameFound(const charT* begin, const charT* end)
{
CheckVNameProcessed(true);

bLastVNameProcessed_ = false;
lastVName_.first = begin;
lastVName_.second = end;
}
void OnValueDataFound(const charT* begin, const charT* end)
{
CheckVNameProcessed(false);

bLastVNameProcessed_ = true;
pObserver_->OnValueFound(lastVName_.first,
lastVName_.second,begin,end);
}
void CheckVNameProcessed(bool needToBeProcessed)
{
if(bLastVNameProcessed_ != needToBeProcessed)
throw std::exception(“Value data not ” +
“found for founded value name”);
}
}; Using Pool

Before considering the observers created for testing, we should describe the usage of the boost Pool library.

What is Pool?

Pool allocation is a memory allocation scheme that is very fast, but limited in its usage.

Installation

The Boost Pool library is a header file library. That means there is no .lib, .dll, or .so to build; just add the Boost directory to your compiler’s include file path, and you should be good to go!

How do I use Pool?

To make it convenient, I created the following classes that have the functionality of the standard STL containers but use the boost Pool library:

#include <boost/pool/pool_alloc.hpp>
#include <map>
#include <vector>
#include <list>

#include <string>

template<class _Kty, class _Ty>
class QMap : public std::map< _Kty, _Ty, std::less<_Kty>,
boost::fast_pool_allocator< std::pair<_Kty,_Ty> > >

{};

template<class _Ty>
class QVect : public std::vector< _Ty, boost::pool_allocator<_Ty> >
{};

template<class _Ty>
class QList : public std::list< _Ty, boost::pool_allocator<_Ty> >

{};

template<class _Ty>
class QStringStream :
public std::basic_stringstream< _Ty,std::char_traits<_Ty>,
boost::pool_allocator<_Ty> >
{};

template<class _Ty>
class QString: public std::basic_string<_Ty,std::char_traits<_Ty>,
boost::pool_allocator<_Ty> >

{
typedef std::basic_string<_Ty,std::char_traits<_Ty>,
boost::pool_allocator<_Ty> >
BaseClass;
public:
QString(){}
// construct from [_First, _Last), const pointers
QString(const _Ty* first,const _Ty* last)
: BaseClass(first,last)
{}
};

The only disadvantage - as you could notice - is no full support for original constructors. I actually think that it's not a big problem, you can just insert the necessary constructor if it's needed.

Observers

Some observers were created for testing purposes:

CRegStatusObserver - assigned to print the status of the parsing process on the screen in percentage. CRegCountObserver - assigned to print the number of keys and the values on the screen. CRegPrintObserver - assigned to print all the keys and values on the screen. CRegFullObserver - assigned to store all the keys in std::map, where the name of the Registry key is key and the vector of all the values of this Registry key is the std::vector values. CRegObserversPool - assigned to make it possible to use several observers simultaneously.

It's important to mention that these observers print information on the screen, but they can be used to print to the file or some other stream. For example, CRegCountObserver:

template<class charT,class streamT>
class CRegCountObserver:public IRegFileObserver<charT>
{
size_t keysCount_;
size_t valuesCount_;

streamT&amp; out_;
public:
CRegCountObserver(streamT&amp; out)
: keysCount_(0)
, valuesCount_(0)
, out_(out)
{}
~CRegCountObserver()
{
out_ << "Keys count: "
<< keysCount_
<< "\t Values count: "
<< valuesCount_
<< "\n";
}
...
};

And some examples of its usage:

// 1
CRegCountObserver<char> screenObsr(std::cout);

// 2
std::stringstream strStream;
CRegPrintObserver<char,std::stringstream> stringObsr(strStream);

// 3
std::fstream fileStream;
CRegPrintObserver<char,std::fstream> fileObsr(fileStream);

The usage of other observers is the same.

Auto-tests description

All auto-test are represented in the one project, RegFileParserAutoTest.

The test is a console application developed with the Boost Testing Framework. Five complicated cases were chosen to be the test data: one for key name, two for value name, and two for value content.

There is one more case with the typical content of a reg file. So, we have six cases, and there are two versions of reg file format - ANSI and UNICODE (Regedit4 and Regedit5 correspondingly); each of our cases duplicates for two formats. As a result, we have 12 test files.

To control the results of parsing, we use a comparison of the original content and the content parsed and saved in memory using CRegPrintObserver:

template<class charT>
class TestRunner
{
protected:
typedef std::basic_string<charT> stringT;
typedef std::basic_stringstream<charT> stringstreamT;

typedef std::basic_fstream<charT> fstreamT;
public:

...

static void
RunTest(const std::wstring&amp; fileName)
{
std::vector<char> buffer;
ReadFile(fileName,&amp;buffer);

stringstreamT stream;
reg_parser::CRegPrintObserver<charT,stringstreamT>
coutObserver(stream);
reg_parser::CRegFileParser<charT> regParser(&amp;coutObserver);

// Run parsing
if( !regParser.Parse( (charT*)&amp;buffer[0] ) )
throw std::exception(“Parsing fail.”);

// Prepare data for comparison
stringT parsedStr;
AddRegHeader(&amp;parsedStr);
parsedStr += stream.str();

stringT originalStr = stringT((charT*)&amp;buffer[0]);

// Trim unneeded symbols
using namespace boost;
trim_if(originalStr,is_any_of(“\n\t\0 “));
trim_if(parsedStr,is_any_of(“\n\t\0 “));

if( parsedStr != originalStr)
{
// Save to file result of parsing
std::wstring parsedFileName = fileName + L”_parsed”;
fstreamT file(parsedFileName.c_str(),
fstreamT::out | fstreamT::trunc);
if( file.is_open() == false )
throw std::exception(“Can’t create file for ”
“result of parsing.”);

BOOST_SCOPE_EXIT( (&amp;file) )
{
file.close();
}
BOOST_SCOPE_EXIT_END

file << parsedStr;

throw std::exception(“Parsed data not ”
“equal to original data.”);
}
}

…
}; Description for manual testing

Manual tests are represented in one project, RegFileParserTestCmd. The test is a console application implemented using Boost Program Options that has these parameters:

C:\RegFileParser\bin\Debug>RegFileParserTestCmd.exe –help
Allowed options:
–help produce help message
–reg_file arg source reg file
–print Enable printing to the screen
–count Enable counting parsed keys and values
–status Enable printing status of parsing

It’s a pity that I don’t have enough time to add options to save the parsed content to a file, and using the save option like it is in autotest doesn’t seem to be aesthetic to me.

Registry export using Regedit

Conclusion

This article is a special piece of knowledge, so may be it’s not as systematic as it should be.

It was really interesting to learn boost spirit, and I managed to get the pleasure of my work with it and some aesthetic satisfaction – not just get my task done. After all, this discovered to be very effective; for example, the calculation of number of keys and values in a Registry file of 250 MB now takes a couple of seconds only.

So learn something new, and good luck to you in your development!

Download sources from Apriorit site.

Establish a definition of Distance Education, after analyzing how define some educational institutions. Examine the origin of distance education and compare the term with similar expressions.
Before attempting to explain the complex and controversial issue is useful to define the terms in question. In this case, before defining distance education, we should first define Education.

Education
A dictionary definition of education is:
“The act or process of educating or being educated.” Or more simple “The act of imparting knowledge.

It is important to note that the words in the definitions above are action or process. But Education is associated with a place such as school, university, schools and not the process.

Learning
With regard to the concept of learning, there are various conceptions and interpretations. Examine some of them, as well as elements of them.
We call learning modality or man’s ability to learn, which occurred as a result of motor activities that cannot be attributed simply to the process of growth and development as human beings.
We can say that learning is a process of acquiring knowledge and skills. For this process can be defined as learning, rather than passing a simple restraint must involve retention of knowledge or skill in question to allow for their demonstration at a future time. Learning can be defined in a more formal “as a relatively permanent change in behavior or potential behavior, comes from experience.”

We note that learning can be understood:

As a product, ie the result of an experience or a change that comes with   practice.
 As a process in which the behavior changes, improves or controls.
 As a function since it is the change that occurs when the subject interacts with the information (materials, activities and academic experiences).

In the 80s there were three major changes on the theme of education and learning.
1. The passage of a psychosocial orientation of education to their integration into   a theory of teaching.

2. The paradigm shift from a predominantly behavioral, cognitive orientation to another.
3. Expanding the concept of learning which includes cognitive and effective.

For now define that distance education is a form of education, referring to the process, but this process is done remotely. For what could be defined as the act or process of educating or being educated, when this process is done remotely without using a physical space where members are meeting the educational process.
Consider that the concept of education includes the teaching-learning process, according to modern interpretations of the same, thus acting to achieve a better relationship with existing and common concepts.
The Distance Education Program was conceived as a means of informal education that would integrate with people who, for cultural, social or economic not adapt or no access to conventional education systems.

Definitions of other institutions

Let’s see how some institutions define distance education.
Combination of education and technology to reach their audience through large distances is the hallmark of distance learning. This amounts to a strategic means to provide training, education and new communication channels for businesses, educational institutions, government and other public and private agencies. With predictions of being one of the seven major developments in the area of education in the future, distance education is crucial in our geopolitical situation as a means of disseminating and assimilating information on a global basis .- (Texas A & M University) .
Distance Education is distributing education that does not require students to be physically present in the same place with the instructor. Historically, Distance Education meant studying by correspondence. Today, audio, video and computer technology are most common modes of transmission: (The Distance Learning Resource Network DLRN).
The term distance education represents a variety of education models have in common the physical separation of teachers and some or all students (University of Maryland).
At its basic level, distance education takes place when students and teachers are separated by physical distance and technology (voice, video, data and impressions) often in combination with face to face classes, is used as a bridge to reduce this barrier (Distance Education at a Glance).

Using the above definitions we can identify three criteria for distance education.

These are:
• Separation of teachers and students, at least in most parts of the process,
• The use of technological means to unite education teachers and students,
• Using two-way communication between students and instructors.

Like terms.
 Now to distinguish between some similar terms, synonyms, Distance Education.
To define more clearly the issue now discuss terms associated. There are many terms that are used as synonyms for Distance Education. While many of these terms are related, there are differences. Usually when people use one of these terms or otherwise, unless they have a specific purpose related to distance education.

These terms include

Distance Learning (Distance Learning)
The school and instructor control of distance education but the learning is student responsibility. The student is responsible for obtaining the knowledge, understanding or application through the educational process.
Learning is the result of education. The teacher provides the environment that makes learning possible, but the student is performing it.
Distance learning can be considered a product of distance education.

Open Learning (Open Learning)
Open learning is a possibility of access to educational opportunities. Opening up opportunities for groups of the population that traditionally lacked the prerequisites for higher education. Open learning has changed the concept that education must be conducted within a prescribed schedule and school formal means.

Distributed Learning (Distributed Learning)
Distributed learning, also known as learning networks, combining different ways of sending mail. It is characterized by user groups and modes of communication, all computerized. The distributed learning are increasingly combining internal computer networks (Intranets) running on LANs (local area networks) and Internet.

Flexible Learning (Flexible Learning)
Flexible Learning seeks to optimize every opportunity for education. Recognizes that not all students learn the same way. Flexible learning focuses on learning strategies for individual students. Using all the strategies and techniques available to maximize the educational process. Flexible learning aims to be student-centered, emphasizing the responsibility of students, learning to train and rhythm of individual advancement.

At a basic level distance education takes place when educators and students are physically separated and technologies (video, voice, data, and print) are used combined with witnessing activities to reduce the impact of distance learning.

The distance education programs are providing adults a second chance at higher education and are helping those with limited time, distance, work or physical limitations, to update the skills required in their work.

How is Distance Education?
Currently using a variety of electronic means to send or receive support materials for distance education. Each institution determines the most appropriate media, in which it has at its disposal and its students well, and with them makes the combinations that best suit their capabilities. The media can be classified into four broad categories:

Voice: The educational tools related to the voice can be divided into passive and interactive. Among the former are the telephone, audio conferencing, voice mail and shortwave radio. The technological tools are passive voice audio recorders. Interactive technologies allow simultaneous communication in both directions, send and receive, while in the passive the student only receives the message and cannot answer it at that time.

Video: Inside find the video images, such as computer presentations (slide shows, Power Point, etc.) Filmed moving images (movies, videos, digitized film, etc.). And moving images transmitted in time real. These can be in one direction, such as those sent via satellite or commercial television or may be through computers in desktop video conferencing or interactive video conferencing.

Data: Applies to the information sent and received through computers. In this category are four broad categories:

• Computer Aided Education (Computer-assisted instruction (CAI))
• Administered by Computer Education (Computer-managed instruction (CMI))
• Education for Computer Multimedia through. (Computer-Based Multimedia (CBM)
• Education through Computers. (Computer-mediated education (CME))

Materials: This was the basic form of distance education programs, from the current systems evolved. It includes textbooks, study guides, workbooks, curricula, case studies, etc.. Currently one of the forms printed have been displaced by data sent via computer and made available to students via the Internet, where it is common to find programs of classes, lectures, study guides and some materials more. The student can now consult the Internet, forward them to your computer or print if desired.

Is Distance Education Effective?
Many educators ask if distant students learn as well as traditional students. Researchers who have compared the methods of distance education with traditional forms have concluded that distance education can be as effective as traditional forms of education face when using the methods and technologies, ie, when there is interaction between students and when they have timely feedback from the teacher.
One of the key questions associated with educational technology is whether it helps or not student learning. There have been two main approaches used to investigate the media. It compares the new medium (radio, tv computer) with a traditional classroom. In these studies comparing distance education with traditional methods in the classroom. Many studies have shown no significant difference in the achievements made as a result of the comparisons. The result achieved by students is not a function of the mode of teaching. Some studies have found higher returns when students used interactive computer programs, including email, video one way or two-way communication and media.
Other studies have focused on the learning context rather than a specific means of transmission. These studies have shown that students perform better when you combine several means of delivery and teaching techniques. They have studied the effects of using desktop videoconferencing used to evaluate the work of other colleagues or the effect of participating in large workgroups. The interaction between collaborative working groups and new educational technologies generally produce positive outcomes for students.
Finally, some studies have identified several factors that appear to be particularly important in distance education. A high level of student motivation, hard work and ethical, academic and technical support to students include measures which generally produce good results in the students. Support to students has been defined as providing not only academic, but also the identification and solution of problems of students, providing opportunities for interaction between students and teachers, and the ability to keep them motivated through monitoring of achievements and feedback.

Key elements in Distance Education
At first we define education as a process and as such has elements that play roles in the process. We discuss the key elements of distance education process and the changes they have experienced their roles for the effects of technology.

Students: Regardless of the context in which to develop education, the role of students is learning. This is a daunting task that usually in most cases requires motivation, planning and the ability to analyze and apply knowledge they learn. When distance education is to have a special burden that are separated from their companions, and they have near them who share their interests and knowledge. Furthermore, with the new technologies are now able to interact with peers who may live in very different to his, and enrich their learning experiences with others, and the experience of their teachers.
Educators: The effectiveness of any distance education process rests firmly on the shoulders of educators and teachers. In a traditional classroom, the teacher’s responsibilities also include determining the specific content of the course, understand and address the particular needs of students. In distance education teachers must also:

• Develop an understanding and knowledge of the characteristics and needs of distance learners with little or no personal contact.

• Adapt teaching styles taking into consideration the needs and expectations of a wide and diverse audience.

• Knowing how to operate educational technology while keeping their attention on their roles as educators.

• Operate effectively as a facilitator and as a content provider.

Consultants: It’s a new character in distance education that is used in remote sites to support the teacher or principal instructor, providing advice and support to students and being a bridge between students and lead teacher. Carry out functions such as installation of equipment and software meet the jobs and tasks, and use tests are the eyes and ears of the teacher in distant sites.

Support Staff: They are responsible for the numerous technical details and communication required in a distance education process function effectively. Usually responsible for the registration of students, duplication and distribution of materials, shipment of textbooks, control and distribution of correspondence between students and teachers, scheduling courses, checking grades, following the development of courses . On the technical side of educational technology, are responsible for the installation and operation of communication networks, installation or development of software required for the process of distance education, technical assistance with questions from students or correcting faults and communication problems, or performance.

Administrators: Administrators are directly related to the planning and implementation of distance education programs. Once in operation the programs achieve coordination among support personnel, technical, academic to ensure there are material resources, technological and human resources to achieve the objectives of the institution. Maintain the academic focus of distance education programs.

Why teach at a distance?
Teachers in a traditional school classroom support the realization of its kind in that they can observe the behavior of their students. Eye contact is an essential element for imparting knowledge. A quick glance lets them know who is paying attention and taking notes, who is preparing to ask a question or comment. It also allows them to detect a student who is bored and tired, as it is equally clear. Good teachers are attentive to the manifestations of their students’ behavior and modify the alternate class activities according to the circumstances they detect.
In contrast, the distance teacher has little or no eye contact with students. In addition to the few contacts that are distorted or are somehow affected by the barriers imposed by technology. It is more difficult to maintain a stimulating teacher-student discussion when you are not seeing the faces or when to expect the arrival of the sound between the two remote sites.

However, many teachers who use it have the idea that the opportunities offered by distance education outweigh the obstacles to the use of technology. In fact, many instructors agree that the distance that requires preparation courses to help improve their performance as teachers. The challenges of distance education means are offset by opportunities for:

• To reach a wider audience of students.

• Meet the needs of students who cannot attend regular classes at universities due to limited work, time or space.

• Engage in class participation of experts from other areas that are located anywhere and that would not otherwise be accessible to students.

• Gather students of different cultural, economic, social and with varied work experiences and knowledge.

• Make education and training accessible to students in remote areas.

• Allowing can continue their studies without having to stop working and getting paid.

• Ensure that students can get expert advice from highly skilled teachers.

From a strictly educational standpoint, not managerial or administrative, that is, from the perspective of the creation, production, dissemination and critical evaluation of knowledge, technology can be applied in four basic ways which are:

1. How to help education?

2. How direct support learning?

3. “As an analytical tool for thinking systemically education?

4. How research helps to intellectual, scientific or artistic creation?

We do not doubt the enormous positive impact which the use of various telecommunications technologies in educational processes. Benefits are reported in economy of time in more individualized to the specific needs of each user, to facilitate content learning through greater connection audiovisual sensory and sequential themes, subjects studied, to shorten geographical distances, to communicate quickly to multiple people simultaneously, in rapid dissemination of findings, research and knowledge on student interaction with the learning experience and I can go on citing many advantages for the educational process appropriate use of technologies. It is a way of encouraging active student participation in learning.

 What to do to be successful learning?
Good educational practice is essentially the same distance to the traditional good educational practice and the factors that influence education are generally universal in different environments. Since the technology using distance education requires more planning and preparation, teachers who teach distance should consider the following factors to improve its effectiveness:

• It requires extensive planning and evaluation of equipment and training courses. The distance students appreciate teachers who are well prepared course and being organized.

• Students perform better when the program and class materials are well presented. The use of images and graphics and interactivity contributes to the understanding by students of the course. However, the use of visual aids should be considered in terms of the environment in which they taught the class and possible characteristics of students.

• Teachers need to be trained in the use of equipment and techniques suitable for distance education. Students learn best when the teacher dominates the hardware and software used for distance education.

Many distance students need advice and support to perform most of the learning experience. The support they can get from the combination of interaction with the teacher or other students through discussion forums and tools that will provide the teacher.

• Students appreciate timely feedback on course content, examinations or assessments and projects or works to be performed.

• Students will gain great benefits from learning to participate in small learning groups. These groups provide support and encouragement as well as feedback on course work and tasks. The groups also provide them with the assurance that if they need help, where will get it.

• Students generally stay more motivated if they are in contact with the teacher or counselor. The formal contact within the course design can be used as a motivational tool.

• The use of local facilitators who are responsible for developing a friendly environment for working with students and those familiar with the team and the course content, increase student satisfaction with the course.

For teachers, participating in distance education programs requires the improvement of skills they already have, rather than the development of new skills, so they must put attention to the following aspects.

• Evaluate the content really can be included and addressed effectively in any course. Given the logistics that distance education requires, submit the same content at a distance usually requires more time to present it in a classroom.

• Note that students who participate in your course will probably have different learning styles. Some team will facilitate learning, while others will be excellent independent work.

• Diversify and schedule the course activities and avoid long readings. Interleave content presentations with discussions and exercises for students. Keep in mind the medium or combination of them, which will run the course and discover all the advantages we offer.

• humanize the course keeping the focus on student learning and not the medium of transmission or technology.

• Consider using some components of printed material to supplement non-print materials.

• Use examples and case studies of local students as possible and support their students to understand and apply its knowledge environment of the course. Remember that the circumstances and environments in which students will be located are varied.

• Impulse their students to share experiences with peers and with the group. You can learn much more by sharing the experiences of all, in orderly fashion. Ask them to explain how things in their environment and how they apply the knowledge they are acquiring.

• Be concise. Use short statements and comprehensive. Ask things directly. Always remember that the distances make communication slower and that students need more time to respond.

• Develop strategies to strengthen students for review, repetition and remediation. For this, the phone counseling, email or audio conference can be very useful.

• Stay relaxed. Students need to familiarize participants with the new form of distance education in which they are participating. After the initial period the rate of progress in improving learning.
If the teacher uses appropriate strategies for interaction and feedback can identify and meet the individual needs of their students, while establishing adequate mechanisms to enable it to constantly improve the course. To improve interaction and feedback, keep the following:

• Use questions that students can study before classes to promote critical thinking and well-informed participation of students. Use the time on his side and avoid the improvisations of the students. Let them investigate and substantiate their shares.

• Since the beginning of the courses ask students to make contact with you and each other through e-mail to feel accustomed to the process. Maintain electronic communication forums can be a very effective tool.

• Establish and respect for their office hours at that distance learners can locate him by telephone, audio conferencing or desktop videoconferencing. Use the evening or night if the majority of students work during the day.

• Keep a variety of forms of interaction and feedback. The easier it is for different types of students select one in which they feel most comfortable. Consider also the personal visits whenever possible.

• Communicate with all sites or all students, if possible every week, especially early in the course. Determine students not participating in the first session and establish communication with them.

• Keep forms of communication available to discuss matters related to the content, relevance, the course syllabus, shipping materials, work in teams and form of instruction.

• Have students keep a journal about their experiences and thoughts on the process and ideas about course content. Ask them to send their units frequently.

• Use local facilitators to stimulate interaction when their students are hesitant to ask questions or participate.

• Ensure that all students have equal opportunities to participate. Diplomatically but firmly discourage students’ attempts to monopolize or sites wishing to participate in class time.

• Make detailed comments on the work or opinions received, refer them to additional sources of information where they can enrich their learning. Answer promptly by the most effective and expeditious disposal.

BENEFITS OF DISTANCE  EDUCATION
• No boundaries of time or place.

• Ability to offer courses according to needs at the right time.

• Adaptation of content.

• Greater possibility of renovation continues.

• Provision of courses taught by professionals from the Association.

• Sharing Resources: Distance education enables the institutional resources of a school or institution will be used to teach students from other schools or institutions

• Greater access to students: Through distance education, students have access to instruction in more than one location, instead of only the local instruction. This makes learning more accessible for many students.

• Improving the quality of education: Distance education should be considered as a future goal of the organizations and institutions, as well as how to take advantage of any special characteristics of a remote location.

• Flexibility in time and space
Provides participants the flexibility to access the study material and study schedule that allows asynchronous, anywhere where they are

• Rate of custom study
Allow time management and use of the hours that best suit the participant according their own needs

• Specialized Faculty
It puts teachers experts in the field of knowledge available to participants

OTHER BENEFITS

• Autonomy in the study.

• Convenience.

• Flexibility.

• Time saving.

• Tutoring.

• Lower Costs.

Why are successful students?

Research suggests that students involved in distance education programs have certain characteristics that influence their performance in the courses:

• Student volunteers are seeking more education.

• Have college education goals

• They are highly motivated and self disciplined.

• Are older than those attending universities.
Studies have also shown that the following factors are important in both traditional and distance education.

• Willingness to seek help from the instructors.

• Serious attitude throughout the course.

Conclusion:
A high level of student motivation, hard work and ethical, academic and technical support to students include measures which generally produce good results in the students. Support to students has been defined as providing not only academic, but also the identification and solution of problems of students, providing opportunities for interaction between students and teachers, and the ability to keep them motivated through monitoring of achievements and feedback.