gergely/taskwarrior-2.x
1
0
Fork 0
Code Issues Actions Packages Projects Releases 1 Wiki Activity

text: Removed local join/split implementation

Browse Source
This commit is contained in:
Paul Beckingham
2016-12-07 01:14:16 -05:00
parent db0f8d33e1
commit 232d266fb5
11 changed files with 18 additions and 277 deletions
Download Patch File Download Diff File Expand all files Collapse all files

241
src/text.cpp
View File

@@ -36,6 +36,7 @@
#include <Lexer.h>
#include <math.h>
#include <util.h>
#include <shared.h>
#include <text.h>
#include <utf8.h>
#include <i18n.h>
@@ -45,246 +46,6 @@ extern Context context;
static const char* newline = "\n";
static const char* noline = "";
///////////////////////////////////////////////////////////////////////////////
void wrapText (
std::vector <std::string>& lines,
const std::string& text,
const int width,
bool hyphenate)
{
std::string line;
unsigned int offset = 0;
while (extractLine (line, text, width, hyphenate, offset))
lines.push_back (line);
}
////////////////////////////////////////////////////////////////////////////////
void split (
std::set<std::string>& results,
const std::string& input,
const char delimiter)
{
results.clear ();
std::string::size_type start = 0;
std::string::size_type i;
while ((i = input.find (delimiter, start)) != std::string::npos)
{
results.insert (input.substr (start, i - start));
start = i + 1;
}
if (input.length ())
results.insert (input.substr (start));
}
////////////////////////////////////////////////////////////////////////////////
void split (
std::vector<std::string>& results,
const std::string& input,
const char delimiter)
{
results.clear ();
std::string::size_type start = 0;
std::string::size_type i;
while ((i = input.find (delimiter, start)) != std::string::npos)
{
results.push_back (input.substr (start, i - start));
start = i + 1;
}
if (input.length ())
results.push_back (input.substr (start));
}
////////////////////////////////////////////////////////////////////////////////
void split (
std::vector<std::string>& results,
const std::string& input,
const std::string& delimiter)
{
results.clear ();
std::string::size_type length = delimiter.length ();
std::string::size_type start = 0;
std::string::size_type i;
while ((i = input.find (delimiter, start)) != std::string::npos)
{
results.push_back (input.substr (start, i - start));
start = i + length;
}
if (input.length ())
results.push_back (input.substr (start));
}
////////////////////////////////////////////////////////////////////////////////
void join (
std::string& result,
const std::string& separator,
const std::vector<std::string>& items)
{
std::stringstream s;
unsigned int size = items.size ();
for (unsigned int i = 0; i < size; ++i)
{
s << items[i];
if (i < size - 1)
s << separator;
}
result = s.str ();
}
////////////////////////////////////////////////////////////////////////////////
void join (
std::string& result,
const std::string& separator,
const std::vector<int>& items)
{
std::stringstream s;
unsigned int size = items.size ();
for (unsigned int i = 0; i < size; ++i)
{
s << items[i];
if (i < size - 1)
s << separator;
}
result = s.str ();
}
////////////////////////////////////////////////////////////////////////////////
// Remove enclosing balanced quotes. Assumes trimmed text.
std::string unquoteText (const std::string& input)
{
std::string output = input;
if (output.length () > 1)
{
char quote = output[0];
if ((quote == '\'' || quote == '"') &&
output[output.length () - 1] == quote)
return output.substr (1, output.length () - 2);
}
return output;
}
////////////////////////////////////////////////////////////////////////////////
int longestLine (const std::string& input)
{
int longest = 0;
int length = 0;
std::string::size_type i = 0;
int character;
while ((character = utf8_next_char (input, i)))
{
if (character == '\n')
{
if (length > longest)
longest = length;
length = 0;
}
else
length += mk_wcwidth (character);
}
if (length > longest)
longest = length;
return longest;
}
////////////////////////////////////////////////////////////////////////////////
// Break UTF8 text into chunks no more than width characters.
bool extractLine (
std::string& line,
const std::string& text,
int width,
bool hyphenate,
unsigned int& offset)
{
// Terminate processing.
if (offset >= text.length ())
return false;
int line_length {0};
int character {0};
std::string::size_type lastWordEnd {std::string::npos};
bool something {false};
std::string::size_type cursor {offset};
std::string::size_type prior_cursor {offset};
while ((character = utf8_next_char (text, cursor)))
{
// Premature EOL.
if (character == '\n')
{
line = text.substr (offset, prior_cursor - offset);
offset = cursor;
return true;
}
if (! Lexer::isWhitespace (character))
{
something = true;
if (! text[cursor] || Lexer::isWhitespace (text[cursor]))
lastWordEnd = prior_cursor;
}
line_length += mk_wcwidth (character);
if (line_length >= width)
{
// Backtrack to previous word end.
if (lastWordEnd != std::string::npos)
{
// Eat one WS after lastWordEnd.
std::string::size_type lastBreak = lastWordEnd;
utf8_next_char (text, lastBreak);
// Position offset at following char.
std::string::size_type nextStart = lastBreak;
utf8_next_char (text, nextStart);
line = text.substr (offset, lastBreak - offset);
offset = nextStart;
return true;
}
// No backtrack, possible hyphenation.
else if (hyphenate)
{
line = text.substr (offset, prior_cursor - offset) + '-';
offset = prior_cursor;
return true;
}
// No hyphenation, just truncation.
else
{
line = text.substr (offset, cursor - offset);
offset = cursor;
return true;
}
}
// Hindsight.
prior_cursor = cursor;
}
// Residual text.
if (something)
{
line = text.substr (offset, cursor - offset);
offset = cursor;
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
const char* optionalBlankLine ()
{