Ivan Pelipenko
42925122cb
source tree changed detached PIConsole and PIScreen* in "pip_console" library
302 lines
11 KiB
C++
302 lines
11 KiB
C++
/*! \file picout.h
|
|
* \brief Universal output to console class
|
|
*/
|
|
/*
|
|
PIP - Platform Independent Primitives
|
|
Universal output to console class
|
|
Ivan Pelipenko peri4ko@yandex.ru
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef PICOUT_H
|
|
#define PICOUT_H
|
|
|
|
#include "piincludes.h"
|
|
|
|
#ifdef DOXYGEN
|
|
|
|
//! \brief Macro used for conditional (piDebug) output to PICout
|
|
# define piCout
|
|
|
|
//! \relatesalso PIObject \brief Macro used for conditional (piDebug and PIObject::debug()) output to PICout for subclasses of PIObject
|
|
# define piCoutObj
|
|
|
|
#else
|
|
# define piCout PICout(piDebug)
|
|
# define piCoutObj PICout(piDebug && debug()) << (PIStringAscii("[") + className() + PIStringAscii(" \"") + name() + PIStringAscii("\"]"))
|
|
#endif
|
|
|
|
|
|
class PIObject;
|
|
|
|
|
|
//! \brief Namespace contains enums controlled PICout
|
|
namespace PICoutManipulators {
|
|
|
|
//! \brief Enum contains special characters
|
|
enum PIP_EXPORT PICoutSpecialChar {
|
|
Null /*! Null-character, '\\0' */,
|
|
NewLine /*! New line character, '\\n' */,
|
|
Tab /*! Tab character, '\\t' */,
|
|
Esc /*! Escape character, '\\e' */,
|
|
Quote /*! Quote character, '"' */
|
|
};
|
|
|
|
//! \brief Enum contains immediate action
|
|
enum PIP_EXPORT PICoutAction {
|
|
Flush /*! Flush the output */,
|
|
Backspace /*! Remove last symbol */,
|
|
ShowCursor /*! Show cursor */,
|
|
HideCursor /*! Hide cursor */,
|
|
ClearLine /*! Clear current line */,
|
|
ClearScreen /*! Clear the screen */,
|
|
SaveContol /*! Save control flags, equivalent to \a saveControl() */,
|
|
RestoreControl /*! Restore control flags, equivalent to \a restoreControl() */
|
|
};
|
|
|
|
//! \brief Enum contains control of PICout
|
|
enum PIP_EXPORT PICoutControl {
|
|
AddNone /*! No controls */ = 0x0,
|
|
AddSpaces /*! Spaces will be appear after each output */ = 0x1,
|
|
AddNewLine /*! New line will be appear after all output */ = 0x2,
|
|
AddQuotes /*! Each string will be quoted */ = 0x4,
|
|
DefaultControls /*! Default controls */ = AddSpaces | AddNewLine,
|
|
AddAll /*! All controls */ = 0xFF,
|
|
NoLock /*! Don`t use mutex for output */ = 0x100,
|
|
};
|
|
|
|
//! \brief Enum contains output format
|
|
enum PIP_EXPORT PICoutFormat {
|
|
Bin /*! Binary representation of integers */ = 0x01,
|
|
Oct /*! Octal representation of integers */ = 0x02,
|
|
Dec /*! Decimal representation of integers */ = 0x04,
|
|
Hex /*! Hexadecimal representation of integers */ = 0x08,
|
|
Bold /*! Bold */ = 0x10,
|
|
Faint /*! */ = 0x20,
|
|
Italic /*! */ = 0x40,
|
|
Underline /*! Underline */ = 0x80,
|
|
Blink /*! Blink */ = 0x100,
|
|
Black /*! Black font */ = 0x400,
|
|
Red /*! Red font */ = 0x800,
|
|
Green /*! Green font */ = 0x1000,
|
|
Blue /*! Blue font */ = 0x2000,
|
|
Yellow /*! Yellow font */ = 0x4000,
|
|
Magenta /*! Magenta font */ = 0x8000,
|
|
Cyan /*! Cyan font */ = 0x10000,
|
|
White /*! White font */ = 0x20000,
|
|
BackBlack /*! Black background */ = 0x40000,
|
|
BackRed /*! Red background */ = 0x80000,
|
|
BackGreen /*! Green background */ = 0x100000,
|
|
BackBlue /*! Blue background */ = 0x200000,
|
|
BackYellow /*! Yellow background */ = 0x400000,
|
|
BackMagenta /*! Magenta background */ = 0x800000,
|
|
BackCyan /*! Cyan background */ = 0x1000000,
|
|
BackWhite /*! White background */ = 0x2000000,
|
|
Default /*! Default format */ = 0x4000000
|
|
};
|
|
|
|
typedef PIFlags<PICoutControl> PICoutControls;
|
|
}
|
|
|
|
|
|
|
|
class PIP_EXPORT PICout {
|
|
public:
|
|
//! Default constructor with default features (AddSpaces and AddNewLine)
|
|
PICout(PIFlags<PICoutManipulators::PICoutControl> controls = PICoutManipulators::DefaultControls);
|
|
PICout(PICoutManipulators::PICoutControl control = PICoutManipulators::DefaultControls);
|
|
|
|
//! Construct with default features (AddSpaces and AddNewLine), but if \"active\" is false does nothing
|
|
PICout(bool active);
|
|
|
|
//! Construct with external buffer and id "id". See \a Notifier for details
|
|
PICout(PIString * buffer, int id = 0, PIFlags<PICoutManipulators::PICoutControl> controls = PICoutManipulators::AddSpaces | PICoutManipulators::AddNewLine);
|
|
|
|
PICout(const PICout & other);
|
|
|
|
~PICout();
|
|
|
|
class Notifier {
|
|
public:
|
|
static Notifier * instance();
|
|
static PIObject * object();
|
|
private:
|
|
Notifier();
|
|
PIObject * o;
|
|
};
|
|
|
|
//! \brief Enum contains output devices of PICout
|
|
enum OutputDevice {
|
|
NoDevices /** PICout is disabled */ = 0x0,
|
|
StdOut /** Standard console output */ = 0x1,
|
|
Buffer /** Internal buffer */ = 0x2,
|
|
AllDevices /** All */ = 0xFFFF,
|
|
};
|
|
|
|
typedef PIFlags<OutputDevice> OutputDevices;
|
|
|
|
//! Output operator for strings with <tt>"const char * "</tt> type
|
|
PICout operator <<(const char * v);
|
|
|
|
//! Output operator for strings with <tt>"std::string"</tt> type
|
|
//PICout operator <<(const std::string & v);
|
|
|
|
//! Output operator for boolean values
|
|
PICout operator <<(const bool v);
|
|
|
|
//! Output operator for <tt>"char"</tt> values
|
|
PICout operator <<(const char v);
|
|
|
|
//! Output operator for <tt>"unsigned char"</tt> values
|
|
PICout operator <<(const uchar v);
|
|
|
|
//! Output operator for <tt>"short"</tt> values
|
|
PICout operator <<(const short v);
|
|
|
|
//! Output operator for <tt>"unsigned short"</tt> values
|
|
PICout operator <<(const ushort v);
|
|
|
|
//! Output operator for <tt>"int"</tt> values
|
|
PICout operator <<(const int v);
|
|
|
|
//! Output operator for <tt>"unsigned int"</tt> values
|
|
PICout operator <<(const uint v);
|
|
|
|
//! Output operator for <tt>"long"</tt> values
|
|
PICout operator <<(const long v);
|
|
|
|
//! Output operator for <tt>"unsigned long"</tt> values
|
|
PICout operator <<(const ulong v);
|
|
|
|
//! Output operator for <tt>"long long"</tt> values
|
|
PICout operator <<(const llong v);
|
|
|
|
//! Output operator for <tt>"unsigned long long"</tt> values
|
|
PICout operator <<(const ullong v);
|
|
|
|
//! Output operator for <tt>"float"</tt> values
|
|
PICout operator <<(const float v);
|
|
|
|
//! Output operator for <tt>"double"</tt> values
|
|
PICout operator <<(const double v);
|
|
|
|
//! Output operator for pointers
|
|
PICout operator <<(const void * v);
|
|
|
|
//! Output operator for PIObject and ancestors
|
|
PICout operator <<(const PIObject * v);
|
|
|
|
//! Output operator for \a PICoutSpecialChar values
|
|
PICout operator <<(const PICoutManipulators::PICoutSpecialChar v);
|
|
|
|
//! Output operator for \a PIFlags<PICoutFormat> values
|
|
PICout operator <<(const PIFlags<PICoutManipulators::PICoutFormat> & v) {
|
|
if (v[PICoutManipulators::Bin]) cnb_ = 2;
|
|
if (v[PICoutManipulators::Oct]) cnb_ = 8;
|
|
if (v[PICoutManipulators::Dec]) cnb_ = 10;
|
|
if (v[PICoutManipulators::Hex]) cnb_ = 16;
|
|
if (v[PICoutManipulators::Bold]) applyFormat(PICoutManipulators::Bold);
|
|
if (v[PICoutManipulators::Faint]) applyFormat(PICoutManipulators::Faint);
|
|
if (v[PICoutManipulators::Italic]) applyFormat(PICoutManipulators::Italic);
|
|
if (v[PICoutManipulators::Underline]) applyFormat(PICoutManipulators::Underline);
|
|
if (v[PICoutManipulators::Blink]) applyFormat(PICoutManipulators::Blink);
|
|
if (v[PICoutManipulators::Black]) applyFormat(PICoutManipulators::Black);
|
|
if (v[PICoutManipulators::Red]) applyFormat(PICoutManipulators::Red);
|
|
if (v[PICoutManipulators::Green]) applyFormat(PICoutManipulators::Green);
|
|
if (v[PICoutManipulators::Blue]) applyFormat(PICoutManipulators::Blue);
|
|
if (v[PICoutManipulators::Yellow]) applyFormat(PICoutManipulators::Yellow);
|
|
if (v[PICoutManipulators::Magenta]) applyFormat(PICoutManipulators::Magenta);
|
|
if (v[PICoutManipulators::Cyan]) applyFormat(PICoutManipulators::Cyan);
|
|
if (v[PICoutManipulators::White]) applyFormat(PICoutManipulators::White);
|
|
if (v[PICoutManipulators::BackBlack]) applyFormat(PICoutManipulators::BackBlack);
|
|
if (v[PICoutManipulators::BackRed]) applyFormat(PICoutManipulators::BackRed);
|
|
if (v[PICoutManipulators::BackGreen]) applyFormat(PICoutManipulators::BackGreen);
|
|
if (v[PICoutManipulators::BackBlue]) applyFormat(PICoutManipulators::BackBlue);
|
|
if (v[PICoutManipulators::BackYellow]) applyFormat(PICoutManipulators::BackYellow);
|
|
if (v[PICoutManipulators::BackMagenta]) applyFormat(PICoutManipulators::BackMagenta);
|
|
if (v[PICoutManipulators::BackCyan]) applyFormat(PICoutManipulators::BackCyan);
|
|
if (v[PICoutManipulators::BackWhite]) applyFormat(PICoutManipulators::BackWhite);
|
|
if (v[PICoutManipulators::Default]) applyFormat(PICoutManipulators::Default);
|
|
return *this;
|
|
}
|
|
|
|
//! Output operator for \a PICoutFormat values
|
|
PICout operator <<(const PICoutManipulators::PICoutFormat v) {
|
|
switch (v) {
|
|
case PICoutManipulators::Bin: cnb_ = 2; break;
|
|
case PICoutManipulators::Oct: cnb_ = 8; break;
|
|
case PICoutManipulators::Dec: cnb_ = 10; break;
|
|
case PICoutManipulators::Hex: cnb_ = 16; break;
|
|
default: applyFormat(v);
|
|
};
|
|
return *this;
|
|
}
|
|
|
|
//! Do some action
|
|
PICout operator <<(const PICoutManipulators::PICoutAction v);
|
|
|
|
//! Set control flag "c" is "on" state
|
|
PICout & setControl(PICoutManipulators::PICoutControl c, bool on = true) {co_.setFlag(c, on); return *this;}
|
|
|
|
//! Set control flags "c" and if "save" exec \a saveControl()
|
|
PICout & setControl(PICoutManipulators::PICoutControls c, bool save = false) {if (save) saveControl(); co_ = c; return *this;}
|
|
|
|
//! Save control flags to internal stack \sa \a restoreControl()
|
|
PICout & saveControl();
|
|
|
|
//! Restore control flags from internal stack \sa \a saveControl()
|
|
PICout & restoreControl();
|
|
|
|
/*! \brief Conditional put space character to output
|
|
* \details If it is not a first output and control \a AddSpaces is set
|
|
* space character is put \sa \a quote(), \a newLine() */
|
|
PICout & space();
|
|
|
|
/*! \brief Conditional put quote character to output
|
|
* \details If control \a AddQuotes is set
|
|
* quote character is put \sa \a space(), \a newLine() */
|
|
PICout & quote();
|
|
|
|
/*! \brief Conditional put new line character to output
|
|
* \details If control \a AddNewLine is set
|
|
* new line character is put \sa \a space(), \a quote() */
|
|
PICout & newLine();
|
|
|
|
static bool setBufferActive(bool on, bool clear = false);
|
|
static bool isBufferActive();
|
|
static PIString buffer(bool clear = false);
|
|
static void clearBuffer();
|
|
|
|
static bool setOutputDevice(OutputDevice d, bool on = true);
|
|
static void setOutputDevices(OutputDevices d);
|
|
static bool isOutputDeviceActive(OutputDevice d);
|
|
|
|
static PIMutex & __mutex__();
|
|
static PIString & __string__();
|
|
|
|
private:
|
|
void init();
|
|
void applyFormat(PICoutManipulators::PICoutFormat f);
|
|
|
|
static OutputDevices devs;
|
|
PRIVATE_DECLARATION
|
|
bool fo_, cc_, fc_, act_;
|
|
int cnb_, attr_, id_;
|
|
PIString * buffer_;
|
|
PICoutManipulators::PICoutControls co_;
|
|
};
|
|
|
|
#endif // PICOUT_H
|