wilderjds
/
ncmpcpp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

strbuffer: fix indentation

Browse Source
master
Andrzej Rybczak 14 years ago
parent 6449cc5f2c
commit e61d0a4958
1 changed files with 237 additions and 230 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 467
      src/strbuffer.h

467
src/strbuffer.h
Unescape View File

@ -27,241 +27,244 @@
#include <list>
namespace NCurses
namespace NCurses {
/// Buffer template class that can store text along with its
/// format attributes. The content can be easily printed to
/// window or taken as raw string at any time.
///
template <typename C> class basic_buffer
{
/// Buffer template class that can store text along with its
/// format attributes. The content can be easily printed to
/// window or taken as raw string at any time.
/// Struct used for storing information about
/// one color/format flag along with its position
///
template <typename C> class basic_buffer
struct FormatPos
{
/// Struct used for storing information about
/// one color/format flag along with its position
///
struct FormatPos
size_t Position;
short Value;
bool operator<(const FormatPos &f)
{
size_t Position;
short Value;
bool operator<(const FormatPos &f)
{
return Position < f.Position;
}
bool operator==(const FormatPos &f)
{
return Position == f.Position && Value == f.Value;
}
};
return Position < f.Position;
}
bool operator==(const FormatPos &f)
{
return Position == f.Position && Value == f.Value;
}
};
/// Internal buffer for storing raw text
///
std::basic_string<C> itsString;
/// List used for storing formatting informations
///
std::list<FormatPos> itsFormat;
/// Pointer to temporary string
/// @see SetTemp()
///
std::basic_string<C> *itsTempString;
public:
/// Constructs an empty buffer
///
basic_buffer() : itsTempString(0) { }
/// Constructs a buffer from the existed one
/// @param b copied buffer
///
basic_buffer(const basic_buffer &b);
/// @return raw content of the buffer without formatting informations
///
const std::basic_string<C> &Str() const;
/// Searches for given string in buffer and sets format/color at the
/// beginning and end of it using val_b and val_e flags accordingly
/// @param val_b flag set at the beginning of found occurence of string
/// @param s string that function seaches for
/// @param val_e flag set at the end of found occurence of string
/// @param case_sensitive indicates whether algorithm should care about case sensitivity
/// @param for_each indicates whether function searches through whole buffer and sets
/// the format for all occurences of given string or stops after the first one
/// @return true if at least one occurence of the string was found, false otherwise
///
bool SetFormatting(short val_b, std::basic_string<C> s, short val_e,
bool case_sensitive, bool for_each = 1);
/// Internal buffer for storing raw text
/// Searches for given string in buffer and removes given
/// format/color from the beginning and end of its occurence
/// @param val_b flag to be removed from the beginning of the string
/// @param s string that function seaches for
/// @param val_e flag to be removed from the end of the string
/// @param case_sensitive indicates whether algorithm should care about case sensitivity
/// @param for_each indicates whether function searches through whole buffer and removes
/// given format from all occurences of given string or stops after the first one
///
std::basic_string<C> itsString;
void RemoveFormatting(short val_b, std::basic_string<C> pattern, short val_e,
bool case_sensitive, bool for_each = 1);
/// List used for storing formatting informations
/// Removes all formating applied to string in buffer.
///
std::list<FormatPos> itsFormat;
void RemoveFormatting();
/// Pointer to temporary string
/// @see SetTemp()
/// Sets the pointer to string, that will be passed in operator<<() to window
/// object instead of the internal buffer. This is useful if you took the content
/// of the buffer, modified it somehow and want to print the modified version instead
/// of the original one, but with the original formatting informations. Note that after
/// you're done with the printing etc., this pointer has to be set to null.
/// @param tmp address of the temporary string
///
std::basic_string<C> *itsTempString;
void SetTemp(std::basic_string<C> *tmp);
public:
/// Constructs an empty buffer
///
basic_buffer() : itsTempString(0) { }
/// Constructs a buffer from the existed one
/// @param b copied buffer
///
basic_buffer(const basic_buffer &b);
/// @return raw content of the buffer without formatting informations
///
const std::basic_string<C> &Str() const;
/// Searches for given string in buffer and sets format/color at the
/// beginning and end of it using val_b and val_e flags accordingly
/// @param val_b flag set at the beginning of found occurence of string
/// @param s string that function seaches for
/// @param val_e flag set at the end of found occurence of string
/// @param case_sensitive indicates whether algorithm should care about case sensitivity
/// @param for_each indicates whether function searches through whole buffer and sets
/// the format for all occurences of given string or stops after the first one
/// @return true if at least one occurence of the string was found, false otherwise
///
bool SetFormatting(short val_b, std::basic_string<C> s, short val_e,
bool case_sensitive, bool for_each = 1);
/// Searches for given string in buffer and removes given
/// format/color from the beginning and end of its occurence
/// @param val_b flag to be removed from the beginning of the string
/// @param s string that function seaches for
/// @param val_e flag to be removed from the end of the string
/// @param case_sensitive indicates whether algorithm should care about case sensitivity
/// @param for_each indicates whether function searches through whole buffer and removes
/// given format from all occurences of given string or stops after the first one
///
void RemoveFormatting(short val_b, std::basic_string<C> pattern, short val_e,
bool case_sensitive, bool for_each = 1);
/// Removes all formating applied to string in buffer.
///
void RemoveFormatting();
/// Sets the pointer to string, that will be passed in operator<<() to window
/// object instead of the internal buffer. This is useful if you took the content
/// of the buffer, modified it somehow and want to print the modified version instead
/// of the original one, but with the original formatting informations. Note that after
/// you're done with the printing etc., this pointer has to be set to null.
/// @param tmp address of the temporary string
///
void SetTemp(std::basic_string<C> *tmp);
/// Prints to window object given part of the string, loading all needed formatting info
/// and cleaning up after. The main goal of this function is to provide interface for
/// colorful scrollers.
/// @param w window object that we want to print to
/// @param start_pos reference to start position of the string. note that this variable is
/// incremented by one after each call or set to 0 if end of string is reached
/// @param width width of the string to be printed
/// @param separator additional text to be placed between the end and the beginning of
/// the string
///
void Write(Window &w, size_t &start_pos, size_t width,
/// Prints to window object given part of the string, loading all needed formatting info
/// and cleaning up after. The main goal of this function is to provide interface for
/// colorful scrollers.
/// @param w window object that we want to print to
/// @param start_pos reference to start position of the string. note that this variable is
/// incremented by one after each call or set to 0 if end of string is reached
/// @param width width of the string to be printed
/// @param separator additional text to be placed between the end and the beginning of
/// the string
///
void Write(Window &w, size_t &start_pos, size_t width,
const std::basic_string<C> &separator) const;
/// Clears the content of the buffer and its formatting informations
///
void Clear();
basic_buffer<C> &operator<<(int n)
{
itsString += intTo< std::basic_string<C> >::apply(n);
return *this;
}
basic_buffer<C> &operator<<(long int n)
{
itsString += longIntTo< std::basic_string<C> >::apply(n);
return *this;
}
basic_buffer<C> &operator<<(unsigned int n)
{
itsString += unsignedIntTo< std::basic_string<C> >::apply(n);
return *this;
}
basic_buffer<C> &operator<<(unsigned long int n)
{
itsString += unsignedLongIntTo< std::basic_string<C> >::apply(n);
return *this;
}
basic_buffer<C> &operator<<(char c)
{
itsString += c;
return *this;
}
basic_buffer<C> &operator<<(wchar_t wc)
{
itsString += wc;
return *this;
}
basic_buffer<C> &operator<<(const C *s)
{
itsString += s;
return *this;
}
basic_buffer<C> &operator<<(const std::basic_string<C> &s)
{
itsString += s;
return *this;
}
/// Handles colors
/// @return reference to itself
///
basic_buffer<C> &operator<<(Color color);
/// Handles format flags
/// @return reference to itself
///
basic_buffer<C> &operator<<(Format f);
/// Handles copying one buffer to another using operator<<()
/// @param buf buffer to be copied
/// @return reference to itself
///
basic_buffer<C> &operator<<(const basic_buffer<C> &buf);
/// Friend operator that handles printing
/// the content of buffer to window object
friend Window &operator<<(Window &w, const basic_buffer<C> &buf)
/// Clears the content of the buffer and its formatting informations
///
void Clear();
basic_buffer<C> &operator<<(int n)
{
itsString += intTo< std::basic_string<C> >::apply(n);
return *this;
}
basic_buffer<C> &operator<<(long int n)
{
itsString += longIntTo< std::basic_string<C> >::apply(n);
return *this;
}
basic_buffer<C> &operator<<(unsigned int n)
{
itsString += unsignedIntTo< std::basic_string<C> >::apply(n);
return *this;
}
basic_buffer<C> &operator<<(unsigned long int n)
{
itsString += unsignedLongIntTo< std::basic_string<C> >::apply(n);
return *this;
}
basic_buffer<C> &operator<<(char c)
{
itsString += c;
return *this;
}
basic_buffer<C> &operator<<(wchar_t wc)
{
itsString += wc;
return *this;
}
basic_buffer<C> &operator<<(const C *s)
{
itsString += s;
return *this;
}
basic_buffer<C> &operator<<(const std::basic_string<C> &s)
{
itsString += s;
return *this;
}
/// Handles colors
/// @return reference to itself
///
basic_buffer<C> &operator<<(Color color);
/// Handles format flags
/// @return reference to itself
///
basic_buffer<C> &operator<<(Format f);
/// Handles copying one buffer to another using operator<<()
/// @param buf buffer to be copied
/// @return reference to itself
///
basic_buffer<C> &operator<<(const basic_buffer<C> &buf);
/// Friend operator that handles printing
/// the content of buffer to window object
friend Window &operator<<(Window &w, const basic_buffer<C> &buf)
{
const std::basic_string<C> &s = buf.itsTempString ? *buf.itsTempString : buf.itsString;
if (buf.itsFormat.empty())
w << s;
else
{
const std::basic_string<C> &s = buf.itsTempString ? *buf.itsTempString : buf.itsString;
if (buf.itsFormat.empty())
w << s;
else
std::basic_string<C> tmp;
auto b = buf.itsFormat.begin(), e = buf.itsFormat.end();
for (size_t i = 0; i < s.length() || b != e; ++i)
{
std::basic_string<C> tmp;
auto b = buf.itsFormat.begin(), e = buf.itsFormat.end();
for (size_t i = 0; i < s.length() || b != e; ++i)
while (b != e && i == b->Position)
{
while (b != e && i == b->Position)
if (!tmp.empty())
{
if (!tmp.empty())
{
w << tmp;
tmp.clear();
}
buf.LoadAttribute(w, b->Value);
b++;
w << tmp;
tmp.clear();
}
if (i < s.length())
tmp += s[i];
buf.LoadAttribute(w, b->Value);
b++;
}
if (!tmp.empty())
w << tmp;
if (i < s.length())
tmp += s[i];
}
return w;
if (!tmp.empty())
w << tmp;
}
private:
/// Loads an attribute to given window object
/// @param w window object we want to load attribute to
/// @param value value of attribute to be loaded
///
void LoadAttribute(Window &w, short value) const;
};
/// Standard buffer that uses narrow characters
///
typedef basic_buffer<char> Buffer;
/// Standard buffer that uses wide characters
///
typedef basic_buffer<wchar_t> WBuffer;
}
return w;
}
private:
/// Loads an attribute to given window object
/// @param w window object we want to load attribute to
/// @param value value of attribute to be loaded
///
void LoadAttribute(Window &w, short value) const;
};
/// Standard buffer that uses narrow characters
///
typedef basic_buffer<char> Buffer;
template <typename C> NCurses::basic_buffer<C>::basic_buffer(const basic_buffer &b) : itsString(b.itsString), itsFormat(b.itsFormat), itsTempString(b.itsTempString) { }
/// Standard buffer that uses wide characters
///
typedef basic_buffer<wchar_t> WBuffer;
template <typename C> const std::basic_string<C> &NCurses::basic_buffer<C>::Str() const
template <typename C> basic_buffer<C>::basic_buffer(const basic_buffer &b)
: itsString(b.itsString), itsFormat(b.itsFormat), itsTempString(b.itsTempString) { }
template <typename C> const std::basic_string<C> &basic_buffer<C>::Str() const
{
return itsString;
}
template <typename C> bool NCurses::basic_buffer<C>::SetFormatting( short val_b,
std::basic_string<C> s,
short val_e,
bool case_sensitive,
bool for_each
)
template <typename C> bool basic_buffer<C>::SetFormatting(
short val_b,
std::basic_string<C> s,
short val_e,
bool case_sensitive,
bool for_each
)
{
if (s.empty())
return false;
@ -290,12 +293,13 @@ template <typename C> bool NCurses::basic_buffer<C>::SetFormatting( short val_b,
return result;
}
template <typename C> void NCurses::basic_buffer<C>::RemoveFormatting( short val_b,
std::basic_string<C> pattern,
short val_e,
bool case_sensitive,
bool for_each
)
template <typename C> void basic_buffer<C>::RemoveFormatting(
short val_b,
std::basic_string<C> pattern,
short val_e,
bool case_sensitive,
bool for_each
)
{
if (pattern.empty())
return;
@ -320,21 +324,22 @@ template <typename C> void NCurses::basic_buffer<C>::RemoveFormatting( short val
}
}
template <typename C> void NCurses::basic_buffer<C>::RemoveFormatting()
template <typename C> void basic_buffer<C>::RemoveFormatting()
{
itsFormat.clear();
}
template <typename C> void NCurses::basic_buffer<C>::SetTemp(std::basic_string<C> *tmp)
template <typename C> void basic_buffer<C>::SetTemp(std::basic_string<C> *tmp)
{
itsTempString = tmp;
}
template <typename C> void NCurses::basic_buffer<C>::Write( Window &w,
size_t &start_pos,
size_t width,
const std::basic_string<C> &separator
) const
template <typename C> void basic_buffer<C>::Write(
Window &w,
size_t &start_pos,
size_t width,
const std::basic_string<C> &separator
) const
{
std::basic_string<C> s = itsString;
size_t len = Window::Length(s);
@ -387,21 +392,21 @@ template <typename C> void NCurses::basic_buffer<C>::Write( Window &w,
w << *this;
}
template <typename C> void NCurses::basic_buffer<C>::Clear()
template <typename C> void basic_buffer<C>::Clear()
{
itsString.clear();
itsFormat.clear();
}
template <typename C> void NCurses::basic_buffer<C>::LoadAttribute(Window &w, short value) const
template <typename C> void basic_buffer<C>::LoadAttribute(Window &w, short value) const
{
if (value < NCurses::fmtNone)
w << NCurses::Color(value);
if (value < fmtNone)
w << Color(value);
else
w << NCurses::Format(value);
w << Format(value);
}
template <typename C> NCurses::basic_buffer<C> &NCurses::basic_buffer<C>::operator<<(Color color)
template <typename C> basic_buffer<C> &basic_buffer<C>::operator<<(Color color)
{
FormatPos f;
f.Position = itsString.length();
@ -410,12 +415,12 @@ template <typename C> NCurses::basic_buffer<C> &NCurses::basic_buffer<C>::operat
return *this;
}
template <typename C> NCurses::basic_buffer<C> &NCurses::basic_buffer<C>::operator<<(Format f)
template <typename C> basic_buffer<C> &basic_buffer<C>::operator<<(Format f)
{
return operator<<(Color(f));
}
template <typename C> NCurses::basic_buffer<C> &NCurses::basic_buffer<C>::operator<<(const NCurses::basic_buffer<C> &buf)
template <typename C> basic_buffer<C> &basic_buffer<C>::operator<<(const basic_buffer<C> &buf)
{
size_t length = itsString.length();
itsString += buf.itsString;
@ -427,4 +432,6 @@ template <typename C> NCurses::basic_buffer<C> &NCurses::basic_buffer<C>::operat
return *this;
}
}
#endif

Write Preview
Loading…
Cancel
Save