mirror of
https://github.com/catchorg/Catch2.git
synced 2024-12-22 11:23:29 +01:00
Update Clara to v1.1.5 to fix TextFlow bugs
This commit is contained in:
Martin Hořeňovský
parent
544c7d7cbf
commit
779e83bc20
533
include/external/clara.hpp
vendored
533
include/external/clara.hpp
vendored
@ -5,7 +5,7 @@
|
||||
//
|
||||
// See https://github.com/philsquared/Clara for more details
|
||||
|
||||
// Clara v1.1.4
|
||||
// Clara v1.1.5
|
||||
|
||||
#ifndef CATCH_CLARA_HPP_INCLUDED
|
||||
#define CATCH_CLARA_HPP_INCLUDED
|
||||
@ -34,8 +34,8 @@
|
||||
//
|
||||
// A single-header library for wrapping and laying out basic text, by Phil Nash
|
||||
//
|
||||
// This work is licensed under the BSD 2-Clause license.
|
||||
// See the accompanying LICENSE file, or the one at https://opensource.org/licenses/BSD-2-Clause
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// This project is hosted at https://github.com/philsquared/textflowcpp
|
||||
|
||||
@ -52,317 +52,326 @@
|
||||
#endif
|
||||
|
||||
|
||||
namespace Catch { namespace clara { namespace TextFlow {
|
||||
namespace Catch {
|
||||
namespace clara {
|
||||
namespace TextFlow {
|
||||
|
||||
inline auto isWhitespace( char c ) -> bool {
|
||||
static std::string chars = " \t\n\r";
|
||||
return chars.find( c ) != std::string::npos;
|
||||
}
|
||||
inline auto isBreakableBefore( char c ) -> bool {
|
||||
static std::string chars = "[({<|";
|
||||
return chars.find( c ) != std::string::npos;
|
||||
}
|
||||
inline auto isBreakableAfter( char c ) -> bool {
|
||||
static std::string chars = "])}>.,:;*+-=&/\\";
|
||||
return chars.find( c ) != std::string::npos;
|
||||
}
|
||||
inline auto isWhitespace(char c) -> bool {
|
||||
static std::string chars = " \t\n\r";
|
||||
return chars.find(c) != std::string::npos;
|
||||
}
|
||||
inline auto isBreakableBefore(char c) -> bool {
|
||||
static std::string chars = "[({<|";
|
||||
return chars.find(c) != std::string::npos;
|
||||
}
|
||||
inline auto isBreakableAfter(char c) -> bool {
|
||||
static std::string chars = "])}>.,:;*+-=&/\\";
|
||||
return chars.find(c) != std::string::npos;
|
||||
}
|
||||
|
||||
class Columns;
|
||||
class Columns;
|
||||
|
||||
class Column {
|
||||
std::vector<std::string> m_strings;
|
||||
size_t m_width = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
|
||||
size_t m_indent = 0;
|
||||
size_t m_initialIndent = std::string::npos;
|
||||
class Column {
|
||||
std::vector<std::string> m_strings;
|
||||
size_t m_width = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
|
||||
size_t m_indent = 0;
|
||||
size_t m_initialIndent = std::string::npos;
|
||||
|
||||
public:
|
||||
class iterator {
|
||||
friend Column;
|
||||
public:
|
||||
class iterator {
|
||||
friend Column;
|
||||
|
||||
Column const& m_column;
|
||||
size_t m_stringIndex = 0;
|
||||
size_t m_pos = 0;
|
||||
Column const& m_column;
|
||||
size_t m_stringIndex = 0;
|
||||
size_t m_pos = 0;
|
||||
|
||||
size_t m_len = 0;
|
||||
size_t m_end = 0;
|
||||
bool m_suffix = false;
|
||||
size_t m_len = 0;
|
||||
size_t m_end = 0;
|
||||
bool m_suffix = false;
|
||||
|
||||
iterator( Column const& column, size_t stringIndex )
|
||||
: m_column( column ),
|
||||
m_stringIndex( stringIndex )
|
||||
{}
|
||||
iterator(Column const& column, size_t stringIndex)
|
||||
: m_column(column),
|
||||
m_stringIndex(stringIndex) {}
|
||||
|
||||
auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
|
||||
auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
|
||||
|
||||
auto isBoundary( size_t at ) const -> bool {
|
||||
assert( at > 0 );
|
||||
assert( at <= line().size() );
|
||||
auto isBoundary(size_t at) const -> bool {
|
||||
assert(at > 0);
|
||||
assert(at <= line().size());
|
||||
|
||||
return at == line().size() ||
|
||||
( isWhitespace( line()[at] ) && !isWhitespace( line()[at-1] ) ) ||
|
||||
isBreakableBefore( line()[at] ) ||
|
||||
isBreakableAfter( line()[at-1] );
|
||||
}
|
||||
return at == line().size() ||
|
||||
(isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
|
||||
isBreakableBefore(line()[at]) ||
|
||||
isBreakableAfter(line()[at - 1]);
|
||||
}
|
||||
|
||||
void calcLength() {
|
||||
assert( m_stringIndex < m_column.m_strings.size() );
|
||||
void calcLength() {
|
||||
assert(m_stringIndex < m_column.m_strings.size());
|
||||
|
||||
m_suffix = false;
|
||||
auto width = m_column.m_width-indent();
|
||||
m_end = m_pos;
|
||||
while( m_end < line().size() && line()[m_end] != '\n' )
|
||||
++m_end;
|
||||
m_suffix = false;
|
||||
auto width = m_column.m_width - indent();
|
||||
m_end = m_pos;
|
||||
while (m_end < line().size() && line()[m_end] != '\n')
|
||||
++m_end;
|
||||
|
||||
if( m_end < m_pos + width ) {
|
||||
m_len = m_end - m_pos;
|
||||
}
|
||||
else {
|
||||
size_t len = width;
|
||||
while (len > 0 && !isBoundary(m_pos + len))
|
||||
--len;
|
||||
while (len > 0 && isWhitespace( line()[m_pos + len - 1] ))
|
||||
--len;
|
||||
if (m_end < m_pos + width) {
|
||||
m_len = m_end - m_pos;
|
||||
} else {
|
||||
size_t len = width;
|
||||
while (len > 0 && !isBoundary(m_pos + len))
|
||||
--len;
|
||||
while (len > 0 && isWhitespace(line()[m_pos + len - 1]))
|
||||
--len;
|
||||
|
||||
if (len > 0) {
|
||||
m_len = len;
|
||||
} else {
|
||||
m_suffix = true;
|
||||
m_len = width - 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (len > 0) {
|
||||
m_len = len;
|
||||
} else {
|
||||
m_suffix = true;
|
||||
m_len = width - 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
auto indent() const -> size_t {
|
||||
auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
|
||||
return initial == std::string::npos ? m_column.m_indent : initial;
|
||||
}
|
||||
auto indent() const -> size_t {
|
||||
auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
|
||||
return initial == std::string::npos ? m_column.m_indent : initial;
|
||||
}
|
||||
|
||||
auto addIndentAndSuffix(std::string const &plain) const -> std::string {
|
||||
return std::string( indent(), ' ' ) + (m_suffix ? plain + "-" : plain);
|
||||
}
|
||||
auto addIndentAndSuffix(std::string const &plain) const -> std::string {
|
||||
return std::string(indent(), ' ') + (m_suffix ? plain + "-" : plain);
|
||||
}
|
||||
|
||||
public:
|
||||
explicit iterator( Column const& column ) : m_column( column ) {
|
||||
assert( m_column.m_width > m_column.m_indent );
|
||||
assert( m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent );
|
||||
calcLength();
|
||||
if( m_len == 0 )
|
||||
m_stringIndex++; // Empty string
|
||||
}
|
||||
public:
|
||||
using difference_type = std::ptrdiff_t;
|
||||
using value_type = std::string;
|
||||
using pointer = value_type * ;
|
||||
using reference = value_type & ;
|
||||
using iterator_category = std::forward_iterator_tag;
|
||||
|
||||
auto operator *() const -> std::string {
|
||||
assert( m_stringIndex < m_column.m_strings.size() );
|
||||
assert( m_pos <= m_end );
|
||||
if( m_pos + m_column.m_width < m_end )
|
||||
return addIndentAndSuffix(line().substr(m_pos, m_len));
|
||||
else
|
||||
return addIndentAndSuffix(line().substr(m_pos, m_end - m_pos));
|
||||
}
|
||||
explicit iterator(Column const& column) : m_column(column) {
|
||||
assert(m_column.m_width > m_column.m_indent);
|
||||
assert(m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent);
|
||||
calcLength();
|
||||
if (m_len == 0)
|
||||
m_stringIndex++; // Empty string
|
||||
}
|
||||
|
||||
auto operator ++() -> iterator& {
|
||||
m_pos += m_len;
|
||||
if( m_pos < line().size() && line()[m_pos] == '\n' )
|
||||
m_pos += 1;
|
||||
else
|
||||
while( m_pos < line().size() && isWhitespace( line()[m_pos] ) )
|
||||
++m_pos;
|
||||
auto operator *() const -> std::string {
|
||||
assert(m_stringIndex < m_column.m_strings.size());
|
||||
assert(m_pos <= m_end);
|
||||
return addIndentAndSuffix(line().substr(m_pos, m_len));
|
||||
}
|
||||
|
||||
if( m_pos == line().size() ) {
|
||||
m_pos = 0;
|
||||
++m_stringIndex;
|
||||
}
|
||||
if( m_stringIndex < m_column.m_strings.size() )
|
||||
calcLength();
|
||||
return *this;
|
||||
}
|
||||
auto operator ++(int) -> iterator {
|
||||
iterator prev( *this );
|
||||
operator++();
|
||||
return prev;
|
||||
}
|
||||
auto operator ++() -> iterator& {
|
||||
m_pos += m_len;
|
||||
if (m_pos < line().size() && line()[m_pos] == '\n')
|
||||
m_pos += 1;
|
||||
else
|
||||
while (m_pos < line().size() && isWhitespace(line()[m_pos]))
|
||||
++m_pos;
|
||||
|
||||
auto operator ==( iterator const& other ) const -> bool {
|
||||
return
|
||||
m_pos == other.m_pos &&
|
||||
m_stringIndex == other.m_stringIndex &&
|
||||
&m_column == &other.m_column;
|
||||
}
|
||||
auto operator !=( iterator const& other ) const -> bool {
|
||||
return !operator==( other );
|
||||
}
|
||||
};
|
||||
using const_iterator = iterator;
|
||||
if (m_pos == line().size()) {
|
||||
m_pos = 0;
|
||||
++m_stringIndex;
|
||||
}
|
||||
if (m_stringIndex < m_column.m_strings.size())
|
||||
calcLength();
|
||||
return *this;
|
||||
}
|
||||
auto operator ++(int) -> iterator {
|
||||
iterator prev(*this);
|
||||
operator++();
|
||||
return prev;
|
||||
}
|
||||
|
||||
explicit Column( std::string const& text ) { m_strings.push_back( text ); }
|
||||
auto operator ==(iterator const& other) const -> bool {
|
||||
return
|
||||
m_pos == other.m_pos &&
|
||||
m_stringIndex == other.m_stringIndex &&
|
||||
&m_column == &other.m_column;
|
||||
}
|
||||
auto operator !=(iterator const& other) const -> bool {
|
||||
return !operator==(other);
|
||||
}
|
||||
};
|
||||
using const_iterator = iterator;
|
||||
|
||||
auto width( size_t newWidth ) -> Column& {
|
||||
assert( newWidth > 0 );
|
||||
m_width = newWidth;
|
||||
return *this;
|
||||
}
|
||||
auto indent( size_t newIndent ) -> Column& {
|
||||
m_indent = newIndent;
|
||||
return *this;
|
||||
}
|
||||
auto initialIndent( size_t newIndent ) -> Column& {
|
||||
m_initialIndent = newIndent;
|
||||
return *this;
|
||||
}
|
||||
explicit Column(std::string const& text) { m_strings.push_back(text); }
|
||||
|
||||
auto width() const -> size_t { return m_width; }
|
||||
auto begin() const -> iterator { return iterator( *this ); }
|
||||
auto end() const -> iterator { return { *this, m_strings.size() }; }
|
||||
auto width(size_t newWidth) -> Column& {
|
||||
assert(newWidth > 0);
|
||||
m_width = newWidth;
|
||||
return *this;
|
||||
}
|
||||
auto indent(size_t newIndent) -> Column& {
|
||||
m_indent = newIndent;
|
||||
return *this;
|
||||
}
|
||||
auto initialIndent(size_t newIndent) -> Column& {
|
||||
m_initialIndent = newIndent;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline friend std::ostream& operator << ( std::ostream& os, Column const& col ) {
|
||||
bool first = true;
|
||||
for( auto line : col ) {
|
||||
if( first )
|
||||
first = false;
|
||||
else
|
||||
os << "\n";
|
||||
os << line;
|
||||
}
|
||||
return os;
|
||||
}
|
||||
auto width() const -> size_t { return m_width; }
|
||||
auto begin() const -> iterator { return iterator(*this); }
|
||||
auto end() const -> iterator { return { *this, m_strings.size() }; }
|
||||
|
||||
auto operator + ( Column const& other ) -> Columns;
|
||||
inline friend std::ostream& operator << (std::ostream& os, Column const& col) {
|
||||
bool first = true;
|
||||
for (auto line : col) {
|
||||
if (first)
|
||||
first = false;
|
||||
else
|
||||
os << "\n";
|
||||
os << line;
|
||||
}
|
||||
return os;
|
||||
}
|
||||
|
||||
auto toString() const -> std::string {
|
||||
std::ostringstream oss;
|
||||
oss << *this;
|
||||
return oss.str();
|
||||
}
|
||||
};
|
||||
auto operator + (Column const& other)->Columns;
|
||||
|
||||
class Spacer : public Column {
|
||||
auto toString() const -> std::string {
|
||||
std::ostringstream oss;
|
||||
oss << *this;
|
||||
return oss.str();
|
||||
}
|
||||
};
|
||||
|
||||
public:
|
||||
explicit Spacer( size_t spaceWidth ) : Column( "" ) {
|
||||
width( spaceWidth );
|
||||
}
|
||||
};
|
||||
class Spacer : public Column {
|
||||
|
||||
class Columns {
|
||||
std::vector<Column> m_columns;
|
||||
public:
|
||||
explicit Spacer(size_t spaceWidth) : Column("") {
|
||||
width(spaceWidth);
|
||||
}
|
||||
};
|
||||
|
||||
public:
|
||||
class Columns {
|
||||
std::vector<Column> m_columns;
|
||||
|
||||
class iterator {
|
||||
friend Columns;
|
||||
struct EndTag {};
|
||||
public:
|
||||
|
||||
std::vector<Column> const& m_columns;
|
||||
std::vector<Column::iterator> m_iterators;
|
||||
size_t m_activeIterators;
|
||||
class iterator {
|
||||
friend Columns;
|
||||
struct EndTag {};
|
||||
|
||||
iterator( Columns const& columns, EndTag )
|
||||
: m_columns( columns.m_columns ),
|
||||
m_activeIterators( 0 )
|
||||
{
|
||||
m_iterators.reserve( m_columns.size() );
|
||||
std::vector<Column> const& m_columns;
|
||||
std::vector<Column::iterator> m_iterators;
|
||||
size_t m_activeIterators;
|
||||
|
||||
for( auto const& col : m_columns )
|
||||
m_iterators.push_back( col.end() );
|
||||
}
|
||||
iterator(Columns const& columns, EndTag)
|
||||
: m_columns(columns.m_columns),
|
||||
m_activeIterators(0) {
|
||||
m_iterators.reserve(m_columns.size());
|
||||
|
||||
public:
|
||||
explicit iterator( Columns const& columns )
|
||||
: m_columns( columns.m_columns ),
|
||||
m_activeIterators( m_columns.size() )
|
||||
{
|
||||
m_iterators.reserve( m_columns.size() );
|
||||
for (auto const& col : m_columns)
|
||||
m_iterators.push_back(col.end());
|
||||
}
|
||||
|
||||
for( auto const& col : m_columns )
|
||||
m_iterators.push_back( col.begin() );
|
||||
}
|
||||
public:
|
||||
using difference_type = std::ptrdiff_t;
|
||||
using value_type = std::string;
|
||||
using pointer = value_type * ;
|
||||
using reference = value_type & ;
|
||||
using iterator_category = std::forward_iterator_tag;
|
||||
|
||||
auto operator ==( iterator const& other ) const -> bool {
|
||||
return m_iterators == other.m_iterators;
|
||||
}
|
||||
auto operator !=( iterator const& other ) const -> bool {
|
||||
return m_iterators != other.m_iterators;
|
||||
}
|
||||
auto operator *() const -> std::string {
|
||||
std::string row, padding;
|
||||
explicit iterator(Columns const& columns)
|
||||
: m_columns(columns.m_columns),
|
||||
m_activeIterators(m_columns.size()) {
|
||||
m_iterators.reserve(m_columns.size());
|
||||
|
||||
for( size_t i = 0; i < m_columns.size(); ++i ) {
|
||||
auto width = m_columns[i].width();
|
||||
if( m_iterators[i] != m_columns[i].end() ) {
|
||||
std::string col = *m_iterators[i];
|
||||
row += padding + col;
|
||||
if( col.size() < width )
|
||||
padding = std::string( width - col.size(), ' ' );
|
||||
else
|
||||
padding = "";
|
||||
}
|
||||
else {
|
||||
padding += std::string( width, ' ' );
|
||||
}
|
||||
}
|
||||
return row;
|
||||
}
|
||||
auto operator ++() -> iterator& {
|
||||
for( size_t i = 0; i < m_columns.size(); ++i ) {
|
||||
if (m_iterators[i] != m_columns[i].end())
|
||||
++m_iterators[i];
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
auto operator ++(int) -> iterator {
|
||||
iterator prev( *this );
|
||||
operator++();
|
||||
return prev;
|
||||
}
|
||||
};
|
||||
using const_iterator = iterator;
|
||||
for (auto const& col : m_columns)
|
||||
m_iterators.push_back(col.begin());
|
||||
}
|
||||
|
||||
auto begin() const -> iterator { return iterator( *this ); }
|
||||
auto end() const -> iterator { return { *this, iterator::EndTag() }; }
|
||||
auto operator ==(iterator const& other) const -> bool {
|
||||
return m_iterators == other.m_iterators;
|
||||
}
|
||||
auto operator !=(iterator const& other) const -> bool {
|
||||
return m_iterators != other.m_iterators;
|
||||
}
|
||||
auto operator *() const -> std::string {
|
||||
std::string row, padding;
|
||||
|
||||
auto operator += ( Column const& col ) -> Columns& {
|
||||
m_columns.push_back( col );
|
||||
return *this;
|
||||
}
|
||||
auto operator + ( Column const& col ) -> Columns {
|
||||
Columns combined = *this;
|
||||
combined += col;
|
||||
return combined;
|
||||
}
|
||||
for (size_t i = 0; i < m_columns.size(); ++i) {
|
||||
auto width = m_columns[i].width();
|
||||
if (m_iterators[i] != m_columns[i].end()) {
|
||||
std::string col = *m_iterators[i];
|
||||
row += padding + col;
|
||||
if (col.size() < width)
|
||||
padding = std::string(width - col.size(), ' ');
|
||||
else
|
||||
padding = "";
|
||||
} else {
|
||||
padding += std::string(width, ' ');
|
||||
}
|
||||
}
|
||||
return row;
|
||||
}
|
||||
auto operator ++() -> iterator& {
|
||||
for (size_t i = 0; i < m_columns.size(); ++i) {
|
||||
if (m_iterators[i] != m_columns[i].end())
|
||||
++m_iterators[i];
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
auto operator ++(int) -> iterator {
|
||||
iterator prev(*this);
|
||||
operator++();
|
||||
return prev;
|
||||
}
|
||||
};
|
||||
using const_iterator = iterator;
|
||||
|
||||
inline friend std::ostream& operator << ( std::ostream& os, Columns const& cols ) {
|
||||
auto begin() const -> iterator { return iterator(*this); }
|
||||
auto end() const -> iterator { return { *this, iterator::EndTag() }; }
|
||||
|
||||
bool first = true;
|
||||
for( auto line : cols ) {
|
||||
if( first )
|
||||
first = false;
|
||||
else
|
||||
os << "\n";
|
||||
os << line;
|
||||
}
|
||||
return os;
|
||||
}
|
||||
auto operator += (Column const& col) -> Columns& {
|
||||
m_columns.push_back(col);
|
||||
return *this;
|
||||
}
|
||||
auto operator + (Column const& col) -> Columns {
|
||||
Columns combined = *this;
|
||||
combined += col;
|
||||
return combined;
|
||||
}
|
||||
|
||||
auto toString() const -> std::string {
|
||||
std::ostringstream oss;
|
||||
oss << *this;
|
||||
return oss.str();
|
||||
}
|
||||
};
|
||||
inline friend std::ostream& operator << (std::ostream& os, Columns const& cols) {
|
||||
|
||||
inline auto Column::operator + ( Column const& other ) -> Columns {
|
||||
Columns cols;
|
||||
cols += *this;
|
||||
cols += other;
|
||||
return cols;
|
||||
}
|
||||
}}} // namespace Catch::clara::TextFlow
|
||||
bool first = true;
|
||||
for (auto line : cols) {
|
||||
if (first)
|
||||
first = false;
|
||||
else
|
||||
os << "\n";
|
||||
os << line;
|
||||
}
|
||||
return os;
|
||||
}
|
||||
|
||||
auto toString() const -> std::string {
|
||||
std::ostringstream oss;
|
||||
oss << *this;
|
||||
return oss.str();
|
||||
}
|
||||
};
|
||||
|
||||
inline auto Column::operator + (Column const& other) -> Columns {
|
||||
Columns cols;
|
||||
cols += *this;
|
||||
cols += other;
|
||||
return cols;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
#endif // CATCH_CLARA_TEXTFLOW_HPP_INCLUDED
|
||||
|
||||
// ----------- end of #include from clara_textflow.hpp -----------
|
||||
// ........... back in clara.hpp
|
||||
|
||||
|
||||
#include <string>
|
||||
#include <memory>
|
||||
#include <set>
|
||||
#include <algorithm>
|
||||
|
||||
@ -6732,7 +6732,7 @@ Matchers.tests.cpp:<line number>:
|
||||
PASSED:
|
||||
CHECK_THAT( testStringForMatching(), Contains("aBC", Catch::CaseSensitive::No) )
|
||||
with expansion:
|
||||
"this string contains 'abc' as a substring" contains: "abc" (case insensitive)
|
||||
"this string contains 'abc' as a substring" contains: "abc" (case
|
||||
insensitive)
|
||||
|
||||
Matchers.tests.cpp:<line number>:
|
||||
@ -10865,7 +10865,7 @@ with expansion:
|
||||
-------------------------------------------------------------------------------
|
||||
xmlentitycheck
|
||||
embedded xml: <test>it should be possible to embed xml characters, such as <,
|
||||
" or &, or even whole <xml>documents</xml> within an attribute</test>
|
||||
" or &, or even whole <xml>documents</xml> within an attribute
|
||||
</test>
|
||||
-------------------------------------------------------------------------------
|
||||
Misc.tests.cpp:<line number>
|
||||
|
||||
25
third_party/clara.hpp
vendored
25
third_party/clara.hpp
vendored
@ -5,7 +5,7 @@
|
||||
//
|
||||
// See https://github.com/philsquared/Clara for more details
|
||||
|
||||
// Clara v1.1.4
|
||||
// Clara v1.1.5
|
||||
|
||||
#ifndef CLARA_HPP_INCLUDED
|
||||
#define CLARA_HPP_INCLUDED
|
||||
@ -34,8 +34,8 @@
|
||||
//
|
||||
// A single-header library for wrapping and laying out basic text, by Phil Nash
|
||||
//
|
||||
// This work is licensed under the BSD 2-Clause license.
|
||||
// See the accompanying LICENSE file, or the one at https://opensource.org/licenses/BSD-2-Clause
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// This project is hosted at https://github.com/philsquared/textflowcpp
|
||||
|
||||
@ -142,6 +142,12 @@ namespace clara { namespace TextFlow {
|
||||
}
|
||||
|
||||
public:
|
||||
using difference_type = std::ptrdiff_t;
|
||||
using value_type = std::string;
|
||||
using pointer = value_type*;
|
||||
using reference = value_type&;
|
||||
using iterator_category = std::forward_iterator_tag;
|
||||
|
||||
explicit iterator( Column const& column ) : m_column( column ) {
|
||||
assert( m_column.m_width > m_column.m_indent );
|
||||
assert( m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent );
|
||||
@ -153,10 +159,7 @@ namespace clara { namespace TextFlow {
|
||||
auto operator *() const -> std::string {
|
||||
assert( m_stringIndex < m_column.m_strings.size() );
|
||||
assert( m_pos <= m_end );
|
||||
if( m_pos + m_column.m_width < m_end )
|
||||
return addIndentAndSuffix(line().substr(m_pos, m_len));
|
||||
else
|
||||
return addIndentAndSuffix(line().substr(m_pos, m_end - m_pos));
|
||||
return addIndentAndSuffix(line().substr(m_pos, m_len));
|
||||
}
|
||||
|
||||
auto operator ++() -> iterator& {
|
||||
@ -266,6 +269,12 @@ namespace clara { namespace TextFlow {
|
||||
}
|
||||
|
||||
public:
|
||||
using difference_type = std::ptrdiff_t;
|
||||
using value_type = std::string;
|
||||
using pointer = value_type*;
|
||||
using reference = value_type&;
|
||||
using iterator_category = std::forward_iterator_tag;
|
||||
|
||||
explicit iterator( Columns const& columns )
|
||||
: m_columns( columns.m_columns ),
|
||||
m_activeIterators( m_columns.size() )
|
||||
@ -355,7 +364,7 @@ namespace clara { namespace TextFlow {
|
||||
cols += other;
|
||||
return cols;
|
||||
}
|
||||
}} // namespace clara::TextFlow
|
||||
}}
|
||||
|
||||
#endif // CLARA_TEXTFLOW_HPP_INCLUDED
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user