{

std::basic_string< charT > result;

for (typename std::basic_string< charT >::size_type i = 0; i < str.size(); ++i)

{

result.append(1, static_cast< charT >(std::tolower(str[i])));

}

return result;

const value_semantic* s)

: m_value_semantic(s)

{

this->set_names(names);

const value_semantic* s,

const char* description)

: m_description(description), m_value_semantic(s)

{

this->set_names(names);

bool approx,

bool long_ignore_case,

bool short_ignore_case) const

{

match_result result = no_match;

std::string local_option = (long_ignore_case ? tolower_(option) : option);

for(std::vector<std::string>::const_iterator it(m_long_names.begin()); it != m_long_names.end(); it++)

{

std::string local_long_name((long_ignore_case ? tolower_(*it) : *it));

if (!local_long_name.empty()) {

if ((result == no_match) && (*local_long_name.rbegin() == '*'))

{

// The name ends with '*'. Any specified name with the given

// prefix is OK.

if (local_option.find(local_long_name.substr(0, local_long_name.length()-1))

== 0)

result = approximate_match;

}

if (local_long_name == local_option)

{

result = full_match;

break;

}

else if (approx)

{

if (local_long_name.find(local_option) == 0)

{

result = approximate_match;

}

}

}

}

if (result != full_match)

{

std::string local_short_name(short_ignore_case ? tolower_(m_short_name) : m_short_name);

if (local_short_name == local_option)

{

result = full_match;

}

}

return result;

{

// We prefer the first long name over any others

if (!m_long_names.empty())

{

if (prefix_style == command_line_style::allow_long)

return "--" + *m_long_names.begin();

if (prefix_style == command_line_style::allow_long_disguise)

return "-" + *m_long_names.begin();

}

// sanity check: m_short_name[0] should be '-' or '/'

if (m_short_name.length() == 2)

{

if (prefix_style == command_line_style::allow_slash_for_short)

return string("/") + m_short_name[1];

if (prefix_style == command_line_style::allow_dash_for_short)

return string("-") + m_short_name[1];

}

if (!m_long_names.empty())

return *m_long_names.begin();

else

return m_short_name;

{

// reinterpret_cast is to please msvc 10.

return (m_long_names.empty())

? std::pair<const std::string*, size_t>(reinterpret_cast<const std::string*>(0), 0 )

: std::pair<const std::string*, size_t>( &(*m_long_names.begin()), m_long_names.size());

{

if (!m_short_name.empty())

{

return m_long_names.empty()

? m_short_name

: string(m_short_name).append(" [ --").

append(*m_long_names.begin()).append(" ]");

}

return string("--").append(*m_long_names.begin());

{

if (m_value_semantic->max_tokens() != 0)

return m_value_semantic->name();

else

return "";

unsigned min_description_length)

: m_line_length(line_length)

, m_min_description_length(min_description_length)

{

// we require a space between the option and description parts, so add 1.

assert(m_min_description_length < m_line_length - 1);

unsigned line_length,

unsigned min_description_length)

: m_caption(caption)

, m_line_length(line_length)

, m_min_description_length(min_description_length)

{

// we require a space between the option and description parts, so add 1.

assert(m_min_description_length < m_line_length - 1);

{

m_options.push_back(desc);

belong_to_group.push_back(false);

std::string par,

unsigned indent,

unsigned line_length)

{

// Through reminder of this function, 'line_length' will

// be the length available for characters, not including

// indent.

assert(indent < line_length);

line_length -= indent;

// index of tab (if present) is used as additional indent relative

// to first_column_width if paragrapth is spanned over multiple

// lines if tab is not on first line it is ignored

string::size_type par_indent = par.find('\t');

if (par_indent == string::npos)

{

par_indent = 0;

}

else

{

// only one tab per paragraph allowed

if (count(par.begin(), par.end(), '\t') > 1)

{

boost::throw_exception(program_options::error(

"Only one tab per paragraph is allowed in the options description"));

}

// erase tab from string

par.erase(par_indent, 1);

// this assert may fail due to user error or

// environment conditions!

assert(par_indent < line_length);

// ignore tab if not on first line

if (par_indent >= line_length)

{

par_indent = 0;

}

}

if (par.size() < line_length)

{

os << par;

}

else

{

string::const_iterator line_begin = par.begin();

const string::const_iterator par_end = par.end();

bool first_line = true; // of current paragraph!

while (line_begin < par_end) // paragraph lines

{

if (!first_line)

{

// If line starts with space, but second character

// is not space, remove the leading space.

// We don't remove double spaces because those

// might be intentianal.

if ((*line_begin == ' ') &&

((line_begin + 1 < par_end) &&

(*(line_begin + 1) != ' ')))

{

line_begin += 1; // line_begin != line_end

}

}

// Take care to never increment the iterator past

// the end, since MSVC 8.0 (brokenly), assumes that

// doing that, even if no access happens, is a bug.

unsigned remaining = static_cast<unsigned>(std::distance(line_begin, par_end));

string::const_iterator line_end = line_begin +

((remaining < line_length) ? remaining : line_length);

// prevent chopped words

// Is line_end between two non-space characters?

if ((*(line_end - 1) != ' ') &&

((line_end < par_end) && (*line_end != ' ')))

{

// find last ' ' in the second half of the current paragraph line

string::const_iterator last_space =

find(reverse_iterator<string::const_iterator>(line_end),

reverse_iterator<string::const_iterator>(line_begin),

' ')

.base();

if (last_space != line_begin)

{

// is last_space within the second half ot the

// current line

if (static_cast<unsigned>(std::distance(last_space, line_end)) <

(line_length / 2))

{

line_end = last_space;

}

}

} // prevent chopped words

// write line to stream

copy(line_begin, line_end, ostream_iterator<char>(os));

if (first_line)

{

indent += static_cast<unsigned>(par_indent);

line_length -= static_cast<unsigned>(par_indent); // there's less to work with now

first_line = false;

}

// more lines to follow?

if (line_end != par_end)

{

os << '\n';

for(unsigned pad = indent; pad > 0; --pad)

{

os.put(' ');

}

}

// next line starts after of this line

line_begin = line_end;

} // paragraph lines

}

const std::string& desc,

unsigned first_column_width,

unsigned line_length)

{

// we need to use one char less per line to work correctly if actual

// console has longer lines

assert(line_length > 1);

if (line_length > 1)

{

--line_length;

}

// line_length must be larger than first_column_width

// this assert may fail due to user error or environment conditions!

assert(line_length > first_column_width);

// Note: can't use 'tokenizer' as name of typedef -- borland

// will consider uses of 'tokenizer' below as uses of

// boost::tokenizer, not typedef.

typedef boost::tokenizer<boost::char_separator<char> > tok;

tok paragraphs(

desc,

char_separator<char>("\n", "", boost::keep_empty_tokens));

tok::const_iterator par_iter = paragraphs.begin();

const tok::const_iterator par_end = paragraphs.end();

while (par_iter != par_end) // paragraphs

{

format_paragraph(os, *par_iter, first_column_width,

line_length);

++par_iter;

// prepair next line if any

if (par_iter != par_end)

{

os << '\n';

for(unsigned pad = first_column_width; pad > 0; --pad)

{

os.put(' ');

}

}

} // paragraphs

unsigned first_column_width, unsigned line_length)

{

stringstream ss;

ss << " " << opt.format_name() << ' ' << opt.format_parameter();

// Don't use ss.rdbuf() since g++ 2.96 is buggy on it.

os << ss.str();

if (!opt.description().empty())

{

if (ss.str().size() >= first_column_width)

{

os.put('\n'); // first column is too long, lets put description in new line

for (unsigned pad = first_column_width; pad > 0; --pad)

{

os.put(' ');

}

} else {

for(unsigned pad = first_column_width - static_cast<unsigned>(ss.str().size()); pad > 0; --pad)

{

os.put(' ');

}

}

format_description(os, opt.description(),

first_column_width, line_length);

}

{

/* Find the maximum width of the option column */

unsigned width(23);

unsigned i; // vc6 has broken for loop scoping

for (i = 0; i < m_options.size(); ++i)

{

const option_description& opt = *m_options[i];

stringstream ss;

ss << " " << opt.format_name() << ' ' << opt.format_parameter();

width = (max)(width, static_cast<unsigned>(ss.str().size()));

}

/* Get width of groups as well*/

for (unsigned j = 0; j < groups.size(); ++j)

width = max(width, groups[j]->get_option_column_width());

/* this is the column were description should start, if first

const unsigned start_of_description_column = m_line_length - m_min_description_length;

width = (min)(width, start_of_description_column-1);

/* add an additional space to improve readability */

++width;

return width;

{

if (!m_caption.empty())

os << m_caption << ":\n";

if (!width)

width = get_option_column_width();

/* The options formatting style is stolen from Subversion. */

for (unsigned i = 0; i < m_options.size(); ++i)

{

if (belong_to_group[i])

continue;

const option_description& opt = *m_options[i];

format_one(os, opt, width, m_line_length);

os << "\n";

}

for (unsigned j = 0; j < groups.size(); ++j) {

os << "\n";

groups[j]->print(os, width);

}