SHS/pip
4
3
Fork 0
Code Issues 67 Pull Requests 1 Actions Releases Wiki Activity

pivariant, enum, tiny format

Browse Source
This commit is contained in:
Пелипенко Иван
2022-12-13 21:44:06 +03:00
parent 9d9357b0ca
commit c74ba871cd
15 changed files with 1914 additions and 851 deletions
Download Patch File Download Diff File Expand all files Collapse all files

428
libs/main/console/pikbdlistener.cpp
View File

@@ -16,13 +16,14 @@
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/>.
*/
#include "piincludes_p.h"
#include "pikbdlistener.h"
#include "piincludes_p.h"
#ifndef WINDOWS
# include <termios.h>
#else
# include <wingdi.h>
# include <wincon.h>
# include <wingdi.h>
#endif
/** \class PIKbdListener
@@ -47,80 +48,82 @@ PIKbdListener * PIKbdListener::_object = 0;
#ifndef WINDOWS
// unix
const PIKbdListener::EscSeq PIKbdListener::esc_seq[] = {
{"OA", PIKbdListener::UpArrow, 0, 0 , 1 },
{"OA", PIKbdListener::UpArrow, 4, 0 , 0 },
{"[1A", PIKbdListener::UpArrow, 0, 0 , 0 },
{"[A", PIKbdListener::UpArrow, 0, vt_all , 0 },
{"OB", PIKbdListener::DownArrow, 0, 0 , 1 },
{"OB", PIKbdListener::DownArrow, 4, 0 , 0 },
{"[1B", PIKbdListener::DownArrow, 0, 0 , 0 },
{"[B", PIKbdListener::DownArrow, 0, vt_all , 0 },
{"OC", PIKbdListener::RightArrow, 0, 0 , 1 },
{"OC", PIKbdListener::RightArrow, 4, 0 , 0 },
{"[1C", PIKbdListener::RightArrow, 0, 0 , 0 },
{"[C", PIKbdListener::RightArrow, 0, vt_all , 0 },
{"OD", PIKbdListener::LeftArrow, 0, 0 , 1 },
{"OD", PIKbdListener::LeftArrow, 4, 0 , 0 },
{"[1D", PIKbdListener::LeftArrow, 0, 0 , 0 },
{"[D", PIKbdListener::LeftArrow, 0, vt_all , 0 },
{"[H", PIKbdListener::Home, 0, vt_xterm , 0 },
{"[1H", PIKbdListener::Home, 0, 0 , 0 },
{"OH", PIKbdListener::Home, 0, 0 , 1 },
{"[1~", PIKbdListener::Home, 0, vt_linux , 0 },
{"[F", PIKbdListener::End, 0, vt_xterm , 0 },
{"[1F", PIKbdListener::End, 0, 0 , 0 },
{"OF", PIKbdListener::End, 0, 0 , 1 },
{"[4~", PIKbdListener::End, 0, vt_linux , 0 },
{"[2~", PIKbdListener::Insert, 0, vt_all , 0 },
{"[3~", PIKbdListener::Delete, 0, vt_all , 0 },
{"[5~", PIKbdListener::PageUp, 0, vt_all , 0 },
{"[6~", PIKbdListener::PageDown, 0, vt_all , 0 },
{"[Z", PIKbdListener::Tab, 1, vt_xterm , 0 },
{"OP", PIKbdListener::F1, 0, vt_xterm , 0 },
{"[[A", PIKbdListener::F1, 0, vt_linux , 0 },
{"[11~", PIKbdListener::F1, 0, 0 , 0 },
{"[25~", PIKbdListener::F1, 1, vt_linux , 0 },
{"OQ", PIKbdListener::F2, 0, vt_xterm , 0 },
{"[[B", PIKbdListener::F2, 0, vt_linux , 0 },
{"[12~", PIKbdListener::F2, 0, 0 , 0 },
{"[26~", PIKbdListener::F2, 1, vt_linux , 0 },
{"OR", PIKbdListener::F3, 0, vt_xterm , 0 },
{"[[C", PIKbdListener::F3, 0, vt_linux , 0 },
{"[13~", PIKbdListener::F3, 0, 0 , 0 },
{"[28~", PIKbdListener::F3, 1, vt_linux , 0 },
{"OS", PIKbdListener::F4, 0, vt_xterm , 0 },
{"[[D", PIKbdListener::F4, 0, vt_linux , 0 },
{"[14~", PIKbdListener::F4, 0, 0 , 0 },
{"[29~", PIKbdListener::F4, 1, vt_linux , 0 },
{"[[E", PIKbdListener::F5, 0, vt_linux , 0 },
{"OT", PIKbdListener::F5, 0, 0 , 0 },
{"[15~", PIKbdListener::F5, 0, vt_xterm , 0 },
{"[31~", PIKbdListener::F5, 1, vt_linux , 0 },
{"OU", PIKbdListener::F6, 0, 0 , 0 },
{"[17~", PIKbdListener::F6, 0, vt_all , 0 },
{"[32~", PIKbdListener::F6, 1, vt_linux , 0 },
{"OV", PIKbdListener::F7, 0, 0 , 0 },
{"[18~", PIKbdListener::F7, 0, vt_all , 0 },
{"[33~", PIKbdListener::F7, 1, vt_linux , 0 },
{"OW", PIKbdListener::F8, 0, 0 , 0 },
{"[19~", PIKbdListener::F8, 0, vt_all , 0 },
{"[34~", PIKbdListener::F8, 1, vt_linux , 0 },
{"OX", PIKbdListener::F9, 0, 0 , 0 },
{"[20~", PIKbdListener::F9, 0, vt_all , 0 },
{"[35~", PIKbdListener::F9, 1, vt_linux , 0 },
{"OY", PIKbdListener::F10, 0, 0 , 0 },
{"[21~", PIKbdListener::F10, 0, vt_all , 0 },
{"[36~", PIKbdListener::F10, 1, vt_linux , 0 },
{"OZ", PIKbdListener::F11, 0, 0 , 0 },
{"[23~", PIKbdListener::F11, 0, vt_all , 0 },
{"O[", PIKbdListener::F12, 0, 0 , 0 },
{"[24~", PIKbdListener::F12, 0, vt_all , 0 },
// End
{0, 0, 0, 0, 0},
{"OA", PIKbdListener::UpArrow, 0, 0, 1},
{"OA", PIKbdListener::UpArrow, 4, 0, 0},
{"[1A", PIKbdListener::UpArrow, 0, 0, 0},
{"[A", PIKbdListener::UpArrow, 0, vt_all, 0},
{"OB", PIKbdListener::DownArrow, 0, 0, 1},
{"OB", PIKbdListener::DownArrow, 4, 0, 0},
{"[1B", PIKbdListener::DownArrow, 0, 0, 0},
{"[B", PIKbdListener::DownArrow, 0, vt_all, 0},
{"OC", PIKbdListener::RightArrow, 0, 0, 1},
{"OC", PIKbdListener::RightArrow, 4, 0, 0},
{"[1C", PIKbdListener::RightArrow, 0, 0, 0},
{"[C", PIKbdListener::RightArrow, 0, vt_all, 0},
{"OD", PIKbdListener::LeftArrow, 0, 0, 1},
{"OD", PIKbdListener::LeftArrow, 4, 0, 0},
{"[1D", PIKbdListener::LeftArrow, 0, 0, 0},
{"[D", PIKbdListener::LeftArrow, 0, vt_all, 0},
{"[H", PIKbdListener::Home, 0, vt_xterm, 0},
{"[1H", PIKbdListener::Home, 0, 0, 0},
{"OH", PIKbdListener::Home, 0, 0, 1},
{"[1~", PIKbdListener::Home, 0, vt_linux, 0},
{"[F", PIKbdListener::End, 0, vt_xterm, 0},
{"[1F", PIKbdListener::End, 0, 0, 0},
{"OF", PIKbdListener::End, 0, 0, 1},
{"[4~", PIKbdListener::End, 0, vt_linux, 0},
{"[2~", PIKbdListener::Insert, 0, vt_all, 0},
{"[3~", PIKbdListener::Delete, 0, vt_all, 0},
{"[5~", PIKbdListener::PageUp, 0, vt_all, 0},
{"[6~", PIKbdListener::PageDown, 0, vt_all, 0},
{"[Z", PIKbdListener::Tab, 1, vt_xterm, 0},
{"OP", PIKbdListener::F1, 0, vt_xterm, 0},
{"[[A", PIKbdListener::F1, 0, vt_linux, 0},
{"[11~", PIKbdListener::F1, 0, 0, 0},
{"[25~", PIKbdListener::F1, 1, vt_linux, 0},
{"OQ", PIKbdListener::F2, 0, vt_xterm, 0},
{"[[B", PIKbdListener::F2, 0, vt_linux, 0},
{"[12~", PIKbdListener::F2, 0, 0, 0},
{"[26~", PIKbdListener::F2, 1, vt_linux, 0},
{"OR", PIKbdListener::F3, 0, vt_xterm, 0},
{"[[C", PIKbdListener::F3, 0, vt_linux, 0},
{"[13~", PIKbdListener::F3, 0, 0, 0},
{"[28~", PIKbdListener::F3, 1, vt_linux, 0},
{"OS", PIKbdListener::F4, 0, vt_xterm, 0},
{"[[D", PIKbdListener::F4, 0, vt_linux, 0},
{"[14~", PIKbdListener::F4, 0, 0, 0},
{"[29~", PIKbdListener::F4, 1, vt_linux, 0},
{"[[E", PIKbdListener::F5, 0, vt_linux, 0},
{"OT", PIKbdListener::F5, 0, 0, 0},
{"[15~", PIKbdListener::F5, 0, vt_xterm, 0},
{"[31~", PIKbdListener::F5, 1, vt_linux, 0},
{"OU", PIKbdListener::F6, 0, 0, 0},
{"[17~", PIKbdListener::F6, 0, vt_all, 0},
{"[32~", PIKbdListener::F6, 1, vt_linux, 0},
{"OV", PIKbdListener::F7, 0, 0, 0},
{"[18~", PIKbdListener::F7, 0, vt_all, 0},
{"[33~", PIKbdListener::F7, 1, vt_linux, 0},
{"OW", PIKbdListener::F8, 0, 0, 0},
{"[19~", PIKbdListener::F8, 0, vt_all, 0},
{"[34~", PIKbdListener::F8, 1, vt_linux, 0},
{"OX", PIKbdListener::F9, 0, 0, 0},
{"[20~", PIKbdListener::F9, 0, vt_all, 0},
{"[35~", PIKbdListener::F9, 1, vt_linux, 0},
{"OY", PIKbdListener::F10, 0, 0, 0},
{"[21~", PIKbdListener::F10, 0, vt_all, 0},
{"[36~", PIKbdListener::F10, 1, vt_linux, 0},
{"OZ", PIKbdListener::F11, 0, 0, 0},
{"[23~", PIKbdListener::F11, 0, vt_all, 0},
{"O[", PIKbdListener::F12, 0, 0, 0},
{"[24~", PIKbdListener::F12, 0, vt_all, 0},
// End
{0, 0, 0, 0, 0},
};
void setupTerminal(bool on) {
printf("\e[?1000"); printf(on ? "h" : "l");
printf("\e[?1002"); printf(on ? "h" : "l");
printf("\e[?1000");
printf(on ? "h" : "l");
printf("\e[?1002");
printf(on ? "h" : "l");
fflush(0);
}
#endif
@@ -128,7 +131,7 @@ void setupTerminal(bool on) {
PRIVATE_DEFINITION_START(PIKbdListener)
#ifdef WINDOWS
void * hIn, * hOut;
void *hIn, *hOut;
DWORD smode, tmode;
CONSOLE_SCREEN_BUFFER_INFO sbi;
#else
@@ -139,7 +142,7 @@ PRIVATE_DEFINITION_START(PIKbdListener)
#else
int
#endif
ret;
ret;
PRIVATE_DEFINITION_END(PIKbdListener)
@@ -147,16 +150,16 @@ PIKbdListener::PIKbdListener(KBFunc slot, void * _d, bool startNow): PIThread()
setName("keyboard_listener");
_object = this;
#ifdef WINDOWS
PRIVATE->hIn = GetStdHandle(STD_INPUT_HANDLE);
PRIVATE->hIn = GetStdHandle(STD_INPUT_HANDLE);
PRIVATE->hOut = GetStdHandle(STD_OUTPUT_HANDLE);
GetConsoleMode(PRIVATE->hIn, &PRIVATE->smode);
#else
tcgetattr(0, &PRIVATE->sterm);
#endif
is_active = true;
ret_func = slot;
kbddata_ = _d;
dbl_interval = 400;
is_active = true;
ret_func = slot;
kbddata_ = _d;
dbl_interval = 400;
PIKbdListener::exiting = exit_enabled = false;
if (startNow) start();
}
@@ -191,9 +194,9 @@ PIKbdListener::KeyModifiers getModifiers(DWORD v, bool * shift = 0) {
bool shi = v & SHIFT_PRESSED;
bool alt = v & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED);
if (ctrl) ret |= PIKbdListener::Ctrl;
if (shi) ret |= PIKbdListener::Shift;
if (alt) ret |= PIKbdListener::Alt;
//if (meta) ret |= PIKbdListener::Meta;
if (shi) ret |= PIKbdListener::Shift;
if (alt) ret |= PIKbdListener::Alt;
// if (meta) ret |= PIKbdListener::Meta;
if (v & CAPSLOCK_ON) shi = !shi;
if (shift) *shift = shi;
return ret;
@@ -201,7 +204,7 @@ PIKbdListener::KeyModifiers getModifiers(DWORD v, bool * shift = 0) {
PIKbdListener::MouseButtons getButtons(DWORD v) {
PIKbdListener::MouseButtons ret;
if (v & FROM_LEFT_1ST_BUTTON_PRESSED) ret |= PIKbdListener::MouseLeft;
if (v & RIGHTMOST_BUTTON_PRESSED) ret |= PIKbdListener::MouseRight;
if (v & RIGHTMOST_BUTTON_PRESSED) ret |= PIKbdListener::MouseRight;
if (v & FROM_LEFT_2ND_BUTTON_PRESSED) ret |= PIKbdListener::MouseMiddle;
return ret;
}
@@ -209,77 +212,160 @@ PIKbdListener::MouseButtons getButtons(DWORD v) {
void PIKbdListener::readKeyboard() {
ke.key = 0;
ke.key = 0;
ke.modifiers = 0;
memset(rc, 0, 8);
#ifdef WINDOWS
INPUT_RECORD ir;
ReadConsoleInput(PRIVATE->hIn, &ir, 1, &(PRIVATE->ret));
//piCout << ir.EventType;
// piCout << ir.EventType;
switch (ir.EventType) {
case KEY_EVENT: {
KEY_EVENT_RECORD ker = ir.Event.KeyEvent;
if (ker.bKeyDown) {
bool shift = false;
bool shift = false;
ke.modifiers = getModifiers(ker.dwControlKeyState, &shift);
//piCout << "key" << int(ker.wVirtualKeyCode) << int(ker.uChar.AsciiChar);
// piCout << "key" << int(ker.wVirtualKeyCode) << int(ker.uChar.AsciiChar);
switch (ker.wVirtualKeyCode) {
case 8: PRIVATE->ret = 1; ke.key = Backspace; break;
case 33: PRIVATE->ret = 1; ke.key = PageUp; break;
case 34: PRIVATE->ret = 1; ke.key = PageDown; break;
case 35: PRIVATE->ret = 1; ke.key = End; break;
case 36: PRIVATE->ret = 1; ke.key = Home; break;
case 37: PRIVATE->ret = 1; ke.key = LeftArrow; break;
case 38: PRIVATE->ret = 1; ke.key = UpArrow; break;
case 39: PRIVATE->ret = 1; ke.key = RightArrow; break;
case 40: PRIVATE->ret = 1; ke.key = DownArrow; break;
case 45: PRIVATE->ret = 1; ke.key = Insert; break;
case 46: PRIVATE->ret = 1; ke.key = Delete; break;
case 8:
PRIVATE->ret = 1;
ke.key = Backspace;
break;
case 33:
PRIVATE->ret = 1;
ke.key = PageUp;
break;
case 34:
PRIVATE->ret = 1;
ke.key = PageDown;
break;
case 35:
PRIVATE->ret = 1;
ke.key = End;
break;
case 36:
PRIVATE->ret = 1;
ke.key = Home;
break;
case 37:
PRIVATE->ret = 1;
ke.key = LeftArrow;
break;
case 38:
PRIVATE->ret = 1;
ke.key = UpArrow;
break;
case 39:
PRIVATE->ret = 1;
ke.key = RightArrow;
break;
case 40:
PRIVATE->ret = 1;
ke.key = DownArrow;
break;
case 45:
PRIVATE->ret = 1;
ke.key = Insert;
break;
case 46:
PRIVATE->ret = 1;
ke.key = Delete;
break;
case '\r':
case '\n': PRIVATE->ret = 1; ke.key = Return; break;
case ' ': PRIVATE->ret = 1; ke.key = Space; break;
case '\t': PRIVATE->ret = 1; ke.key = Tab; break;
case 112: PRIVATE->ret = 1; ke.key = F1; break;
case 113: PRIVATE->ret = 1; ke.key = F2; break;
case 114: PRIVATE->ret = 1; ke.key = F3; break;
case 115: PRIVATE->ret = 1; ke.key = F4; break;
case 116: PRIVATE->ret = 1; ke.key = F5; break;
case 117: PRIVATE->ret = 1; ke.key = F6; break;
case 118: PRIVATE->ret = 1; ke.key = F7; break;
case 119: PRIVATE->ret = 1; ke.key = F8; break;
case 120: PRIVATE->ret = 1; ke.key = F9; break;
case 121: PRIVATE->ret = 1; ke.key = F10; break;
case 122: PRIVATE->ret = 1; ke.key = F11; break;
case 123: PRIVATE->ret = 1; ke.key = F12; break;
case '\n':
PRIVATE->ret = 1;
ke.key = Return;
break;
case ' ':
PRIVATE->ret = 1;
ke.key = Space;
break;
case '\t':
PRIVATE->ret = 1;
ke.key = Tab;
break;
case 112:
PRIVATE->ret = 1;
ke.key = F1;
break;
case 113:
PRIVATE->ret = 1;
ke.key = F2;
break;
case 114:
PRIVATE->ret = 1;
ke.key = F3;
break;
case 115:
PRIVATE->ret = 1;
ke.key = F4;
break;
case 116:
PRIVATE->ret = 1;
ke.key = F5;
break;
case 117:
PRIVATE->ret = 1;
ke.key = F6;
break;
case 118:
PRIVATE->ret = 1;
ke.key = F7;
break;
case 119:
PRIVATE->ret = 1;
ke.key = F8;
break;
case 120:
PRIVATE->ret = 1;
ke.key = F9;
break;
case 121:
PRIVATE->ret = 1;
ke.key = F10;
break;
case 122:
PRIVATE->ret = 1;
ke.key = F11;
break;
case 123:
PRIVATE->ret = 1;
ke.key = F12;
break;
default:
PRIVATE->ret = 1;
rc[0] = 1;
rc[0] = 1;
{
PIChar ch = PIChar::fromConsole(ker.uChar.AsciiChar);
if (shift) ch = ch.toUpper();
ke.key = ch.unicode16Code();
PIChar ch = PIChar::fromConsole(ker.uChar.AsciiChar);
if (shift) ch = ch.toUpper();
ke.key = ch.unicode16Code();
}
break;
}
if (ke.key == 0) {piMSleep(10); return;}
} else {piMSleep(10); return;}
if (ke.key == 0) {
piMSleep(10);
return;
}
} else {
piMSleep(10);
return;
}
break;
} break;
case MOUSE_EVENT: {
MOUSE_EVENT_RECORD mer = ir.Event.MouseEvent;
GetConsoleScreenBufferInfo(PRIVATE->hOut, &PRIVATE->sbi);
me.modifiers = getModifiers(mer.dwControlKeyState);
me.modifiers = getModifiers(mer.dwControlKeyState);
MouseButtons mb = getButtons(mer.dwButtonState);
if (mer.dwEventFlags & MOUSE_WHEELED) {
memcpy((void*)(&we), (const void*)(&me), sizeof(me));
we.action = MouseWheel;
memcpy((void *)(&we), (const void *)(&me), sizeof(me));
we.action = MouseWheel;
we.direction = short((mer.dwButtonState >> 8) & 0xFFFF) > 0;
//piCout << "wheel" << we.direction;
// piCout << "wheel" << we.direction;
wheelEvent(we, kbddata_);
break;
} else {
me.x = mer.dwMousePosition.X;
me.y = mer.dwMousePosition.Y - PRIVATE->sbi.srWindow.Top;
me.x = mer.dwMousePosition.X;
me.y = mer.dwMousePosition.Y - PRIVATE->sbi.srWindow.Top;
bool move = mer.dwEventFlags & MOUSE_MOVED;
if (move) {
if (me.action == MouseButtonRelease) {
@@ -297,24 +383,23 @@ void PIKbdListener::readKeyboard() {
prev_p_me = me;
}
tm_dbl.reset();
} else if (mb < me.buttons)
me.action = MouseButtonRelease;
else {
if (mb != 0) piCoutObj << "WTF";
break;
}
else if (mb < me.buttons) me.action = MouseButtonRelease;
else {if (mb != 0) piCoutObj << "WTF"; break;}
}
me.buttons = mb;
if (piCompareBinary(&prev_me, &me, sizeof(me)))
break;
memcpy((void*)(&prev_me), (const void*)(&me), sizeof(me));
//PIString _s[] = {"press", "release", "dbl click", "move"};
//piCoutObj << _s[me.action] << me.buttons << ":" << me.x << me.y;
if (piCompareBinary(&prev_me, &me, sizeof(me))) break;
memcpy((void *)(&prev_me), (const void *)(&me), sizeof(me));
// PIString _s[] = {"press", "release", "dbl click", "move"};
// piCoutObj << _s[me.action] << me.buttons << ":" << me.x << me.y;
mouseEvent(me, kbddata_);
break;
}
}
break;
default:
piMSleep(10);
return;
} break;
default: piMSleep(10); return;
}
#else
tcsetattr(0, TCSANOW, &PRIVATE->tterm);
@@ -327,8 +412,14 @@ void PIKbdListener::readKeyboard() {
for (int i = 0; i < PRIVATE->ret; ++i)
std::cout << "'" << (char)(rc[i]) << "' " << (int)(uchar)(rc[i]);
std::cout << std::endl;*/
if (rc[0] == 0) {piMSleep(10); return;}
if (PRIVATE->ret < 0 || PRIVATE->ret > 7) {piMSleep(10); return;}
if (rc[0] == 0) {
piMSleep(10);
return;
}
if (PRIVATE->ret < 0 || PRIVATE->ret > 7) {
piMSleep(10);
return;
}
if (PRIVATE->ret == 1) {
if (rc[0] == 8)
ke.key = Backspace;
@@ -343,25 +434,26 @@ void PIKbdListener::readKeyboard() {
// 8 - ctrl+alt+shift 7
if (rc[0] == '\e') { // search for Alt
if (PRIVATE->ret == 2) {
mod = 2;
mod = 2;
ke.key = PIChar::fromConsole(rc[1]).unicode16Code();
} else {// escape-seq
} else { // escape-seq
if (rc[1] == '\e') { // search for Alt
for (int i = 1; i < 7; ++i) rc[i] = rc[i + 1];
for (int i = 1; i < 7; ++i)
rc[i] = rc[i + 1];
mod = 2;
PRIVATE->ret--;
}
if (rc[1] == '[') {
if (rc[2] == 'M') { // mouse
if (PRIVATE->ret >= 5) {
me.x = uchar(rc[4] - '!');
me.y = uchar(rc[5] - '!');
me.x = uchar(rc[4] - '!');
me.y = uchar(rc[5] - '!');
int b = rc[3] & 0x7, a = rc[3] & 0x60;
if (a == 0x60) {
memcpy((void*)(&we), (const void*)(&me), sizeof(me));
we.action = MouseWheel;
memcpy((void *)(&we), (const void *)(&me), sizeof(me));
we.action = MouseWheel;
we.direction = (b == 0);
//piCout << "wheel" << we.direction;
// piCout << "wheel" << we.direction;
wheelEvent(we, kbddata_);
} else {
switch (b) {
@@ -372,7 +464,7 @@ void PIKbdListener::readKeyboard() {
}
if (a == 0x20) {
if (b == 3) {
me.action = MouseButtonRelease;
me.action = MouseButtonRelease;
me.buttons = 0;
} else {
if (tm_dbl.elapsed_m() <= dbl_interval && prev_p_me.x == me.x && prev_p_me.y == me.y)
@@ -385,18 +477,19 @@ void PIKbdListener::readKeyboard() {
}
}
if (a == 0x40) me.action = MouseMove;
//PIString _s[] = {"press", "release", "dbl click", "move"};
//piCoutObj << _s[me.action] << me.buttons << ":" << me.x << me.y;
// PIString _s[] = {"press", "release", "dbl click", "move"};
// piCoutObj << _s[me.action] << me.buttons << ":" << me.x << me.y;
mouseEvent(me, kbddata_);
}
//piCout << me.x << me.y << PICoutManipulators::Hex << b << a;
// piCout << me.x << me.y << PICoutManipulators::Hex << b << a;
}
return;
} else {
for (int i = 2; i < 7; ++i) // search for modifier
if (rc[i] == ';') {
mod |= rc[i + 1] - '0' - 1;
for (int j = i; j < 6; ++j) rc[j] = rc[j + 2];
for (int j = i; j < 6; ++j)
rc[j] = rc[j + 2];
rc[6] = rc[7] = 0;
PRIVATE->ret -= 2;
break;
@@ -406,14 +499,15 @@ void PIKbdListener::readKeyboard() {
if (PRIVATE->ret >= 3 && rc[1] == 'O') { // search for modifier (F1-F4)
if (rc[2] >= '1' && rc[2] <= '8') {
mod |= rc[2] - '0' - 1;
for (int j = 2; j < 6; ++j) rc[j] = rc[j + 1];
for (int j = 2; j < 6; ++j)
rc[j] = rc[j + 1];
rc[7] = 0;
PRIVATE->ret--;
}
}
for (int i = 0; ; ++i) {
for (int i = 0;; ++i) {
if (!esc_seq[i].seq) break;
//piCout << "search" << rc[1] << esc_seq[i].seq;
// piCout << "search" << rc[1] << esc_seq[i].seq;
if (strcmp(esc_seq[i].seq, &(rc[1])) == 0) {
ke.key = esc_seq[i].key;
mod |= esc_seq[i].mod;
@@ -425,18 +519,16 @@ void PIKbdListener::readKeyboard() {
if (mod & 0x1) ke.modifiers |= Shift;
if (mod & 0x2) ke.modifiers |= Alt;
if (mod & 0x4) ke.modifiers |= Ctrl;
//if (mod & 0x8) ke.modifiers |= Meta;
// if (mod & 0x8) ke.modifiers |= Meta;
}
/*cout << "wo mods (" << mod << ")\n";
for (int i = 0; i < PRIVATE->ret; ++i)
cout << "'" << (char)(rc[i]) << "' ";
cout << endl;*/
/*cout << "wo mods (" << mod << ")\n";
for (int i = 0; i < PRIVATE->ret; ++i)
cout << "'" << (char)(rc[i]) << "' ";
cout << endl;*/
}
if (ke.key == 0 && PRIVATE->ret > 1)
ke.key = PIChar(rc).unicode16Code();
if (ke.key == 0 && PRIVATE->ret > 1) ke.key = PIChar(rc).unicode16Code();
#endif
if ((rc[0] == '\n' || rc[0] == '\r') && PRIVATE->ret == 1)
ke.key = Return;
if ((rc[0] == '\n' || rc[0] == '\r') && PRIVATE->ret == 1) ke.key = Return;
if (exit_enabled && ke.key == exit_key) {
PIKbdListener::exiting = true;
return;
@@ -449,7 +541,7 @@ void PIKbdListener::readKeyboard() {
void PIKbdListener::end() {
//cout << "list end" << endl;
// cout << "list end" << endl;
#ifdef WINDOWS
SetConsoleMode(PRIVATE->hIn, PRIVATE->smode);
#else

162
libs/main/console/pikbdlistener.h
View File

@@ -27,61 +27,66 @@
#define PIKBDLISTENER_H
#include "pithread.h"
#include "pitime.h"
#define WAIT_FOR_EXIT while (!PIKbdListener::exiting) piMSleep(PIP_MIN_MSLEEP*5); // TODO: rewrite with condvar
#define WAIT_FOR_EXIT \
while (!PIKbdListener::exiting) \
piMSleep(PIP_MIN_MSLEEP * 5); // TODO: rewrite with condvar
class PIP_EXPORT PIKbdListener: public PIThread
{
class PIP_EXPORT PIKbdListener: public PIThread {
PIOBJECT_SUBCLASS(PIKbdListener, PIThread);
friend class PIConsole;
friend class PITerminal;
public:
public:
//! Special keyboard keys
enum SpecialKey {
Tab /** Tab key */ = 0x09,
Return /** Enter key */ = 0x0a,
Esc /** Escape key */ = 0x1b,
Space /** Space key */ = 0x20,
Backspace /** Backspace key */ = 0x7f,
UpArrow /** Up arrow key */ = -1,
DownArrow /** Down arrow key */ = -2,
Tab /** Tab key */ = 0x09,
Return /** Enter key */ = 0x0a,
Esc /** Escape key */ = 0x1b,
Space /** Space key */ = 0x20,
Backspace /** Backspace key */ = 0x7f,
UpArrow /** Up arrow key */ = -1,
DownArrow /** Down arrow key */ = -2,
RightArrow /** Right arrow key */ = -3,
LeftArrow /** Left arrow key */ = -4,
Home /** Home key */ = -5,
End /** End key */ = -6,
PageUp /** Page up key */ = -7,
PageDown /** Page down key */ = -8,
Insert /** Delete key */ = -9,
Delete /** Delete key */ = -10,
F1 /** F1 key */ = -11,
F2 /** F2 key */ = -12,
F3 /** F3 key */ = -13,
F4 /** F4 key */ = -14,
F5 /** F5 key */ = -15,
F6 /** F6 key */ = -16,
F7 /** F7 key */ = -17,
F8 /** F8 key */ = -18,
F9 /** F9 key */ = -19,
F10 /** F10 key */ = -20,
F11 /** F11 key */ = -21,
F12 /** F12 key */ = -22
LeftArrow /** Left arrow key */ = -4,
Home /** Home key */ = -5,
End /** End key */ = -6,
PageUp /** Page up key */ = -7,
PageDown /** Page down key */ = -8,
Insert /** Delete key */ = -9,
Delete /** Delete key */ = -10,
F1 /** F1 key */ = -11,
F2 /** F2 key */ = -12,
F3 /** F3 key */ = -13,
F4 /** F4 key */ = -14,
F5 /** F5 key */ = -15,
F6 /** F6 key */ = -16,
F7 /** F7 key */ = -17,
F8 /** F8 key */ = -18,
F9 /** F9 key */ = -19,
F10 /** F10 key */ = -20,
F11 /** F11 key */ = -21,
F12 /** F12 key */ = -22
};
//! Keyboard modifiers
enum KeyModifier {
Ctrl /** Control key */ = 0x1,
Shift /** Shift key */ = 0x2,
Alt /** Alt key */ = 0x4
//Meta /** Meta (windows) key */ = 0x8
Shift /** Shift key */ = 0x2,
Alt /** Alt key */ = 0x4
// Meta /** Meta (windows) key */ = 0x8
};
typedef PIFlags<KeyModifier> KeyModifiers;
//! This struct contains information about pressed keyboard key
struct PIP_EXPORT KeyEvent {
KeyEvent(int k = 0, KeyModifiers m = 0) {key = k; modifiers = m;}
KeyEvent(int k = 0, KeyModifiers m = 0) {
key = k;
modifiers = m;
}
//! Pressed key. It can be simple \b char or special key (see PIKbdListener::SpecialKey)
int key;
@@ -92,8 +97,8 @@ public:
//! Mouse buttons
enum MouseButton {
MouseLeft /** Left button */ = 0x01,
MouseRight /** Right button */ = 0x02,
MouseLeft /** Left button */ = 0x01,
MouseRight /** Right button */ = 0x02,
MouseMiddle /** Middle button */ = 0x04
};
@@ -110,7 +115,12 @@ public:
//! This struct contains information about mouse action
struct PIP_EXPORT MouseEvent {
MouseEvent(MouseAction a = MouseButtonPress, MouseButtons b = 0, KeyModifiers m = 0) {x = y = 0; action = a; buttons = b; modifiers = m;}
MouseEvent(MouseAction a = MouseButtonPress, MouseButtons b = 0, KeyModifiers m = 0) {
x = y = 0;
action = a;
buttons = b;
modifiers = m;
}
//! Event X coordinate in view-space, from 0
int x;
@@ -130,7 +140,7 @@ public:
//! This struct contains information about mouse wheel action
struct PIP_EXPORT WheelEvent: public MouseEvent {
WheelEvent(): MouseEvent() {direction = false;}
WheelEvent(): MouseEvent() { direction = false; }
//! Wheel direction, /b true - up, /b fasle - down
bool direction;
@@ -145,43 +155,48 @@ public:
//! Returns custom data
void * data() {return kbddata_;}
void * data() { return kbddata_; }
//! Set custom data to "_data"
void setData(void * _data) {kbddata_ = _data;}
void setData(void * _data) { kbddata_ = _data; }
//! Set external function to "slot"
void setSlot(KBFunc slot) {ret_func = slot;}
void setSlot(KBFunc slot) { ret_func = slot; }
//! Set external function to "slot"
void setSlot(std::function<void(KeyEvent)> slot) {ret_func = [slot](KeyEvent e, void *){slot(e);};}
void setSlot(std::function<void(KeyEvent)> slot) {
ret_func = [slot](KeyEvent e, void *) { slot(e); };
}
//! Returns if exit key if awaiting
bool exitCaptured() const {return exit_enabled;}
bool exitCaptured() const { return exit_enabled; }
//! Returns exit key, default 'Q'
int exitKey() const {return exit_key;}
int exitKey() const { return exit_key; }
double doubleClickInterval() const {return dbl_interval;}
void setDoubleClickInterval(double v) {dbl_interval = v;}
double doubleClickInterval() const { return dbl_interval; }
void setDoubleClickInterval(double v) { dbl_interval = v; }
void readKeyboard();
//! Returns if keyboard listening is active (not running!)
bool isActive() {return is_active;}
bool isActive() { return is_active; }
EVENT_HANDLER( void, enableExitCapture) {enableExitCapture('Q');}
EVENT_HANDLER1(void, enableExitCapture, int, key) {exit_enabled = true; exit_key = key;}
EVENT_HANDLER(void, disableExitCapture) {exit_enabled = false;}
EVENT_HANDLER(void, setActive) {setActive(true);}
EVENT_HANDLER(void, enableExitCapture) { enableExitCapture('Q'); }
EVENT_HANDLER1(void, enableExitCapture, int, key) {
exit_enabled = true;
exit_key = key;
}
EVENT_HANDLER(void, disableExitCapture) { exit_enabled = false; }
EVENT_HANDLER(void, setActive) { setActive(true); }
EVENT_HANDLER1(void, setActive, bool, yes);
EVENT2(keyPressed, PIKbdListener::KeyEvent, key, void * , data);
EVENT2(mouseEvent, PIKbdListener::MouseEvent, mouse, void * , data);
EVENT2(wheelEvent, PIKbdListener::WheelEvent, wheel, void * , data);
EVENT2(keyPressed, PIKbdListener::KeyEvent, key, void *, data);
EVENT2(mouseEvent, PIKbdListener::MouseEvent, mouse, void *, data);
EVENT2(wheelEvent, PIKbdListener::WheelEvent, wheel, void *, data);
//! \handlers
//! \{
//! \handlers
//! \{
//! \fn void enableExitCapture(int key = 'Q')
//! \brief Enable exit key "key" awaiting
@@ -192,21 +207,21 @@ public:
//! \fn void setActive(bool yes = true)
//! \brief Set keyboard listening is active or not
//! \}
//! \events
//! \{
//! \}
//! \events
//! \{
//! \fn void keyPressed(PIKbdListener::KeyEvent key, void * data)
//! \brief Raise on key "key" pressed, "data" is custom data
//! \}
//! \}
static bool exiting;
static PIKbdListener * instance() {return _object;}
static PIKbdListener * instance() { return _object; }
private:
void begin() override;
void run() override {readKeyboard();}
void run() override { readKeyboard(); }
void end() override;
#ifndef WINDOWS
@@ -225,7 +240,7 @@ private:
vt_none,
vt_xterm = 0x1,
vt_linux = 0x2,
vt_all = 0xFF
vt_all = 0xFF
};
static const EscSeq esc_seq[];
@@ -243,30 +258,41 @@ private:
MouseEvent me, prev_me, prev_p_me;
WheelEvent we;
static PIKbdListener * _object;
};
//! \relatesalso PIBinaryStream
//! \~english Store operator
//! \~russian Оператор сохранения
BINARY_STREAM_WRITE(PIKbdListener::MouseEvent) {s << v.x << v.y << v.action << v.buttons << v.modifiers; return s;}
BINARY_STREAM_WRITE(PIKbdListener::MouseEvent) {
s << v.x << v.y << v.action << v.buttons << v.modifiers;
return s;
}
//! \relatesalso PIBinaryStream
//! \~english Restore operator
//! \~russian Оператор извлечения
BINARY_STREAM_READ (PIKbdListener::MouseEvent) {s >> v.x >> v.y >> v.action >> v.buttons >> v.modifiers; return s;}
BINARY_STREAM_READ(PIKbdListener::MouseEvent) {
s >> v.x >> v.y >> v.action >> v.buttons >> v.modifiers;
return s;
}
//! \relatesalso PIBinaryStream
//! \~english Store operator
//! \~russian Оператор сохранения
BINARY_STREAM_WRITE(PIKbdListener::WheelEvent) {s << (*(PIKbdListener::MouseEvent*)&v) << v.direction; return s;}
BINARY_STREAM_WRITE(PIKbdListener::WheelEvent) {
s << (*(PIKbdListener::MouseEvent *)&v) << v.direction;
return s;
}
//! \relatesalso PIBinaryStream
//! \~english Restore operator
//! \~russian Оператор извлечения
BINARY_STREAM_READ (PIKbdListener::WheelEvent) {s >> (*(PIKbdListener::MouseEvent*)&v) >> v.direction; return s;}
BINARY_STREAM_READ(PIKbdListener::WheelEvent) {
s >> (*(PIKbdListener::MouseEvent *)&v) >> v.direction;
return s;
}
REGISTER_PIVARIANTSIMPLE(PIKbdListener::KeyEvent)

25
libs/main/text/pistring.cpp
View File

@@ -1391,6 +1391,31 @@ PIString PIString::takeNumber() {
}
PIString PIString::takeInteger() {
PIString ret;
int sz = size_s(), ws = -1, we = -1;
for (int i = 0; i < sz; ++i) {
PIChar c = at(i);
if (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
if (we < 0 && ws >= 0) {
we = i;
break;
}
} else {
if (ws < 0) ws = i;
if (!c.isDigit()) {
we = i;
break;
}
if (we >= 0) break;
}
}
ret = mid(ws, we - ws);
cutLeft(we < 0 ? sz : we);
return ret;
}
//! \~\details
//! \~english "shield" symbol prevent analysis of the next symbol
//! \~russian Символ "shield" экранирует следующий символ

4
libs/main/text/pistring.h
View File

@@ -806,6 +806,10 @@ public:
//! \~english Take a number with C-format from the begin of this string and return it.
//! \~russian Извлекает число в C-формате с начала строки и возвращает его как строку.
PIString takeNumber();
//! \~english Take a digits from the begin of this string and return it.
//! \~russian Извлекает цифры с начала строки и возвращает их как строку.
PIString takeInteger();
//! \~english Take a range between "start" and "end" characters from the begin of this string and return it.
//! \~russian Извлекает диапазон между символами "start" и "end" с начала строки и возвращает его.

1
libs/main/thread/pithread.cpp
View File

@@ -20,6 +20,7 @@
#include "piincludes_p.h"
#include "pithread.h"
#include "piintrospection_threads.h"
#include "pitime.h"
#ifndef MICRO_PIP
# include "pisystemtests.h"
#endif

8
libs/main/types/colors.cpp
View File

@@ -19,8 +19,10 @@
#include "colors_p.h"
#define CSS_COLOR(n,v) {#n,v}
#define CSS_COLOR(n, v) \
{ #n, v }
// clang-format off
struct CSSColor {
const char * name;
uint color;
@@ -174,6 +176,7 @@ struct CSSColor {
CSS_COLOR(yellowgreen ,0x9acd32),
{nullptr, 0}
};
// clang-format on
#undef CSS_COLOR
@@ -189,8 +192,7 @@ PIColorCollection::PIColorCollection() {
while (c->name) {
PIVariantTypes::Color col(c->color | 0xFF000000);
css_color[c->name] = col;
css_name[col] = c->name;
css_name[col] = c->name;
++c;
}
}

155
libs/main/types/pibytearray.cpp
View File

@@ -18,9 +18,11 @@
*/
#include "pibytearray.h"
#include "pistringlist.h"
#include <iostream>
#include "picrc.h"
#include "pistringlist.h"
#include <iostream>
//! \class PIByteArray pibytearray.h
//! \~\details
@@ -71,51 +73,27 @@
//!
static const uchar base64Table[64] = {
0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e,
0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33,
0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f};
static const uchar base64Table[64] = {0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f};
static const uchar base64InvTable[256] = {
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x3E, 0x0, 0x0, 0x0, 0x3F,
0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B,
0x3C, 0x3D, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6,
0x7, 0x8, 0x9, 0xA, 0xB, 0xC, 0xD, 0xE,
0xF, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
0x17, 0x18, 0x19, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
0x31, 0x32, 0x33, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3E,
0x0, 0x0, 0x0, 0x3F, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
0x17, 0x18, 0x19, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26,
0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
// clang-format off
struct base64HelpStruct {
base64HelpStruct() {v = 0;}
inline void setBytes(const uchar * r, int size = 3) {
@@ -148,14 +126,15 @@ struct base64HelpStruct {
}
uint v;
};
// clang-format on
PIByteArray &PIByteArray::convertToBase64() {
PIByteArray & PIByteArray::convertToBase64() {
return *this = toBase64();
}
PIByteArray &PIByteArray::convertFromBase64() {
PIByteArray & PIByteArray::convertFromBase64() {
return *this = fromBase64(*this);
}
@@ -177,23 +156,23 @@ PIByteArray PIByteArray::toBase64() const {
}
int der = size_s() % 3;
switch (der) {
case 1:
hs.setBytes(data(sz), 1);
hs.getAscii(t);
ret[++ri] = (t[0]);
ret[++ri] = (t[1]);
ret[++ri] = ('=');
ret[++ri] = ('=');
break;
case 2:
hs.setBytes(data(sz), 2);
hs.getAscii(t);
ret[++ri] = (t[0]);
ret[++ri] = (t[1]);
ret[++ri] = (t[2]);
ret[++ri] = ('=');
break;
default: break;
case 1:
hs.setBytes(data(sz), 1);
hs.getAscii(t);
ret[++ri] = (t[0]);
ret[++ri] = (t[1]);
ret[++ri] = ('=');
ret[++ri] = ('=');
break;
case 2:
hs.setBytes(data(sz), 2);
hs.getAscii(t);
ret[++ri] = (t[0]);
ret[++ri] = (t[1]);
ret[++ri] = (t[2]);
ret[++ri] = ('=');
break;
default: break;
}
return ret;
}
@@ -214,7 +193,8 @@ PIByteArray PIByteArray::fromBase64(const PIByteArray & base64) {
ret[++ind] = (t[2]);
}
if (base64.back() == '=') ret.pop_back();
if (sz > 1) if (base64[sz - 2] == '=') ret.pop_back();
if (sz > 1)
if (base64[sz - 2] == '=') ret.pop_back();
return ret;
}
@@ -228,12 +208,11 @@ PIByteArray & PIByteArray::compressRLE(uchar threshold) {
PIByteArray t;
uchar fb, clen, mlen = 255 - threshold;
for (uint i = 0; i < size();) {
fb = at(i);
fb = at(i);
clen = 1;
while (at(++i) == fb) {
++clen;
if (clen == mlen)
break;
if (clen == mlen) break;
}
if (clen > 1) {
t.push_back(threshold + clen);
@@ -258,7 +237,7 @@ PIByteArray & PIByteArray::decompressRLE(uchar threshold) {
fb = at(i);
if (fb >= threshold) {
clen = fb - threshold;
fb = at(++i);
fb = at(++i);
for (uint j = 0; j < clen; ++j)
t.push_back(fb);
continue;
@@ -285,7 +264,7 @@ PIByteArray & PIByteArray::decompressRLE(uchar threshold) {
//! \endcode
uchar PIByteArray::checksumPlain8(bool inverse) const {
uchar c = 0;
int sz = size_s();
int sz = size_s();
for (int i = 0; i < sz; ++i)
c += at(i);
if (inverse) c = ~(c + 1);
@@ -350,15 +329,19 @@ PIString PIByteArray::toString(int base) const {
PIString PIByteArray::toHex() const {
PIByteArray hex(size() * 2);
uchar *hexData = hex.data();
const uchar *d = data();
uchar * hexData = hex.data();
const uchar * d = data();
for (int i = 0; i < size_s(); ++i) {
int j = (d[i] >> 4) & 0xf;
if (j <= 9) hexData[i*2] = (j + '0');
else hexData[i*2] = (j + 'a' - 10);
if (j <= 9)
hexData[i * 2] = (j + '0');
else
hexData[i * 2] = (j + 'a' - 10);
j = d[i] & 0xf;
if (j <= 9) hexData[i*2+1] = (j + '0');
else hexData[i*2+1] = (j + 'a' - 10);
if (j <= 9)
hexData[i * 2 + 1] = (j + '0');
else
hexData[i * 2 + 1] = (j + 'a' - 10);
}
return PIString(hex);
}
@@ -370,7 +353,7 @@ PIByteArray PIByteArray::fromUserInput(PIString str) {
str.replaceAll("\n", " ").replaceAll("\t", " ").replaceAll(" ", " ");
PIStringList bl(str.split(" "));
bool ok(false);
piForeachC (PIString & b, bl) {
piForeachC(PIString & b, bl) {
int bv = b.toInt(-1, &ok);
if (ok) ret << uchar(bv);
}
@@ -380,19 +363,23 @@ PIByteArray PIByteArray::fromUserInput(PIString str) {
PIByteArray PIByteArray::fromHex(PIString str) {
PIByteArray hexEncoded = str.toByteArray();
PIByteArray res((hexEncoded.size() + 1)/ 2);
uchar *result = res.data() + res.size();
PIByteArray res((hexEncoded.size() + 1) / 2);
uchar * result = res.data() + res.size();
bool odd_digit = true;
for (int i = hexEncoded.size() - 1; i >= 0; --i) {
int ch = hexEncoded.at(i);
int tmp;
if (ch >= '0' && ch <= '9') tmp = ch - '0';
else if (ch >= 'a' && ch <= 'f') tmp = ch - 'a' + 10;
else if (ch >= 'A' && ch <= 'F') tmp = ch - 'A' + 10;
else continue;
if (ch >= '0' && ch <= '9')
tmp = ch - '0';
else if (ch >= 'a' && ch <= 'f')
tmp = ch - 'a' + 10;
else if (ch >= 'A' && ch <= 'F')
tmp = ch - 'A' + 10;
else
continue;
if (odd_digit) {
--result;
*result = tmp;
*result = tmp;
odd_digit = false;
} else {
*result |= tmp << 4;
@@ -404,7 +391,7 @@ PIByteArray PIByteArray::fromHex(PIString str) {
}
PICout operator <<(PICout s, const PIByteArray & ba) {
PICout operator<<(PICout s, const PIByteArray & ba) {
s.space();
s.saveAndSetControls(0);
s << "{";
@@ -419,7 +406,7 @@ PICout operator <<(PICout s, const PIByteArray & ba) {
#ifdef PIP_STD_IOSTREAM
std::ostream &operator <<(std::ostream & s, const PIByteArray & ba) {
std::ostream & operator<<(std::ostream & s, const PIByteArray & ba) {
s << "{";
for (uint i = 0; i < ba.size(); ++i) {
s << ba[i];

29
libs/main/types/pivaluetree.cpp
View File

@@ -29,6 +29,8 @@
//! \~russian
//!
//!
// clang-format off
const char PIValueTree::attributeHidden [] = "hidden" ;
const char PIValueTree::attributeReadOnly [] = "readOnly" ;
const char PIValueTree::attributeIsLabel [] = "label" ;
@@ -45,10 +47,10 @@ const char PIValueTree::attributeSingleStep [] = "singleStep" ;
const char PIValueTree::attributeDecimals [] = "decimals" ;
const char PIValueTree::attributePrefix [] = "prefix" ;
const char PIValueTree::attributeSuffix [] = "suffix" ;
// clang-format on
PIValueTree::PIValueTree() {
}
PIValueTree::PIValueTree() {}
PIValueTree::PIValueTree(const PIVariant & v) {
@@ -91,8 +93,7 @@ void PIValueTree::mergeAttributes(const PIVariantMap & a) {
if (_is_null) return;
auto it = a.makeIterator();
while (it.next()) {
if (!_attributes.contains(it.key()))
_attributes.insert(it.key(), it.value());
if (!_attributes.contains(it.key())) _attributes.insert(it.key(), it.value());
}
}
@@ -100,8 +101,7 @@ void PIValueTree::mergeAttributes(const PIVariantMap & a) {
bool PIValueTree::contains(const PIString & name) const {
if (_is_null) return true;
for (const auto & c: _children)
if (c.name() == name)
return true;
if (c.name() == name) return true;
return false;
}
@@ -118,8 +118,7 @@ bool PIValueTree::contains(const PIStringList & path) const {
const PIValueTree & PIValueTree::child(const PIString & name) const {
if (_is_null) return *this;
for (const auto & c: _children)
if (c.name() == name)
return c;
if (c.name() == name) return c;
return nullValue();
}
@@ -127,8 +126,7 @@ const PIValueTree & PIValueTree::child(const PIString & name) const {
PIValueTree & PIValueTree::child(const PIString & name) {
if (_is_null) return *this;
for (auto & c: _children)
if (c.name() == name)
return c;
if (c.name() == name) return c;
return nullValue();
}
@@ -155,7 +153,7 @@ PIValueTree & PIValueTree::addChildren(const PIVector<PIValueTree> & n) {
PIValueTree & PIValueTree::remove(const PIString & name) {
if (_is_null) return *this;
_children.removeWhere([name](const PIValueTree & i){return i.name() == name;});
_children.removeWhere([name](const PIValueTree & i) { return i.name() == name; });
return *this;
}
@@ -163,8 +161,7 @@ PIValueTree & PIValueTree::remove(const PIString & name) {
PIValueTree & PIValueTree::operator[](const PIString & name) {
if (_is_null) return *this;
for (auto & c: _children)
if (c.name() == name)
return c;
if (c.name() == name) return c;
_children << PIValueTree(name, PIVariant());
return _children.back();
}
@@ -182,10 +179,8 @@ PIValueTree & PIValueTree::operator[](const PIStringList & path) {
void PIValueTree::print(PIString & s, const PIValueTree & v, PIString tab) {
PIString ntab = tab + " ", nntab = ntab + " ";
s += tab + v.name() + " {\n";
if (v.value().isValid())
s += ntab + "value: " + v.value().toString() + "\n";
if (v.comment().isNotEmpty())
s += ntab + "comment: " + v.comment() + "\n";
if (v.value().isValid()) s += ntab + "value: " + v.value().toString() + "\n";
if (v.comment().isNotEmpty()) s += ntab + "comment: " + v.comment() + "\n";
if (v.attributes().isNotEmpty()) {
s += ntab + "attributes: [\n";
auto ait = v.attributes().makeIterator();

49
libs/main/types/pivaluetree.h
View File

@@ -3,7 +3,7 @@
* \brief
* \~english Attributed values tree
* \~russian Дерево атрибутированных значений
*/
*/
/*
PIP - Platform Independent Primitives
Attributed values tree
@@ -26,18 +26,20 @@
#ifndef PIVALUETREE_H
#define PIVALUETREE_H
#include "pivariant.h"
#include "pichunkstream.h"
#include "pivariant.h"
class PIP_EXPORT PIValueTree {
BINARY_STREAM_FRIEND(PIValueTree);
friend PICout operator <<(PICout s, const PIValueTree & v);
friend PICout operator<<(PICout s, const PIValueTree & v);
public:
PIValueTree();
PIValueTree(const PIVariant & v);
PIValueTree(const PIString & n, const PIVariant & v, const PIVariantMap & a = PIVariantMap());
// clang-format off
static const char attributeHidden [];
static const char attributeReadOnly [];
static const char attributeIsLabel [];
@@ -55,29 +57,30 @@ public:
static const char attributePrefix [];
static const char attributeSuffix [];
//static constexpr char attribute[] = "";
// clang-format on
bool isNull() const {return _is_null;}
bool isValid() const {return _value.isValid();}
bool isArray() const {return _attributes.contains(attributeArrayType);}
bool hasChildren() const {return _children.isNotEmpty();}
bool isNull() const { return _is_null; }
bool isValid() const { return _value.isValid(); }
bool isArray() const { return _attributes.contains(attributeArrayType); }
bool hasChildren() const { return _children.isNotEmpty(); }
const PIString & name() const {return _name;}
const PIString & name() const { return _name; }
void setName(const PIString & n);
const PIString & comment() const {return _comment;}
const PIString & comment() const { return _comment; }
void setComment(const PIString & c);
const PIVariant & value() const {return _value;}
const PIVariant & value() const { return _value; }
void setValue(const PIVariant & v);
const PIVariantMap & attributes() const {return _attributes;}
PIVariantMap & attributes() {return _attributes;}
PIVariant attribute(const PIString & an, const PIVariant & def = PIVariant()) const {return _attributes.value(an, def);}
const PIVariantMap & attributes() const { return _attributes; }
PIVariantMap & attributes() { return _attributes; }
PIVariant attribute(const PIString & an, const PIVariant & def = PIVariant()) const { return _attributes.value(an, def); }
void setAttribute(const PIString & n, const PIVariant & a);
void mergeAttributes(const PIVariantMap & a);
const PIVector<PIValueTree> & children() const {return _children;}
void clearChildren() {_children.clear();}
const PIVector<PIValueTree> & children() const { return _children; }
void clearChildren() { _children.clear(); }
bool contains(const PIString & name) const;
bool contains(const PIStringList & path) const;
@@ -89,7 +92,7 @@ public:
PIValueTree & operator[](const PIString & name);
PIValueTree & operator[](const PIStringList & path);
const PIValueTree & operator[](const PIString & name) const {return child(name);}
const PIValueTree & operator[](const PIString & name) const { return child(name); }
private:
static void print(PIString & s, const PIValueTree & v, PIString tab);
@@ -101,7 +104,6 @@ private:
PIVariant _value;
PIVector<PIValueTree> _children;
bool _is_null = false;
};
@@ -110,11 +112,7 @@ private:
//! \~russian Оператор сохранения.
BINARY_STREAM_WRITE(PIValueTree) {
PIChunkStream cs;
cs.add(1, v._name)
.add(2, v._comment)
.add(3, v._attributes)
.add(4, v._value)
.add(5, v._children);
cs.add(1, v._name).add(2, v._comment).add(3, v._attributes).add(4, v._value).add(5, v._children);
s << cs.data();
return s;
}
@@ -122,8 +120,9 @@ BINARY_STREAM_WRITE(PIValueTree) {
//! \relatesalso PIBinaryStream
//! \~english Restore operator.
//! \~russian Оператор извлечения.
BINARY_STREAM_READ (PIValueTree) {
PIByteArray csba; s >> csba;
BINARY_STREAM_READ(PIValueTree) {
PIByteArray csba;
s >> csba;
PIChunkStream cs(csba);
while (!cs.atEnd()) {
switch (cs.read()) {
@@ -140,7 +139,7 @@ BINARY_STREAM_READ (PIValueTree) {
//! \relatesalso PICout
//! \~english Output operator to \a PICout.
//! \~russian Оператор вывода в \a PICout.
inline PICout operator <<(PICout s, const PIValueTree & v) {
inline PICout operator<<(PICout s, const PIValueTree & v) {
s.space();
s.saveAndSetControls(0);
PIString str;

1134
libs/main/types/pivariant.cpp
View File

@@ -65,18 +65,17 @@
#ifdef CUSTOM_PIVARIANT
PIMap<uint, __PIVariantInfo__ * > * __PIVariantInfoStorage__::map = nullptr;
PIMap<uint, __PIVariantInfo__ *> * __PIVariantInfoStorage__::map = nullptr;
#endif
PIVariant::PIVariant() {
}
PIVariant::PIVariant() {}
PIVariant::PIVariant(const PIVariant & v) {
_type = v._type;
_type = v._type;
_content = v._content;
_typeID = v._typeID;
_typeID = v._typeID;
#ifdef CUSTOM_PIVARIANT
_info = v._info;
#endif
@@ -90,38 +89,96 @@ PIVariant::PIVariant(PIVariant && v) {
void PIVariant::setValueFromString(const PIString & v) {
switch (_type) {
case PIVariant::pivBool: {setValue(v.toBool());} break;
case PIVariant::pivChar: {setValue(v.toChar());} break;
case PIVariant::pivUChar: {setValue((uchar)v.toChar());} break;
case PIVariant::pivShort: {setValue(v.toShort());} break;
case PIVariant::pivUShort: {setValue(v.toUShort());} break;
case PIVariant::pivInt: {setValue(v.toInt());} break;
case PIVariant::pivUInt: {setValue(v.toUInt());} break;
case PIVariant::pivLLong: {setValue(v.toLLong());} break;
case PIVariant::pivULLong: {setValue(v.toULLong());} break;
case PIVariant::pivFloat: {setValue(v.toFloat());} break;
case PIVariant::pivDouble: {setValue(v.toDouble());} break;
case PIVariant::pivLDouble: {setValue(v.toLDouble());} break;
case PIVariant::pivTime: {setValue(PITime::fromString(v));} break;
case PIVariant::pivDate: {setValue(PIDate::fromString(v));} break;
case PIVariant::pivDateTime: {setValue(PIDateTime::fromString(v));} break;
case PIVariant::pivString: {setValue(v);} break;
case PIVariant::pivStringList: {setValue(v.split("%|%"));} break;
case PIVariant::pivEnum: {PIVariantTypes::Enum r = toEnum(); r.selectName(v); setValue(r);} break;
case PIVariant::pivFile: {PIVariantTypes::File r = toFile(); r.file = v; setValue(r);} break;
case PIVariant::pivDir: {PIVariantTypes::Dir r = toDir(); r.dir = v; setValue(r);} break;
case PIVariant::pivColor: {setValue(PIVariantTypes::Color::fromString(v));} break;
case PIVariant::pivIODevice: {setValue(PIVariantTypes::IODevice());} break; // TODO
case PIVariant::pivPoint: {PIStringList l = v.split(';'); if (l.size() >= 2) setValue(PIPointd(l[0].toDouble(), l[1].toDouble()));} break;
case PIVariant::pivRect: {PIStringList l = v.split(';'); if (l.size() >= 4) setValue(PIRectd(l[0].toDouble(), l[1].toDouble(), l[2].toDouble(), l[3].toDouble()));} break;
case PIVariant::pivLine: {PIStringList l = v.split(';'); if (l.size() >= 4) setValue(PILined(l[0].toDouble(), l[1].toDouble(), l[2].toDouble(), l[3].toDouble()));} break;
case PIVariant::pivBool: {
setValue(v.toBool());
} break;
case PIVariant::pivChar: {
setValue(v.toChar());
} break;
case PIVariant::pivUChar: {
setValue((uchar)v.toChar());
} break;
case PIVariant::pivShort: {
setValue(v.toShort());
} break;
case PIVariant::pivUShort: {
setValue(v.toUShort());
} break;
case PIVariant::pivInt: {
setValue(v.toInt());
} break;
case PIVariant::pivUInt: {
setValue(v.toUInt());
} break;
case PIVariant::pivLLong: {
setValue(v.toLLong());
} break;
case PIVariant::pivULLong: {
setValue(v.toULLong());
} break;
case PIVariant::pivFloat: {
setValue(v.toFloat());
} break;
case PIVariant::pivDouble: {
setValue(v.toDouble());
} break;
case PIVariant::pivLDouble: {
setValue(v.toLDouble());
} break;
case PIVariant::pivTime: {
setValue(PITime::fromString(v));
} break;
case PIVariant::pivDate: {
setValue(PIDate::fromString(v));
} break;
case PIVariant::pivDateTime: {
setValue(PIDateTime::fromString(v));
} break;
case PIVariant::pivString: {
setValue(v);
} break;
case PIVariant::pivStringList: {
setValue(v.split("%|%"));
} break;
case PIVariant::pivEnum: {
setValue(PIVariantTypes::Enum::fromString(v));
} break;
case PIVariant::pivFile: {
PIVariantTypes::File r = toFile();
r.file = v;
setValue(r);
} break;
case PIVariant::pivDir: {
PIVariantTypes::Dir r = toDir();
r.dir = v;
setValue(r);
} break;
case PIVariant::pivColor: {
setValue(PIVariantTypes::Color::fromString(v));
} break;
case PIVariant::pivIODevice: {
setValue(PIVariantTypes::IODevice());
} break; // TODO
case PIVariant::pivPoint: {
PIStringList l = v.split(';');
if (l.size() >= 2) setValue(PIPointd(l[0].toDouble(), l[1].toDouble()));
} break;
case PIVariant::pivRect: {
PIStringList l = v.split(';');
if (l.size() >= 4) setValue(PIRectd(l[0].toDouble(), l[1].toDouble(), l[2].toDouble(), l[3].toDouble()));
} break;
case PIVariant::pivLine: {
PIStringList l = v.split(';');
if (l.size() >= 4) setValue(PILined(l[0].toDouble(), l[1].toDouble(), l[2].toDouble(), l[3].toDouble()));
} break;
case PIVariant::pivCustom: {
#ifdef CUSTOM_PIVARIANT
__PIVariantInfo__ * vi = __PIVariantInfoStorage__::get()->map->value(__PIVariantFunctions__<PIString>::typeIDHelper());
if (vi) {
__PIVariantInfo__::castHelperFunc cf = vi->cast.value(_typeID);
if (cf) {
PIByteArray sba; sba << v;
PIByteArray sba;
sba << v;
_content = cf(sba);
}
}
@@ -132,10 +189,10 @@ void PIVariant::setValueFromString(const PIString & v) {
}
PIVariant & PIVariant::operator =(const PIVariant & v) {
_type = v._type;
PIVariant & PIVariant::operator=(const PIVariant & v) {
_type = v._type;
_content = v._content;
_typeID = v._typeID;
_typeID = v._typeID;
#ifdef CUSTOM_PIVARIANT
_info = v._info;
#endif
@@ -143,13 +200,13 @@ PIVariant & PIVariant::operator =(const PIVariant & v) {
}
PIVariant & PIVariant::operator =(PIVariant && v) {
PIVariant & PIVariant::operator=(PIVariant && v) {
swap(v);
return *this;
}
bool PIVariant::operator ==(const PIVariant & v) const {
bool PIVariant::operator==(const PIVariant & v) const {
return (_typeID == v._typeID) && (_content == v._content);
}
@@ -161,7 +218,8 @@ PIVariant::Type PIVariant::typeFromName(const PIString & tname) {
if (s == "short" || s == "shortint" || s == "signedshort" || s == "signedshortint" || s == "sword") return PIVariant::pivShort;
if (s == "int" || s == "signed" || s == "signedint") return PIVariant::pivInt;
if (s == "long" || s == "longint" || s == "signedlong" || s == "signedlongint" || s == "sdword") return PIVariant::pivInt;
if (s == "llong" || s == "longlong" || s == "longlongint" || s == "signedlonglong" || s == "signedlonglongint" || s == "sqword") return PIVariant::pivLLong;
if (s == "llong" || s == "longlong" || s == "longlongint" || s == "signedlonglong" || s == "signedlonglongint" || s == "sqword")
return PIVariant::pivLLong;
if (s == "uchar" || s == "byte") return PIVariant::pivUChar;
if (s == "ushort" || s == "unsignedshort" || s == "unsignedshortint" || s == "word") return PIVariant::pivUShort;
if (s == "uint" || s == "unsigned" || s == "unsignedint") return PIVariant::pivUInt;
@@ -173,10 +231,13 @@ PIVariant::Type PIVariant::typeFromName(const PIString & tname) {
if (s == "complexd" || s == "complex<double>") return PIVariant::pivComplexd;
if (s == "complexld" || s == "complex<ldouble>" || s == "complex<longdouble>") return PIVariant::pivComplexld;
if (s == "pibitarray" || s == "bitarray") return PIVariant::pivBitArray;
if (s == "pibytearray" || s == "bytearray" || s == "vector<uchar>" || s == "pivector<uchar>" || s == "vector<unsignedchar>" || s == "pivector<unsignedchar>" ||
s == "vector<char>" || s == "pivector<char>") return PIVariant::pivByteArray;
if (s == "pibytearray" || s == "bytearray" || s == "vector<uchar>" || s == "pivector<uchar>" || s == "vector<unsignedchar>" ||
s == "pivector<unsignedchar>" || s == "vector<char>" || s == "pivector<char>")
return PIVariant::pivByteArray;
if (s == "pistring" || s == "string" || s == "text") return PIVariant::pivString;
if (s == "pistringlist" || s == "stringlist" || s == "vector<string>" || s == "vector<pistring>" || s == "pivector<string>" || s == "pivector<pistring>") return PIVariant::pivStringList;
if (s == "pistringlist" || s == "stringlist" || s == "vector<string>" || s == "vector<pistring>" || s == "pivector<string>" ||
s == "pivector<pistring>")
return PIVariant::pivStringList;
if (s == "pitime" || s == "time") return PIVariant::pivTime;
if (s == "pidate" || s == "date") return PIVariant::pivDate;
if (s == "pidatetime" || s == "datetime") return PIVariant::pivDateTime;
@@ -231,8 +292,7 @@ PIVariant::Type PIVariant::typeFromID(uint type_id) {
if (type_id == typeID<PIMathMatrixd>()) return PIVariant::pivMathMatrix;
if (type_id == typeID<PILined>()) return PIVariant::pivLine;
#ifdef CUSTOM_PIVARIANT
if (__PIVariantInfoStorage__::get()->map->contains(type_id))
return PIVariant::pivCustom;
if (__PIVariantInfoStorage__::get()->map->contains(type_id)) return PIVariant::pivCustom;
#endif
return PIVariant::pivInvalid;
}
@@ -246,6 +306,7 @@ uint PIVariant::typeIDFromName(const PIString & tname) {
}
// clang-format off
uint PIVariant::typeIDFromType(Type type) {
switch (type) {
case (PIVariant::pivBool ): return typeID<bool >();
@@ -284,12 +345,12 @@ uint PIVariant::typeIDFromType(Type type) {
}
return 0;
}
// clang-format on
PIString PIVariant::typeName() const {
#ifdef CUSTOM_PIVARIANT
if ((_type == pivCustom) && _info)
return _info->typeName;
if ((_type == pivCustom) && _info) return _info->typeName;
#endif
return typeName(_type);
}
@@ -320,8 +381,8 @@ PIVariant PIVariant::fromValue(const PIByteArray & c, uint type_id) {
return ret;
}
}
ret._type = t;
ret._typeID = type_id;
ret._type = t;
ret._typeID = type_id;
ret._content = c;
return ret;
}
@@ -342,8 +403,8 @@ PIVariant PIVariant::fromValue(const PIByteArray & c, const PIString & type) {
return ret;
}
}
ret._type = t;
ret._typeID = type.hash();
ret._type = t;
ret._typeID = type.hash();
ret._content = c;
return ret;
}
@@ -411,6 +472,25 @@ PIString PIVariant::typeNameFromID(uint type_id) {
}
PIVector<uint> PIVariant::knownTypeIDs() {
PIVector<uint> ret;
#ifdef CUSTOM_PIVARIANT
auto it = __PIVariantInfoStorage__::get()->map->makeIterator();
while (it.next())
ret << it.key();
#endif
return ret;
}
int PIVariant::knownTypeIDsCount() {
#ifdef CUSTOM_PIVARIANT
return __PIVariantInfoStorage__::get()->map->size_s();
#endif
return 0;
}
//! \~\brief
//! \~english Returns variant content as boolean
//! \~russian Возвращает содержимое как boolean
@@ -433,20 +513,77 @@ PIString PIVariant::typeNameFromID(uint type_id) {
bool PIVariant::toBool() const {
PIByteArray ba(_content);
switch (_type) {
case PIVariant::pivBool: {bool r; ba >> r; return r;}
case PIVariant::pivChar: {char r; ba >> r; return r != 0;}
case PIVariant::pivUChar: {uchar r; ba >> r; return r != 0;}
case PIVariant::pivShort: {short r; ba >> r; return r != 0;}
case PIVariant::pivUShort: {ushort r; ba >> r; return r != 0;}
case PIVariant::pivInt: {int r; ba >> r; return r != 0;}
case PIVariant::pivUInt: {uint r; ba >> r; return r != 0;}
case PIVariant::pivLLong: {llong r; ba >> r; return r != 0;}
case PIVariant::pivULLong: {ullong r; ba >> r; return r != 0;}
case PIVariant::pivFloat: {float r; ba >> r; return r > 0.f;}
case PIVariant::pivDouble: {double r; ba >> r; return r > 0.;}
case PIVariant::pivLDouble: {ldouble r; ba >> r; return r > 0.;}
case PIVariant::pivString: {PIString r; ba >> r; return r.toBool();}
case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return false; return r.front().toBool();}
case PIVariant::pivBool: {
bool r;
ba >> r;
return r;
}
case PIVariant::pivChar: {
char r;
ba >> r;
return r != 0;
}
case PIVariant::pivUChar: {
uchar r;
ba >> r;
return r != 0;
}
case PIVariant::pivShort: {
short r;
ba >> r;
return r != 0;
}
case PIVariant::pivUShort: {
ushort r;
ba >> r;
return r != 0;
}
case PIVariant::pivInt: {
int r;
ba >> r;
return r != 0;
}
case PIVariant::pivUInt: {
uint r;
ba >> r;
return r != 0;
}
case PIVariant::pivLLong: {
llong r;
ba >> r;
return r != 0;
}
case PIVariant::pivULLong: {
ullong r;
ba >> r;
return r != 0;
}
case PIVariant::pivFloat: {
float r;
ba >> r;
return r > 0.f;
}
case PIVariant::pivDouble: {
double r;
ba >> r;
return r > 0.;
}
case PIVariant::pivLDouble: {
ldouble r;
ba >> r;
return r > 0.;
}
case PIVariant::pivString: {
PIString r;
ba >> r;
return r.toBool();
}
case PIVariant::pivStringList: {
PIStringList r;
ba >> r;
if (r.isEmpty()) return false;
return r.front().toBool();
}
case PIVariant::pivCustom: return getAsValue<bool>(*this);
default: break;
}
@@ -454,7 +591,6 @@ bool PIVariant::toBool() const {
}
//! \~\brief
//! \~english Returns variant content as int
//! \~russian Возвращает содержимое как int
@@ -477,22 +613,87 @@ bool PIVariant::toBool() const {
int PIVariant::toInt() const {
PIByteArray ba(_content);
switch (_type) {
case PIVariant::pivBool: {bool r; ba >> r; return r;}
case PIVariant::pivChar: {char r; ba >> r; return r;}
case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
case PIVariant::pivShort: {short r; ba >> r; return r;}
case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
case PIVariant::pivInt: {int r; ba >> r; return r;}
case PIVariant::pivUInt: {uint r; ba >> r; return r;}
case PIVariant::pivLLong: {llong r; ba >> r; return r;}
case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
case PIVariant::pivFloat: {float r; ba >> r; return r;}
case PIVariant::pivDouble: {double r; ba >> r; return r;}
case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
case PIVariant::pivString: {PIString r; ba >> r; return r.toInt();}
case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0; return r.front().toInt();}
case PIVariant::pivEnum: {PIVariantTypes::Enum r; ba >> r; return r.selectedValue();}
case PIVariant::pivColor: {PIVariantTypes::Color r; ba >> r; return (int)r.rgba;}
case PIVariant::pivBool: {
bool r;
ba >> r;
return r;
}
case PIVariant::pivChar: {
char r;
ba >> r;
return r;
}
case PIVariant::pivUChar: {
uchar r;
ba >> r;
return r;
}
case PIVariant::pivShort: {
short r;
ba >> r;
return r;
}
case PIVariant::pivUShort: {
ushort r;
ba >> r;
return r;
}
case PIVariant::pivInt: {
int r;
ba >> r;
return r;
}
case PIVariant::pivUInt: {
uint r;
ba >> r;
return r;
}
case PIVariant::pivLLong: {
llong r;
ba >> r;
return r;
}
case PIVariant::pivULLong: {
ullong r;
ba >> r;
return r;
}
case PIVariant::pivFloat: {
float r;
ba >> r;
return r;
}
case PIVariant::pivDouble: {
double r;
ba >> r;
return r;
}
case PIVariant::pivLDouble: {
ldouble r;
ba >> r;
return r;
}
case PIVariant::pivString: {
PIString r;
ba >> r;
return r.toInt();
}
case PIVariant::pivStringList: {
PIStringList r;
ba >> r;
if (r.isEmpty()) return 0;
return r.front().toInt();
}
case PIVariant::pivEnum: {
PIVariantTypes::Enum r;
ba >> r;
return r.selectedValue();
}
case PIVariant::pivColor: {
PIVariantTypes::Color r;
ba >> r;
return (int)r.rgba;
}
case PIVariant::pivCustom: return getAsValue<int>(*this);
default: break;
}
@@ -522,21 +723,82 @@ int PIVariant::toInt() const {
llong PIVariant::toLLong() const {
PIByteArray ba(_content);
switch (_type) {
case PIVariant::pivBool: {bool r; ba >> r; return r;}
case PIVariant::pivChar: {char r; ba >> r; return r;}
case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
case PIVariant::pivShort: {short r; ba >> r; return r;}
case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
case PIVariant::pivInt: {int r; ba >> r; return r;}
case PIVariant::pivUInt: {uint r; ba >> r; return r;}
case PIVariant::pivLLong: {llong r; ba >> r; return r;}
case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
case PIVariant::pivFloat: {float r; ba >> r; return r;}
case PIVariant::pivDouble: {double r; ba >> r; return r;}
case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
case PIVariant::pivString: {PIString r; ba >> r; return r.toLLong();}
case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0L; return r.front().toLLong();}
case PIVariant::pivEnum: {PIVariantTypes::Enum r; ba >> r; return llong(r.selectedValue());}
case PIVariant::pivBool: {
bool r;
ba >> r;
return r;
}
case PIVariant::pivChar: {
char r;
ba >> r;
return r;
}
case PIVariant::pivUChar: {
uchar r;
ba >> r;
return r;
}
case PIVariant::pivShort: {
short r;
ba >> r;
return r;
}
case PIVariant::pivUShort: {
ushort r;
ba >> r;
return r;
}
case PIVariant::pivInt: {
int r;
ba >> r;
return r;
}
case PIVariant::pivUInt: {
uint r;
ba >> r;
return r;
}
case PIVariant::pivLLong: {
llong r;
ba >> r;
return r;
}
case PIVariant::pivULLong: {
ullong r;
ba >> r;
return r;
}
case PIVariant::pivFloat: {
float r;
ba >> r;
return r;
}
case PIVariant::pivDouble: {
double r;
ba >> r;
return r;
}
case PIVariant::pivLDouble: {
ldouble r;
ba >> r;
return r;
}
case PIVariant::pivString: {
PIString r;
ba >> r;
return r.toLLong();
}
case PIVariant::pivStringList: {
PIStringList r;
ba >> r;
if (r.isEmpty()) return 0L;
return r.front().toLLong();
}
case PIVariant::pivEnum: {
PIVariantTypes::Enum r;
ba >> r;
return llong(r.selectedValue());
}
case PIVariant::pivCustom: return getAsValue<llong>(*this);
default: break;
}
@@ -566,21 +828,82 @@ llong PIVariant::toLLong() const {
float PIVariant::toFloat() const {
PIByteArray ba(_content);
switch (_type) {
case PIVariant::pivBool: {bool r; ba >> r; return r;}
case PIVariant::pivChar: {char r; ba >> r; return r;}
case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
case PIVariant::pivShort: {short r; ba >> r; return r;}
case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
case PIVariant::pivInt: {int r; ba >> r; return r;}
case PIVariant::pivUInt: {uint r; ba >> r; return r;}
case PIVariant::pivLLong: {llong r; ba >> r; return r;}
case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
case PIVariant::pivFloat: {float r; ba >> r; return r;}
case PIVariant::pivDouble: {double r; ba >> r; return r;}
case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
case PIVariant::pivString: {PIString r; ba >> r; return r.toFloat();}
case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0.f; return r.front().toFloat();}
case PIVariant::pivEnum: {PIVariantTypes::Enum r; ba >> r; return float(r.selectedValue());}
case PIVariant::pivBool: {
bool r;
ba >> r;
return r;
}
case PIVariant::pivChar: {
char r;
ba >> r;
return r;
}
case PIVariant::pivUChar: {
uchar r;
ba >> r;
return r;
}
case PIVariant::pivShort: {
short r;
ba >> r;
return r;
}
case PIVariant::pivUShort: {
ushort r;
ba >> r;
return r;
}
case PIVariant::pivInt: {
int r;
ba >> r;
return r;
}
case PIVariant::pivUInt: {
uint r;
ba >> r;
return r;
}
case PIVariant::pivLLong: {
llong r;
ba >> r;
return r;
}
case PIVariant::pivULLong: {
ullong r;
ba >> r;
return r;
}
case PIVariant::pivFloat: {
float r;
ba >> r;
return r;
}
case PIVariant::pivDouble: {
double r;
ba >> r;
return r;
}
case PIVariant::pivLDouble: {
ldouble r;
ba >> r;
return r;
}
case PIVariant::pivString: {
PIString r;
ba >> r;
return r.toFloat();
}
case PIVariant::pivStringList: {
PIStringList r;
ba >> r;
if (r.isEmpty()) return 0.f;
return r.front().toFloat();
}
case PIVariant::pivEnum: {
PIVariantTypes::Enum r;
ba >> r;
return float(r.selectedValue());
}
case PIVariant::pivCustom: return getAsValue<float>(*this);
default: break;
}
@@ -610,21 +933,82 @@ float PIVariant::toFloat() const {
double PIVariant::toDouble() const {
PIByteArray ba(_content);
switch (_type) {
case PIVariant::pivBool: {bool r; ba >> r; return r;}
case PIVariant::pivChar: {char r; ba >> r; return r;}
case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
case PIVariant::pivShort: {short r; ba >> r; return r;}
case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
case PIVariant::pivInt: {int r; ba >> r; return r;}
case PIVariant::pivUInt: {uint r; ba >> r; return r;}
case PIVariant::pivLLong: {llong r; ba >> r; return r;}
case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
case PIVariant::pivFloat: {float r; ba >> r; return r;}
case PIVariant::pivDouble: {double r; ba >> r; return r;}
case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
case PIVariant::pivString: {PIString r; ba >> r; return r.toDouble();}
case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0.; return r.front().toDouble();}
case PIVariant::pivEnum: {PIVariantTypes::Enum r; ba >> r; return double(r.selectedValue());}
case PIVariant::pivBool: {
bool r;
ba >> r;
return r;
}
case PIVariant::pivChar: {
char r;
ba >> r;
return r;
}
case PIVariant::pivUChar: {
uchar r;
ba >> r;
return r;
}
case PIVariant::pivShort: {
short r;
ba >> r;
return r;
}
case PIVariant::pivUShort: {
ushort r;
ba >> r;
return r;
}
case PIVariant::pivInt: {
int r;
ba >> r;
return r;
}
case PIVariant::pivUInt: {
uint r;
ba >> r;
return r;
}
case PIVariant::pivLLong: {
llong r;
ba >> r;
return r;
}
case PIVariant::pivULLong: {
ullong r;
ba >> r;
return r;
}
case PIVariant::pivFloat: {
float r;
ba >> r;
return r;
}
case PIVariant::pivDouble: {
double r;
ba >> r;
return r;
}
case PIVariant::pivLDouble: {
ldouble r;
ba >> r;
return r;
}
case PIVariant::pivString: {
PIString r;
ba >> r;
return r.toDouble();
}
case PIVariant::pivStringList: {
PIStringList r;
ba >> r;
if (r.isEmpty()) return 0.;
return r.front().toDouble();
}
case PIVariant::pivEnum: {
PIVariantTypes::Enum r;
ba >> r;
return double(r.selectedValue());
}
case PIVariant::pivCustom: return getAsValue<double>(*this);
default: break;
}
@@ -654,21 +1038,82 @@ double PIVariant::toDouble() const {
ldouble PIVariant::toLDouble() const {
PIByteArray ba(_content);
switch (_type) {
case PIVariant::pivBool: {bool r; ba >> r; return r;}
case PIVariant::pivChar: {char r; ba >> r; return r;}
case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
case PIVariant::pivShort: {short r; ba >> r; return r;}
case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
case PIVariant::pivInt: {int r; ba >> r; return r;}
case PIVariant::pivUInt: {uint r; ba >> r; return r;}
case PIVariant::pivLLong: {llong r; ba >> r; return r;}
case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
case PIVariant::pivFloat: {float r; ba >> r; return r;}
case PIVariant::pivDouble: {double r; ba >> r; return r;}
case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
case PIVariant::pivString: {PIString r; ba >> r; return r.toLDouble();}
case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0.; return r.front().toLDouble();}
case PIVariant::pivEnum: {PIVariantTypes::Enum r; ba >> r; return ldouble(r.selectedValue());}
case PIVariant::pivBool: {
bool r;
ba >> r;
return r;
}
case PIVariant::pivChar: {
char r;
ba >> r;
return r;
}
case PIVariant::pivUChar: {
uchar r;
ba >> r;
return r;
}
case PIVariant::pivShort: {
short r;
ba >> r;
return r;
}
case PIVariant::pivUShort: {
ushort r;
ba >> r;
return r;
}
case PIVariant::pivInt: {
int r;
ba >> r;
return r;
}
case PIVariant::pivUInt: {
uint r;
ba >> r;
return r;
}
case PIVariant::pivLLong: {
llong r;
ba >> r;
return r;
}
case PIVariant::pivULLong: {
ullong r;
ba >> r;
return r;
}
case PIVariant::pivFloat: {
float r;
ba >> r;
return r;
}
case PIVariant::pivDouble: {
double r;
ba >> r;
return r;
}
case PIVariant::pivLDouble: {
ldouble r;
ba >> r;
return r;
}
case PIVariant::pivString: {
PIString r;
ba >> r;
return r.toLDouble();
}
case PIVariant::pivStringList: {
PIStringList r;
ba >> r;
if (r.isEmpty()) return 0.;
return r.front().toLDouble();
}
case PIVariant::pivEnum: {
PIVariantTypes::Enum r;
ba >> r;
return ldouble(r.selectedValue());
}
case PIVariant::pivCustom: return getAsValue<float>(*this);
default: break;
}
@@ -693,10 +1138,24 @@ ldouble PIVariant::toLDouble() const {
//!
PITime PIVariant::toTime() const {
PIByteArray ba(_content);
if (_type == PIVariant::pivString) {PIString r; ba >> r; return PITime::fromString(r);}
if (_type == PIVariant::pivTime) {PITime r; ba >> r; return r;}
if (_type == PIVariant::pivDateTime) {PIDateTime r; ba >> r; return r.time();}
if (_type == PIVariant::pivCustom) {return getAsValue<PITime>(*this);}
if (_type == PIVariant::pivString) {
PIString r;
ba >> r;
return PITime::fromString(r);
}
if (_type == PIVariant::pivTime) {
PITime r;
ba >> r;
return r;
}
if (_type == PIVariant::pivDateTime) {
PIDateTime r;
ba >> r;
return r.time();
}
if (_type == PIVariant::pivCustom) {
return getAsValue<PITime>(*this);
}
return PITime();
}
@@ -718,10 +1177,24 @@ PITime PIVariant::toTime() const {
//!
PIDate PIVariant::toDate() const {
PIByteArray ba(_content);
if (_type == PIVariant::pivString) {PIString r; ba >> r; return PIDate::fromString(r);}
if (_type == PIVariant::pivDate) {PIDate r; ba >> r; return r;}
if (_type == PIVariant::pivDateTime) {PIDateTime r; ba >> r; return r.date();}
if (_type == PIVariant::pivCustom) {return getAsValue<PIDate>(*this);}
if (_type == PIVariant::pivString) {
PIString r;
ba >> r;
return PIDate::fromString(r);
}
if (_type == PIVariant::pivDate) {
PIDate r;
ba >> r;
return r;
}
if (_type == PIVariant::pivDateTime) {
PIDateTime r;
ba >> r;
return r.date();
}
if (_type == PIVariant::pivCustom) {
return getAsValue<PIDate>(*this);
}
return PIDate();
}
@@ -745,11 +1218,29 @@ PIDate PIVariant::toDate() const {
//!
PIDateTime PIVariant::toDateTime() const {
PIByteArray ba(_content);
if (_type == PIVariant::pivString) {PIString r; ba >> r; return PIDateTime::fromString(r);}
if (_type == PIVariant::pivTime) {PITime r; ba >> r; return PIDateTime(r);}
if (_type == PIVariant::pivDate) {PIDate r; ba >> r; return PIDateTime(r);}
if (_type == PIVariant::pivDateTime) {PIDateTime r; ba >> r; return r;}
if (_type == PIVariant::pivCustom) {return getAsValue<PIDateTime>(*this);}
if (_type == PIVariant::pivString) {
PIString r;
ba >> r;
return PIDateTime::fromString(r);
}
if (_type == PIVariant::pivTime) {
PITime r;
ba >> r;
return PIDateTime(r);
}
if (_type == PIVariant::pivDate) {
PIDate r;
ba >> r;
return PIDateTime(r);
}
if (_type == PIVariant::pivDateTime) {
PIDateTime r;
ba >> r;
return r;
}
if (_type == PIVariant::pivCustom) {
return getAsValue<PIDateTime>(*this);
}
return PIDateTime();
}
@@ -769,8 +1260,14 @@ PIDateTime PIVariant::toDateTime() const {
//!
PISystemTime PIVariant::toSystemTime() const {
PIByteArray ba(_content);
if (_type == PIVariant::pivSystemTime) {PISystemTime r; ba >> r; return r;}
if (_type == PIVariant::pivCustom) {return getAsValue<PISystemTime>(*this);}
if (_type == PIVariant::pivSystemTime) {
PISystemTime r;
ba >> r;
return r;
}
if (_type == PIVariant::pivCustom) {
return getAsValue<PISystemTime>(*this);
}
return PISystemTime::fromSeconds(toDouble());
}
@@ -802,31 +1299,134 @@ PISystemTime PIVariant::toSystemTime() const {
PIString PIVariant::toString() const {
PIByteArray ba(_content);
switch (_type) {
case PIVariant::pivBool: {bool r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::pivChar: {char r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::pivUChar: {uchar r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::pivShort: {short r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::pivUShort: {ushort r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::pivInt: {int r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::pivUInt: {uint r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::pivLLong: {llong r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::pivULLong: {ullong r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::pivFloat: {float r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::pivDouble: {double r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::pivLDouble: {ldouble r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::pivTime: {PITime r; ba >> r; return r.toString();}
case PIVariant::pivDate: {PIDate r; ba >> r; return r.toString();}
case PIVariant::pivDateTime: {PIDateTime r; ba >> r; return r.toString();}
case PIVariant::pivString: {PIString r; ba >> r; return r;}
case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return PIString(); return r.join(";");}
case PIVariant::pivEnum: {PIVariantTypes::Enum r; ba >> r; return r.selectedName();}
case PIVariant::pivFile: {PIVariantTypes::File r; ba >> r; return r.file;}
case PIVariant::pivDir: {PIVariantTypes::Dir r; ba >> r; return r.dir;}
case PIVariant::pivColor: {PIVariantTypes::Color r; ba >> r; return r.toName();}
case PIVariant::pivIODevice: {PIVariantTypes::IODevice r; ba >> r; return "IODevice";} // TODO
case PIVariant::pivPoint: {PIPointd r; ba >> r; return PIString::fromNumber(r.x) + ";" + PIString::fromNumber(r.y);} break;
case PIVariant::pivRect: {PIRectd r; ba >> r; return PIString::fromNumber(r.left()) + ";" + PIString::fromNumber(r.bottom()) + ";" + PIString::fromNumber(r.width()) + ";" + PIString::fromNumber(r.height());} break;
case PIVariant::pivLine: {PILined r; ba >> r; return PIString::fromNumber(r.p0.x) + ";" + PIString::fromNumber(r.p0.y) + ";" + PIString::fromNumber(r.p1.x) + ";" + PIString::fromNumber(r.p1.y);} break;
case PIVariant::pivBool: {
bool r;
ba >> r;
return PIString::fromNumber(r);
}
case PIVariant::pivChar: {
char r;
ba >> r;
return PIString::fromNumber(r);
}
case PIVariant::pivUChar: {
uchar r;
ba >> r;
return PIString::fromNumber(r);
}
case PIVariant::pivShort: {
short r;
ba >> r;
return PIString::fromNumber(r);
}
case PIVariant::pivUShort: {
ushort r;
ba >> r;
return PIString::fromNumber(r);
}
case PIVariant::pivInt: {
int r;
ba >> r;
return PIString::fromNumber(r);
}
case PIVariant::pivUInt: {
uint r;
ba >> r;
return PIString::fromNumber(r);
}
case PIVariant::pivLLong: {
llong r;
ba >> r;
return PIString::fromNumber(r);
}
case PIVariant::pivULLong: {
ullong r;
ba >> r;
return PIString::fromNumber(r);
}
case PIVariant::pivFloat: {
float r;
ba >> r;
return PIString::fromNumber(r);
}
case PIVariant::pivDouble: {
double r;
ba >> r;
return PIString::fromNumber(r);
}
case PIVariant::pivLDouble: {
ldouble r;
ba >> r;
return PIString::fromNumber(r);
}
case PIVariant::pivTime: {
PITime r;
ba >> r;
return r.toString();
}
case PIVariant::pivDate: {
PIDate r;
ba >> r;
return r.toString();
}
case PIVariant::pivDateTime: {
PIDateTime r;
ba >> r;
return r.toString();
}
case PIVariant::pivString: {
PIString r;
ba >> r;
return r;
}
case PIVariant::pivStringList: {
PIStringList r;
ba >> r;
if (r.isEmpty()) return PIString();
return r.join(";");
}
case PIVariant::pivEnum: {
PIVariantTypes::Enum r;
ba >> r;
return r.toString();
}
case PIVariant::pivFile: {
PIVariantTypes::File r;
ba >> r;
return r.file;
}
case PIVariant::pivDir: {
PIVariantTypes::Dir r;
ba >> r;
return r.dir;
}
case PIVariant::pivColor: {
PIVariantTypes::Color r;
ba >> r;
return r.toName();
}
case PIVariant::pivIODevice: {
PIVariantTypes::IODevice r;
ba >> r;
return "IODevice";
} // TODO
case PIVariant::pivPoint: {
PIPointd r;
ba >> r;
return PIString::fromNumber(r.x) + ";" + PIString::fromNumber(r.y);
} break;
case PIVariant::pivRect: {
PIRectd r;
ba >> r;
return PIString::fromNumber(r.left()) + ";" + PIString::fromNumber(r.bottom()) + ";" + PIString::fromNumber(r.width()) + ";" +
PIString::fromNumber(r.height());
} break;
case PIVariant::pivLine: {
PILined r;
ba >> r;
return PIString::fromNumber(r.p0.x) + ";" + PIString::fromNumber(r.p0.y) + ";" + PIString::fromNumber(r.p1.x) + ";" +
PIString::fromNumber(r.p1.y);
} break;
case PIVariant::pivCustom: return getAsValue<PIString>(*this);
default: break;
}
@@ -849,9 +1449,19 @@ PIString PIVariant::toString() const {
//!
PIStringList PIVariant::toStringList() const {
PIByteArray ba(_content);
if (_type == PIVariant::pivStringList) {PIStringList r; ba >> r; return r;}
if (_type == PIVariant::pivEnum) {PIVariantTypes::Enum r; ba >> r; return r.names();}
if (_type == PIVariant::pivCustom) {return getAsValue<PIStringList>(*this);}
if (_type == PIVariant::pivStringList) {
PIStringList r;
ba >> r;
return r;
}
if (_type == PIVariant::pivEnum) {
PIVariantTypes::Enum r;
ba >> r;
return r.names();
}
if (_type == PIVariant::pivCustom) {
return getAsValue<PIStringList>(*this);
}
return PIStringList(toString());
}
@@ -871,8 +1481,14 @@ PIStringList PIVariant::toStringList() const {
//!
PIBitArray PIVariant::toBitArray() const {
PIByteArray ba(_content);
if (_type == PIVariant::pivBitArray) {PIBitArray r; ba >> r; return r;}
if (_type == PIVariant::pivCustom) {return getAsValue<PIBitArray>(*this);}
if (_type == PIVariant::pivBitArray) {
PIBitArray r;
ba >> r;
return r;
}
if (_type == PIVariant::pivCustom) {
return getAsValue<PIBitArray>(*this);
}
return PIBitArray(ullong(toLLong()));
}
@@ -892,8 +1508,14 @@ PIBitArray PIVariant::toBitArray() const {
//!
PIByteArray PIVariant::toByteArray() const {
PIByteArray ba(_content);
if (_type == PIVariant::pivByteArray) {PIByteArray r; ba >> r; return r;}
if (_type == PIVariant::pivCustom) {return getAsValue<PIByteArray>(*this);}
if (_type == PIVariant::pivByteArray) {
PIByteArray r;
ba >> r;
return r;
}
if (_type == PIVariant::pivCustom) {
return getAsValue<PIByteArray>(*this);
}
return PIByteArray();
}
@@ -917,10 +1539,26 @@ PIByteArray PIVariant::toByteArray() const {
//!
PIVariantTypes::Enum PIVariant::toEnum() const {
PIByteArray ba(_content);
if (_type == PIVariant::pivEnum) {PIVariantTypes::Enum r; ba >> r; return r;}
if (_type == PIVariant::pivString) {PIString v; ba >> v; PIVariantTypes::Enum r; r << v; return r;}
if (_type == PIVariant::pivStringList) {PIStringList v; ba >> v; PIVariantTypes::Enum r; r << v; return r;}
if (_type == PIVariant::pivCustom) {return getAsValue<PIVariantTypes::Enum>(*this);}
if (_type == PIVariant::pivEnum) {
PIVariantTypes::Enum r;
ba >> r;
return r;
}
if (_type == PIVariant::pivString) {
PIString v;
ba >> v;
return PIVariantTypes::Enum::fromString(v);
}
if (_type == PIVariant::pivStringList) {
PIStringList v;
ba >> v;
PIVariantTypes::Enum r;
r << v;
return r;
}
if (_type == PIVariant::pivCustom) {
return getAsValue<PIVariantTypes::Enum>(*this);
}
return PIVariantTypes::Enum();
}
@@ -942,9 +1580,21 @@ PIVariantTypes::Enum PIVariant::toEnum() const {
//!
PIVariantTypes::File PIVariant::toFile() const {
PIByteArray ba(_content);
if (_type == PIVariant::pivFile) {PIVariantTypes::File r; ba >> r; return r;}
if (_type == PIVariant::pivString) {PIString v; ba >> v; PIVariantTypes::File r; r.file = v; return r;}
if (_type == PIVariant::pivCustom) {return getAsValue<PIVariantTypes::File>(*this);}
if (_type == PIVariant::pivFile) {
PIVariantTypes::File r;
ba >> r;
return r;
}
if (_type == PIVariant::pivString) {
PIString v;
ba >> v;
PIVariantTypes::File r;
r.file = v;
return r;
}
if (_type == PIVariant::pivCustom) {
return getAsValue<PIVariantTypes::File>(*this);
}
return PIVariantTypes::File();
}
@@ -966,9 +1616,21 @@ PIVariantTypes::File PIVariant::toFile() const {
//!
PIVariantTypes::Dir PIVariant::toDir() const {
PIByteArray ba(_content);
if (_type == PIVariant::pivDir) {PIVariantTypes::Dir r; ba >> r; return r;}
if (_type == PIVariant::pivString) {PIString v; ba >> v; PIVariantTypes::Dir r; r.dir = v; return r;}
if (_type == PIVariant::pivCustom) {return getAsValue<PIVariantTypes::Dir>(*this);}
if (_type == PIVariant::pivDir) {
PIVariantTypes::Dir r;
ba >> r;
return r;
}
if (_type == PIVariant::pivString) {
PIString v;
ba >> v;
PIVariantTypes::Dir r;
r.dir = v;
return r;
}
if (_type == PIVariant::pivCustom) {
return getAsValue<PIVariantTypes::Dir>(*this);
}
return PIVariantTypes::Dir();
}
@@ -990,10 +1652,24 @@ PIVariantTypes::Dir PIVariant::toDir() const {
//!
PIVariantTypes::Color PIVariant::toColor() const {
PIByteArray ba(_content);
if (_type == PIVariant::pivString) {PIString r; ba >> r; return PIVariantTypes::Color::fromString(r);}
if (_type == PIVariant::pivColor) {PIVariantTypes::Color r; ba >> r; return r;}
if (_type == PIVariant::pivInt) {int v; ba >> v; return PIVariantTypes::Color(v);}
if (_type == PIVariant::pivCustom) {return getAsValue<PIVariantTypes::Color>(*this);}
if (_type == PIVariant::pivString) {
PIString r;
ba >> r;
return PIVariantTypes::Color::fromString(r);
}
if (_type == PIVariant::pivColor) {
PIVariantTypes::Color r;
ba >> r;
return r;
}
if (_type == PIVariant::pivInt) {
int v;
ba >> v;
return PIVariantTypes::Color(v);
}
if (_type == PIVariant::pivCustom) {
return getAsValue<PIVariantTypes::Color>(*this);
}
return PIVariantTypes::Color();
}
@@ -1013,7 +1689,11 @@ PIVariantTypes::Color PIVariant::toColor() const {
//!
PIVariantTypes::IODevice PIVariant::toIODevice() const {
PIByteArray ba(_content);
if (_type == PIVariant::pivIODevice) {PIVariantTypes::IODevice r; ba >> r; return r;}
if (_type == PIVariant::pivIODevice) {
PIVariantTypes::IODevice r;
ba >> r;
return r;
}
return PIVariantTypes::IODevice();
}
@@ -1033,8 +1713,17 @@ PIVariantTypes::IODevice PIVariant::toIODevice() const {
//!
PIPointd PIVariant::toPoint() const {
PIByteArray ba(_content);
if (_type == PIVariant::pivString) {PIString r; ba >> r; PIStringList l = r.split(';'); if (l.size() >= 2) return PIPointd(l[0].toDouble(), l[1].toDouble());}
if (_type == PIVariant::pivPoint) {PIPointd r; ba >> r; return r;}
if (_type == PIVariant::pivString) {
PIString r;
ba >> r;
PIStringList l = r.split(';');
if (l.size() >= 2) return PIPointd(l[0].toDouble(), l[1].toDouble());
}
if (_type == PIVariant::pivPoint) {
PIPointd r;
ba >> r;
return r;
}
return PIPointd();
}
@@ -1054,8 +1743,17 @@ PIPointd PIVariant::toPoint() const {
//!
PIRectd PIVariant::toRect() const {
PIByteArray ba(_content);
if (_type == PIVariant::pivString) {PIString r; ba >> r; PIStringList l = r.split(';'); if (l.size() >= 4) return PIRectd(l[0].toDouble(), l[1].toDouble(), l[2].toDouble(), l[3].toDouble());}
if (_type == PIVariant::pivRect) {PIRectd r; ba >> r; return r;}
if (_type == PIVariant::pivString) {
PIString r;
ba >> r;
PIStringList l = r.split(';');
if (l.size() >= 4) return PIRectd(l[0].toDouble(), l[1].toDouble(), l[2].toDouble(), l[3].toDouble());
}
if (_type == PIVariant::pivRect) {
PIRectd r;
ba >> r;
return r;
}
return PIRectd();
}
@@ -1075,8 +1773,17 @@ PIRectd PIVariant::toRect() const {
//!
PILined PIVariant::toLine() const {
PIByteArray ba(_content);
if (_type == PIVariant::pivString) {PIString r; ba >> r; PIStringList l = r.split(';'); if (l.size() >= 4) return PILined(l[0].toDouble(), l[1].toDouble(), l[2].toDouble(), l[3].toDouble());}
if (_type == PIVariant::pivLine) {PILined r; ba >> r; return r;}
if (_type == PIVariant::pivString) {
PIString r;
ba >> r;
PIStringList l = r.split(';');
if (l.size() >= 4) return PILined(l[0].toDouble(), l[1].toDouble(), l[2].toDouble(), l[3].toDouble());
}
if (_type == PIVariant::pivLine) {
PILined r;
ba >> r;
return r;
}
return PILined();
}
@@ -1096,7 +1803,11 @@ PILined PIVariant::toLine() const {
//!
PIMathVectord PIVariant::toMathVector() const {
PIByteArray ba(_content);
if (_type == PIVariant::pivMathVector) {PIMathVectord r; ba >> r; return r;}
if (_type == PIVariant::pivMathVector) {
PIMathVectord r;
ba >> r;
return r;
}
return PIMathVectord();
}
@@ -1116,7 +1827,10 @@ PIMathVectord PIVariant::toMathVector() const {
//!
PIMathMatrixd PIVariant::toMathMatrix() const {
PIByteArray ba(_content);
if (_type == PIVariant::pivMathMatrix) {PIMathMatrixd r; ba >> r; return r;}
if (_type == PIVariant::pivMathMatrix) {
PIMathMatrixd r;
ba >> r;
return r;
}
return PIMathMatrixd();
}

620
libs/main/types/pivariant.h
View File

@@ -3,7 +3,7 @@
* \brief
* \~english Variant type
* \~russian Вариативный тип
*/
*/
/*
PIP - Platform Independent Primitives
Variant type
@@ -26,11 +26,13 @@
#ifndef PIVARIANT_H
#define PIVARIANT_H
#include "pivarianttypes.h"
#include "piconstchars.h"
#include "pitime.h"
#include "pigeometry.h"
#include "pidatetime.h"
#include "piline.h"
#include "pimathmatrix.h"
#include "pipoint.h"
#include "pirect.h"
#include "pivarianttypes.h"
#ifdef DOXYGEN
@@ -60,21 +62,27 @@
template<typename T>
class __PIVariantFunctions__ {
public:
static PIString typeNameHelper() {return PIStringAscii("");}
static uint typeIDHelper() {return 0;}
static PIString typeNameHelper() { return PIStringAscii(""); }
static uint typeIDHelper() { return 0; }
static bool isSimpleHelper() {return false;}
template<typename C> static PIByteArray castHelper(PIByteArray ba) {return PIByteArray();}
template<typename C> static C castVariant(const T & v) {return C();}
static bool isSimpleHelper() { return false; }
template<typename C>
static PIByteArray castHelper(PIByteArray ba) {
return PIByteArray();
}
template<typename C>
static C castVariant(const T & v) {
return C();
}
};
struct PIP_EXPORT __PIVariantInfo__ {
__PIVariantInfo__(const PIString & n, const PIByteArray & e) {
typeName = n;
typeID = n.hash();
empty = e;
typeID = n.hash();
empty = e;
}
typedef PIByteArray(*castHelperFunc)(PIByteArray);
typedef PIByteArray (*castHelperFunc)(PIByteArray);
PIMap<uint, castHelperFunc> cast;
PIByteArray empty;
PIString typeName;
@@ -92,92 +100,121 @@ struct __PIVariantTypeInfo__ {
typedef const T & ConstReferenceType;
};
#define __TYPEINFO_SINGLE(PT, T) \
template<> struct __PIVariantTypeInfo__<T> { \
typedef PT PureType; \
typedef const PT ConstPureType; \
typedef PT * PointerType; \
typedef const PT * ConstPointerType; \
typedef PT & ReferenceType; \
typedef const PT & ConstReferenceType; \
};
# define __TYPEINFO_SINGLE(PT, T) \
template<> \
struct __PIVariantTypeInfo__<T> { \
typedef PT PureType; \
typedef const PT ConstPureType; \
typedef PT * PointerType; \
typedef const PT * ConstPointerType; \
typedef PT & ReferenceType; \
typedef const PT & ConstReferenceType; \
};
#define REGISTER_VARIANT_TYPEINFO(T) \
__TYPEINFO_SINGLE(T, T &) \
__TYPEINFO_SINGLE(T, const T) \
__TYPEINFO_SINGLE(T, const T &)
# define REGISTER_VARIANT_TYPEINFO(T) \
__TYPEINFO_SINGLE(T, T &) \
__TYPEINFO_SINGLE(T, const T) \
__TYPEINFO_SINGLE(T, const T &)
class PIP_EXPORT __PIVariantInfoStorage__ {
public:
__PIVariantInfoStorage__() {if (!map) map = new PIMap<uint, __PIVariantInfo__ * >();}
static __PIVariantInfoStorage__ * get() {static __PIVariantInfoStorage__ * r = new __PIVariantInfoStorage__(); return r;}
static PIMap<uint, __PIVariantInfo__ * > * map;
__PIVariantInfoStorage__() {
if (!map) map = new PIMap<uint, __PIVariantInfo__ *>();
}
static __PIVariantInfoStorage__ * get() {
static __PIVariantInfoStorage__ * r = new __PIVariantInfoStorage__();
return r;
}
static PIMap<uint, __PIVariantInfo__ *> * map;
};
#define REGISTER_VARIANT(classname) \
template<> inline PIString __PIVariantFunctions__< classname >::typeNameHelper() {static PIString tn = PIStringAscii(#classname); return tn;} \
template<> inline uint __PIVariantFunctions__< classname >::typeIDHelper() {static uint ret = PIStringAscii(#classname).hash(); return ret;} \
REGISTER_VARIANT_TYPEINFO(classname) \
STATIC_INITIALIZER_BEGIN \
uint type_id = __PIVariantFunctions__< classname >::typeIDHelper(); \
PIString type_name = __PIVariantFunctions__< classname >::typeNameHelper(); \
if (__PIVariantInfoStorage__::get()->map->contains(type_id)) return; \
PIByteArray empty; empty << classname(); \
(*(__PIVariantInfoStorage__::get()->map))[type_id] = new __PIVariantInfo__(type_name, empty); \
STATIC_INITIALIZER_END
# define REGISTER_VARIANT(classname) \
template<> \
inline PIString __PIVariantFunctions__<classname>::typeNameHelper() { \
static PIString tn = PIStringAscii(#classname); \
return tn; \
} \
template<> \
inline uint __PIVariantFunctions__<classname>::typeIDHelper() { \
static uint ret = PIStringAscii(#classname).hash(); \
return ret; \
} \
REGISTER_VARIANT_TYPEINFO(classname) \
STATIC_INITIALIZER_BEGIN \
uint type_id = __PIVariantFunctions__<classname>::typeIDHelper(); \
PIString type_name = __PIVariantFunctions__<classname>::typeNameHelper(); \
if (__PIVariantInfoStorage__::get()->map->contains(type_id)) return; \
PIByteArray empty; \
empty << classname(); \
(*(__PIVariantInfoStorage__::get()->map))[type_id] = new __PIVariantInfo__(type_name, empty); \
STATIC_INITIALIZER_END
#define REGISTER_VARIANT_CAST_H(classname_from, classname_to) \
template<> template<> inline \
classname_to __PIVariantFunctions__<classname_from>::castVariant<classname_to>(const classname_from & v);
# define REGISTER_VARIANT_CAST_H(classname_from, classname_to) \
template<> \
template<> \
inline classname_to __PIVariantFunctions__<classname_from>::castVariant<classname_to>(const classname_from & v);
#define REGISTER_VARIANT_CAST_CPP(classname_from, classname_to) \
template<> template<> inline \
PIByteArray __PIVariantFunctions__<classname_from>::castHelper<classname_to>(PIByteArray v) { \
classname_from f; v >> f; \
classname_to t = __PIVariantFunctions__<classname_from>::castVariant<classname_to>(f); \
PIByteArray ret; ret << t; \
return ret; \
} \
STATIC_INITIALIZER_BEGIN \
__PIVariantInfo__ * vi(__PIVariantInfoStorage__::get()->map->value(__PIVariantFunctions__< classname_from >::typeIDHelper(), nullptr)); \
if (!vi) { \
piCout << "Warning! Using REGISTER_VARIANT_CAST("#classname_from", "#classname_to") before REGISTER_VARIANT("#classname_from"), ignore."; \
return; \
} \
vi->cast[__PIVariantFunctions__< classname_to >::typeIDHelper()] = __PIVariantFunctions__<classname_from>::castHelper<classname_to>; \
STATIC_INITIALIZER_END \
template<> template<> \
classname_to __PIVariantFunctions__<classname_from>::castVariant<classname_to>(const classname_from & v)
# define REGISTER_VARIANT_CAST_CPP(classname_from, classname_to) \
template<> \
template<> \
inline PIByteArray __PIVariantFunctions__<classname_from>::castHelper<classname_to>(PIByteArray v) { \
classname_from f; \
v >> f; \
classname_to t = __PIVariantFunctions__<classname_from>::castVariant<classname_to>(f); \
PIByteArray ret; \
ret << t; \
return ret; \
} \
STATIC_INITIALIZER_BEGIN \
__PIVariantInfo__ * vi( \
__PIVariantInfoStorage__::get()->map->value(__PIVariantFunctions__<classname_from>::typeIDHelper(), nullptr)); \
if (!vi) { \
piCout << "Warning! Using REGISTER_VARIANT_CAST(" #classname_from ", " #classname_to \
") before REGISTER_VARIANT(" #classname_from "), ignore."; \
return; \
} \
vi->cast[__PIVariantFunctions__<classname_to>::typeIDHelper()] = \
__PIVariantFunctions__<classname_from>::castHelper<classname_to>; \
STATIC_INITIALIZER_END \
template<> \
template<> \
classname_to __PIVariantFunctions__<classname_from>::castVariant<classname_to>(const classname_from & v)
#define REGISTER_VARIANT_CAST(classname_from, classname_to) \
REGISTER_VARIANT_CAST_H(classname_from, classname_to) \
REGISTER_VARIANT_CAST_CPP(classname_from, classname_to)
# define REGISTER_VARIANT_CAST(classname_from, classname_to) \
REGISTER_VARIANT_CAST_H(classname_from, classname_to) \
REGISTER_VARIANT_CAST_CPP(classname_from, classname_to)
#define REGISTER_VARIANT_CAST_SIMPLE(classname_from, classname_to) REGISTER_VARIANT_CAST(classname_from, classname_to) {return classname_to(v);}
#define REGISTER_VARIANT_CAST_SIMPLE_H(classname_from, classname_to) REGISTER_VARIANT_CAST_H(classname_from, classname_to)
#define REGISTER_VARIANT_CAST_SIMPLE_CPP(classname_from, classname_to) REGISTER_VARIANT_CAST_CPP(classname_from, classname_to) {return classname_to(v);}
# define REGISTER_VARIANT_CAST_SIMPLE(classname_from, classname_to) \
REGISTER_VARIANT_CAST(classname_from, classname_to) { \
return classname_to(v); \
}
# define REGISTER_VARIANT_CAST_SIMPLE_H(classname_from, classname_to) REGISTER_VARIANT_CAST_H(classname_from, classname_to)
# define REGISTER_VARIANT_CAST_SIMPLE_CPP(classname_from, classname_to) \
REGISTER_VARIANT_CAST_CPP(classname_from, classname_to) { \
return classname_to(v); \
}
#else
#define REGISTER_VARIANT_TYPEINFO(classname)
#define REGISTER_VARIANT_H(classname)
#define REGISTER_VARIANT_CPP(classname)
#define INIT_VARIANT(classname)
#define REGISTER_VARIANT(classname)
#define REGISTER_NS_VARIANT_H(ns, classname)
#define REGISTER_NS_VARIANT_CPP(ns, classname)
#define INIT_NS_VARIANT(ns, classname)
#define REGISTER_NS_VARIANT(ns, classname)
#define REGISTER_VARIANT_CAST_H(classname_from, classname_to)
#define REGISTER_VARIANT_CAST_CPP(classname_from, classname_to)
#define REGISTER_VARIANT_CAST(classname_from, classname_to)
#define REGISTER_VARIANT_CAST_SIMPLE(classname_from, classname_to)
#define REGISTER_VARIANT_CAST_SIMPLE_H(classname_from, classname_to)
#define REGISTER_VARIANT_CAST_SIMPLE_CPP(classname_from, classname_to)
# define REGISTER_VARIANT_TYPEINFO(classname)
# define REGISTER_VARIANT_H(classname)
# define REGISTER_VARIANT_CPP(classname)
# define INIT_VARIANT(classname)
# define REGISTER_VARIANT(classname)
# define REGISTER_NS_VARIANT_H(ns, classname)
# define REGISTER_NS_VARIANT_CPP(ns, classname)
# define INIT_NS_VARIANT(ns, classname)
# define REGISTER_NS_VARIANT(ns, classname)
# define REGISTER_VARIANT_CAST_H(classname_from, classname_to)
# define REGISTER_VARIANT_CAST_CPP(classname_from, classname_to)
# define REGISTER_VARIANT_CAST(classname_from, classname_to)
# define REGISTER_VARIANT_CAST_SIMPLE(classname_from, classname_to)
# define REGISTER_VARIANT_CAST_SIMPLE_H(classname_from, classname_to)
# define REGISTER_VARIANT_CAST_SIMPLE_CPP(classname_from, classname_to)
#endif
@@ -186,47 +223,49 @@ public:
//! \~english Variant type.
//! \~russian Вариантный тип.
class PIP_EXPORT PIVariant {
friend PICout operator <<(PICout s, const PIVariant & v);
friend PICout operator<<(PICout s, const PIVariant & v);
BINARY_STREAM_FRIEND(PIVariant);
public:
public:
//! \~english Type of %PIVariant content
//! \~russian Тип содержимого %PIVariant
enum Type {
pivInvalid /** \~english Invalid type, default type of empty contructor \~russian Недействительный тип, также конструированный по умолчанию */ = 0 ,
pivBool /** bool */ ,
pivChar /** char */ ,
pivUChar /** uchar */ ,
pivShort /** short */ ,
pivUShort /** ushort */ ,
pivInt /** int */ ,
pivUInt /** uint */ ,
pivLLong /** llong */ ,
pivULLong /** ullong */ ,
pivFloat /** float */ ,
pivDouble /** double */ ,
pivLDouble /** ldouble */ ,
pivComplexd /** complexd */ ,
pivComplexld /** complexld */ ,
pivBitArray /** PIBitArray */ ,
pivByteArray /** PIByteArray */ ,
pivString /** PIString */ ,
pivStringList /** PIStringList */ ,
pivTime /** PITime */ ,
pivDate /** PIDate */ ,
pivDateTime /** PIDateTime */ ,
pivSystemTime /** PISystemTime */ ,
pivEnum /** PIVariantTypes::Enum */ ,
pivFile /** PIVariantTypes::File */ ,
pivDir /** PIVariantTypes::Dir */ ,
pivColor /** PIVariantTypes::Color */ ,
pivPoint /** PIPoint<double> */ ,
pivRect /** PIRect<double> */ ,
pivIODevice /** PIVariantTypes::IODevice */ ,
pivMathVector /** PIMathVector<double> */ ,
pivMathMatrix /** PIMathMatrix<double> */ ,
pivLine /** PILine<double> */ ,
pivCustom /** \~english Custom \~russian Свой тип */ = 0xFF
pivInvalid /** \~english Invalid type, default type of empty contructor \~russian Недействительный тип, также конструированный по
умолчанию */
= 0,
pivBool /** bool */,
pivChar /** char */,
pivUChar /** uchar */,
pivShort /** short */,
pivUShort /** ushort */,
pivInt /** int */,
pivUInt /** uint */,
pivLLong /** llong */,
pivULLong /** ullong */,
pivFloat /** float */,
pivDouble /** double */,
pivLDouble /** ldouble */,
pivComplexd /** complexd */,
pivComplexld /** complexld */,
pivBitArray /** PIBitArray */,
pivByteArray /** PIByteArray */,
pivString /** PIString */,
pivStringList /** PIStringList */,
pivTime /** PITime */,
pivDate /** PIDate */,
pivDateTime /** PIDateTime */,
pivSystemTime /** PISystemTime */,
pivEnum /** PIVariantTypes::Enum */,
pivFile /** PIVariantTypes::File */,
pivDir /** PIVariantTypes::Dir */,
pivColor /** PIVariantTypes::Color */,
pivPoint /** PIPoint<double> */,
pivRect /** PIRect<double> */,
pivIODevice /** PIVariantTypes::IODevice */,
pivMathVector /** PIMathVector<double> */,
pivMathMatrix /** PIMathMatrix<double> */,
pivLine /** PILine<double> */,
pivCustom /** \~english Custom \~russian Свой тип */ = 0xFF
};
//! \~english Construct \a pivInvalid %PIVariant
@@ -243,253 +282,253 @@ public:
//! \~english Constructs %PIVariant from string
//! \~russian Создает %PIVariant из строки.
PIVariant(const char * v) {initType(PIString(v));}
PIVariant(const char * v) { initType(PIString(v)); }
//! \~english Constructs %PIVariant from boolean
//! \~russian Создает %PIVariant из логического значения.
PIVariant(const bool v) {initType(v);}
PIVariant(const bool v) { initType(v); }
//! \~english Constructs %PIVariant from char
//! \~russian Создает %PIVariant из символа.
PIVariant(const char v) {initType(v);}
PIVariant(const char v) { initType(v); }
//! \~english Constructs %PIVariant from integer
//! \~russian Создает %PIVariant из целого числа.
PIVariant(const uchar v) {initType(v);}
PIVariant(const uchar v) { initType(v); }
//! \~english Constructs %PIVariant from integer
//! \~russian Создает %PIVariant из целого числа.
PIVariant(const short v) {initType(v);}
PIVariant(const short v) { initType(v); }
//! \~english Constructs %PIVariant from integer
//! \~russian Создает %PIVariant из целого числа.
PIVariant(const ushort v) {initType(v);}
PIVariant(const ushort v) { initType(v); }
//! \~english Constructs %PIVariant from integer
//! \~russian Создает %PIVariant из целого числа.
PIVariant(const int & v) {initType(v);}
PIVariant(const int & v) { initType(v); }
//! \~english Constructs %PIVariant from integer
//! \~russian Создает %PIVariant из целого числа.
PIVariant(const uint & v) {initType(v);}
PIVariant(const uint & v) { initType(v); }
//! \~english Constructs %PIVariant from integer
//! \~russian Создает %PIVariant из целого числа.
PIVariant(const llong & v) {initType(v);}
PIVariant(const llong & v) { initType(v); }
//! \~english Constructs %PIVariant from integer
//! \~russian Создает %PIVariant из целого числа.
PIVariant(const ullong & v) {initType(v);}
PIVariant(const ullong & v) { initType(v); }
//! \~english Constructs %PIVariant from float
//! \~russian Создает %PIVariant из вещественного числа.
PIVariant(const float & v) {initType(v);}
PIVariant(const float & v) { initType(v); }
//! \~english Constructs %PIVariant from double
//! \~russian Создает %PIVariant из вещественного числа.
PIVariant(const double & v) {initType(v);}
PIVariant(const double & v) { initType(v); }
//! \~english Constructs %PIVariant from long double
//! \~russian Создает %PIVariant из вещественного числа.
PIVariant(const ldouble & v) {initType(v);}
PIVariant(const ldouble & v) { initType(v); }
//! \~english Constructs %PIVariant from bit array
//! \~russian Создает %PIVariant из массива битов.
PIVariant(const PIBitArray & v) {initType(v);}
PIVariant(const PIBitArray & v) { initType(v); }
//! \~english Constructs %PIVariant from byte array
//! \~russian Создает %PIVariant из массива байтов.
PIVariant(const PIByteArray & v) {initType(v);}
PIVariant(const PIByteArray & v) { initType(v); }
//! \~english Constructs %PIVariant from string
//! \~russian Создает %PIVariant из строки.
PIVariant(const PIString & v) {initType(v);}
PIVariant(const PIString & v) { initType(v); }
//! \~english Constructs %PIVariant from strings list
//! \~russian Создает %PIVariant из массива строк.
PIVariant(const PIStringList & v) {initType(v);}
PIVariant(const PIStringList & v) { initType(v); }
//! \~english Constructs %PIVariant from time
//! \~russian Создает %PIVariant из времени.
PIVariant(const PITime & v) {initType(v);}
PIVariant(const PITime & v) { initType(v); }
//! \~english Constructs %PIVariant from date
//! \~russian Создает %PIVariant из даты.
PIVariant(const PIDate & v) {initType(v);}
PIVariant(const PIDate & v) { initType(v); }
//! \~english Constructs %PIVariant from date and time
//! \~russian Создает %PIVariant из даты и времени.
PIVariant(const PIDateTime & v) {initType(v);}
PIVariant(const PIDateTime & v) { initType(v); }
//! \~english Constructs %PIVariant from system time
//! \~russian Создает %PIVariant из системного времени.
PIVariant(const PISystemTime & v) {initType(v);}
PIVariant(const PISystemTime & v) { initType(v); }
//! \~english Constructs %PIVariant from enum
//! \~russian Создает %PIVariant из перечисления.
PIVariant(const PIVariantTypes::Enum & v) {initType(v);}
PIVariant(const PIVariantTypes::Enum & v) { initType(v); }
//! \~english Constructs %PIVariant from file
//! \~russian Создает %PIVariant из файла.
PIVariant(const PIVariantTypes::File & v) {initType(v);}
PIVariant(const PIVariantTypes::File & v) { initType(v); }
//! \~english Constructs %PIVariant from dir
//! \~russian Создает %PIVariant из директории.
PIVariant(const PIVariantTypes::Dir & v) {initType(v);}
PIVariant(const PIVariantTypes::Dir & v) { initType(v); }
//! \~english Constructs %PIVariant from color
//! \~russian Создает %PIVariant из цвета.
PIVariant(const PIVariantTypes::Color & v) {initType(v);}
PIVariant(const PIVariantTypes::Color & v) { initType(v); }
//! \~english Constructs %PIVariant from IODevice
//! \~russian Создает %PIVariant из IODevice.
PIVariant(const PIVariantTypes::IODevice & v) {initType(v);}
PIVariant(const PIVariantTypes::IODevice & v) { initType(v); }
//! \~english Constructs %PIVariant from point
//! \~russian Создает %PIVariant из точки.
PIVariant(const PIPointd & v) {initType(v);}
PIVariant(const PIPointd & v) { initType(v); }
//! \~english Constructs %PIVariant from rect
//! \~russian Создает %PIVariant из прямоугольника.
PIVariant(const PIRectd & v) {initType(v);}
PIVariant(const PIRectd & v) { initType(v); }
//! \~english Constructs %PIVariant from line
//! \~russian Создает %PIVariant из линии.
PIVariant(const PILined & v) {initType(v);}
PIVariant(const PILined & v) { initType(v); }
//! \~english Constructs %PIVariant from MathVector
//! \~russian Создает %PIVariant из MathVector.
PIVariant(const PIMathVectord & v) {initType(v);}
PIVariant(const PIMathVectord & v) { initType(v); }
//! \~english Constructs %PIVariant from MathMatrix
//! \~russian Создает %PIVariant из MathMatrix.
PIVariant(const PIMathMatrixd & v) {initType(v);}
PIVariant(const PIMathMatrixd & v) { initType(v); }
//! \~english Set variant content and type to string
//! \~russian Устанавливает значение и тип из строки
void setValue(const char * v) {setValue(PIString(v));}
void setValue(const char * v) { setValue(PIString(v)); }
//! \~english Set variant content and type to boolean
//! \~russian Устанавливает значение и тип из
void setValue(const bool v) {initType(v);}
void setValue(const bool v) { initType(v); }
//! \~english Set variant content and type to char
//! \~russian Устанавливает значение и тип из символа
void setValue(const char v) {initType(v);}
void setValue(const char v) { initType(v); }
//! \~english Set variant content and type to integer
//! \~russian Устанавливает значение и тип из целого числа
void setValue(const uchar v) {initType(v);}
void setValue(const uchar v) { initType(v); }
//! \~english Set variant content and type to integer
//! \~russian Устанавливает значение и тип из целого числа
void setValue(const short v) {initType(v);}
void setValue(const short v) { initType(v); }
//! \~english Set variant content and type to integer
//! \~russian Устанавливает значение и тип из целого числа
void setValue(const ushort v) {initType(v);}
void setValue(const ushort v) { initType(v); }
//! \~english Set variant content and type to integer
//! \~russian Устанавливает значение и тип из целого числа
void setValue(const int & v) {initType(v);}
void setValue(const int & v) { initType(v); }
//! \~english Set variant content and type to integer
//! \~russian Устанавливает значение и тип из целого числа
void setValue(const uint & v) {initType(v);}
void setValue(const uint & v) { initType(v); }
//! \~english Set variant content and type to integer
//! \~russian Устанавливает значение и тип из целого числа
void setValue(const llong & v) {initType(v);}
void setValue(const llong & v) { initType(v); }
//! \~english Set variant content and type to integer
//! \~russian Устанавливает значение и тип из целого числа
void setValue(const ullong & v) {initType(v);}
void setValue(const ullong & v) { initType(v); }
//! \~english Set variant content and type to float
//! \~russian Устанавливает значение и тип из вещественного числа
void setValue(const float & v) {initType(v);}
void setValue(const float & v) { initType(v); }
//! \~english Set variant content and type to double
//! \~russian Устанавливает значение и тип из вещественного числа
void setValue(const double & v) {initType(v);}
void setValue(const double & v) { initType(v); }
//! \~english Set variant content and type to long double
//! \~russian Устанавливает значение и тип из вещественного числа
void setValue(const ldouble & v) {initType(v);}
void setValue(const ldouble & v) { initType(v); }
//! \~english Set variant content and type to bit array
//! \~russian Устанавливает значение и тип из массива битов
void setValue(const PIBitArray & v) {initType(v);}
void setValue(const PIBitArray & v) { initType(v); }
//! \~english Set variant content and type to byte array
//! \~russian Устанавливает значение и тип из массива байтов
void setValue(const PIByteArray & v) {initType(v);}
void setValue(const PIByteArray & v) { initType(v); }
//! \~english Set variant content and type to string
//! \~russian Устанавливает значение и тип из строки
void setValue(const PIString & v) {initType(v);}
void setValue(const PIString & v) { initType(v); }
//! \~english Set variant content and type to strings list
//! \~russian Устанавливает значение и тип из массива строк
void setValue(const PIStringList & v) {initType(v);}
void setValue(const PIStringList & v) { initType(v); }
//! \~english Set variant content and type to time
//! \~russian Устанавливает значение и тип из времени
void setValue(const PITime & v) {initType(v);}
void setValue(const PITime & v) { initType(v); }
//! \~english Set variant content and type to date
//! \~russian Устанавливает значение и тип из даты
void setValue(const PIDate & v) {initType(v);}
void setValue(const PIDate & v) { initType(v); }
//!
//! \~english Set variant content and type to date and time
//! \~russian Устанавливает значение и тип из даты и времени
void setValue(const PIDateTime & v) {initType(v);}
void setValue(const PIDateTime & v) { initType(v); }
//! \~english Set variant content and type to system time
//! \~russian Устанавливает значение и тип из системного времени
void setValue(const PISystemTime & v) {initType(v);}
void setValue(const PISystemTime & v) { initType(v); }
//! \~english Set variant content and type to enum
//! \~russian Устанавливает значение и тип из перечисления
void setValue(const PIVariantTypes::Enum & v) {initType(v);}
void setValue(const PIVariantTypes::Enum & v) { initType(v); }
//! \~english Set variant content and type to file
//! \~russian Устанавливает значение и тип из файла
void setValue(const PIVariantTypes::File & v) {initType(v);}
void setValue(const PIVariantTypes::File & v) { initType(v); }
//! \~english Set variant content and type to dir
//! \~russian Устанавливает значение и тип из директории
void setValue(const PIVariantTypes::Dir & v) {initType(v);}
void setValue(const PIVariantTypes::Dir & v) { initType(v); }
//! \~english Set variant content and type to color
//! \~russian Устанавливает значение и тип из цвета
void setValue(const PIVariantTypes::Color & v) {initType(v);}
void setValue(const PIVariantTypes::Color & v) { initType(v); }
//! \~english Set variant content and type to IODevice
//! \~russian Устанавливает значение и тип из IODevice
void setValue(const PIVariantTypes::IODevice & v) {initType(v);}
void setValue(const PIVariantTypes::IODevice & v) { initType(v); }
//! \~english Set variant content and type to point
//! \~russian Устанавливает значение и тип из точки
void setValue(const PIPointd & v) {initType(v);}
void setValue(const PIPointd & v) { initType(v); }
//! \~english Set variant content and type to rect
//! \~russian Устанавливает значение и тип из прямоугольника
void setValue(const PIRectd & v) {initType(v);}
void setValue(const PIRectd & v) { initType(v); }
//! \~english Set variant content and type to line
//! \~russian Устанавливает значение и тип из линии
void setValue(const PILined & v) {initType(v);}
void setValue(const PILined & v) { initType(v); }
//! \~english Set variant content and type to math vector
//! \~russian Устанавливает значение и тип из вектора
void setValue(const PIMathVectord & v) {initType(v);}
void setValue(const PIMathVectord & v) { initType(v); }
//! \~english Set variant content and type to math matrix
//! \~russian Устанавливает значение и тип из матрицы
void setValue(const PIMathMatrixd & v) {initType(v);}
void setValue(const PIMathMatrixd & v) { initType(v); }
//! \~english Set current value from string without change type
@@ -534,157 +573,252 @@ public:
//! Для стандартных типов эквиваленстно методу \a to<Type>. \n
//! Для других возвращает тип T только если он был установлен ранее.
template<typename T>
T value() const {return getAsValue<T>(*this);}
T value() const {
return getAsValue<T>(*this);
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PIVariant & v);
PIVariant & operator=(const PIVariant & v);
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(PIVariant && v);
PIVariant & operator=(PIVariant && v);
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const char * v) {setValue(PIString(v)); return *this;}
PIVariant & operator=(const char * v) {
setValue(PIString(v));
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const bool v) {setValue(v); return *this;}
PIVariant & operator=(const bool v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const char v) {setValue(v); return *this;}
PIVariant & operator=(const char v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const uchar v) {setValue(v); return *this;}
PIVariant & operator=(const uchar v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const short v) {setValue(v); return *this;}
PIVariant & operator=(const short v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const ushort v) {setValue(v); return *this;}
PIVariant & operator=(const ushort v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const int & v) {setValue(v); return *this;}
PIVariant & operator=(const int & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const uint & v) {setValue(v); return *this;}
PIVariant & operator=(const uint & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const llong & v) {setValue(v); return *this;}
PIVariant & operator=(const llong & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const ullong & v) {setValue(v); return *this;}
PIVariant & operator=(const ullong & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const float & v) {setValue(v); return *this;}
PIVariant & operator=(const float & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const double & v) {setValue(v); return *this;}
PIVariant & operator=(const double & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const ldouble & v) {setValue(v); return *this;}
PIVariant & operator=(const ldouble & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PIBitArray & v) {setValue(v); return *this;}
PIVariant & operator=(const PIBitArray & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PIByteArray & v) {setValue(v); return *this;}
PIVariant & operator=(const PIByteArray & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PIString & v) {setValue(v); return *this;}
PIVariant & operator=(const PIString & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PIStringList & v) {setValue(v); return *this;}
PIVariant & operator=(const PIStringList & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PITime & v) {setValue(v); return *this;}
PIVariant & operator=(const PITime & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PIDate & v) {setValue(v); return *this;}
PIVariant & operator=(const PIDate & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PIDateTime & v) {setValue(v); return *this;}
PIVariant & operator=(const PIDateTime & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PISystemTime & v) {setValue(v); return *this;}
PIVariant & operator=(const PISystemTime & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PIVariantTypes::Enum & v) {setValue(v); return *this;}
PIVariant & operator=(const PIVariantTypes::Enum & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PIVariantTypes::File & v) {setValue(v); return *this;}
PIVariant & operator=(const PIVariantTypes::File & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PIVariantTypes::Dir & v) {setValue(v); return *this;}
PIVariant & operator=(const PIVariantTypes::Dir & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PIVariantTypes::Color & v) {setValue(v); return *this;}
PIVariant & operator=(const PIVariantTypes::Color & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PIVariantTypes::IODevice & v) {setValue(v); return *this;}
PIVariant & operator=(const PIVariantTypes::IODevice & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PIPointd & v) {setValue(v); return *this;}
PIVariant & operator=(const PIPointd & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PIRectd & v) {setValue(v); return *this;}
PIVariant & operator=(const PIRectd & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PILined & v) {setValue(v); return *this;}
PIVariant & operator=(const PILined & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PIMathVectord & v) {setValue(v); return *this;}
PIVariant & operator=(const PIMathVectord & v) {
setValue(v);
return *this;
}
//! \~english Assign operator.
//! \~russian Оператор присваивания.
PIVariant & operator =(const PIMathMatrixd & v) {setValue(v); return *this;}
PIVariant & operator=(const PIMathMatrixd & v) {
setValue(v);
return *this;
}
//! \~english Compare operator. Check type and content.
//! \~russian Оператор сравнения. Сравнивает тип и содержимое.
bool operator ==(const PIVariant & v) const;
bool operator==(const PIVariant & v) const;
//! \~english Compare operator. Check type and content.
//! \~russian Оператор сравнения. Сравнивает тип и содержимое.
bool operator !=(const PIVariant & v) const {return !(*this == v);}
bool operator!=(const PIVariant & v) const { return !(*this == v); }
//! \~english Returns type of variant content.
//! \~russian Возвращает тип значения.
PIVariant::Type type() const {return _type;}
PIVariant::Type type() const { return _type; }
//! \~english Returns type ID of variant content.
//! \~russian Возвращает ID типа значения.
uint typeID() const {return _typeID;}
uint typeID() const { return _typeID; }
//! \~english Returns type name of variant content.
//! \~russian Возвращает имя типа значения.
@@ -693,7 +827,7 @@ public:
//! \~english Returns if type is not \a pivInvalid.
//! \~russian Возвращает не является ли тип \a pivInvalid.
bool isValid() const {return _type != PIVariant::pivInvalid;}
bool isValid() const { return _type != PIVariant::pivInvalid; }
//! \~english Swaps with other %PIVariant.
//! \~russian Меняет с другим %PIVariant.
@@ -710,7 +844,7 @@ public:
//! \~russian
//! Для стандартных типов эквиваленстно конструктору \a PIVariant(). \n
//! Для других устанавливает содержимое из "v" и тип \a pivCustom.
template <typename T>
template<typename T>
static PIVariant fromValue(const T & v) {
PIVariant ret;
ret.initType<T>(v);
@@ -722,7 +856,7 @@ public:
//! \~english Returns new %PIVariant from default-constructed type with name "type".
//! \~russian Возвращает новый %PIVariant из пустого конструктора типа "type".
static PIVariant fromType(const PIString & type) {return fromType(typeIDFromName(type));}
static PIVariant fromType(const PIString & type) { return fromType(typeIDFromName(type)); }
//! \~english Returns new %PIVariant from default-constructed type with type ID "type_id".
//! \~russian Возвращает новый %PIVariant из пустого конструктора типа c ID "type_id".
@@ -751,7 +885,7 @@ public:
//! \~english Returns type name.
//! \~russian Возвращает имя типа.
template <typename T>
template<typename T>
static PIString typeName() {
#ifdef CUSTOM_PIVARIANT
return __PIVariantFunctions__<T>::typeNameHelper();
@@ -764,7 +898,7 @@ public:
//! \~russian Возвращает имя типа из его ID.
static PIString typeNameFromID(uint type_id);
template <typename T>
template<typename T>
static uint typeID() {
#ifdef CUSTOM_PIVARIANT
return __PIVariantFunctions__<T>::typeIDHelper();
@@ -773,10 +907,20 @@ public:
#endif
}
//! \~english Returns all registered type ID.
//! \~russian Возвращает все зарегистрированные ID типов.
static PIVector<uint> knownTypeIDs();
static int knownTypeIDsCount();
private:
void destroy() {_content.clear();}
template <typename T> inline static Type getType() {return pivCustom;}
template <typename T> inline void initType(const T & v) {
void destroy() { _content.clear(); }
template<typename T>
inline static Type getType() {
return pivCustom;
}
template<typename T>
inline void initType(const T & v) {
_content.clear();
_content << v;
_type = getType<T>();
@@ -792,21 +936,23 @@ private:
_info = 0;
#endif
}
template<typename T> inline static T getAsValue(const PIVariant & v) {
template<typename T>
inline static T getAsValue(const PIVariant & v) {
#ifdef CUSTOM_PIVARIANT
if (v._content.isEmpty() || !v._info) return T();
uint cnid = __PIVariantFunctions__<T>::typeIDHelper();
//piCout << "gav" << cn;
// piCout << "gav" << cn;
PIByteArray ba;
if (cnid == v._info->typeID) {
ba = v._content;
} else {
__PIVariantInfo__::castHelperFunc cf = v._info->cast.value(cnid);
//piCout << "gav cast" << cf;
// piCout << "gav cast" << cf;
if (!cf) return T();
ba = cf(v._content);
}
T ret; ba >> ret;
T ret;
ba >> ret;
return ret;
#else
return T();
@@ -819,12 +965,12 @@ private:
__PIVariantInfo__ * _info = nullptr;
#endif
uint _typeID = 0;
};
typedef PIMap<PIString, PIVariant> PIVariantMap;
typedef PIVector<PIVariant> PIVariantVector;
// clang-format off
template<> inline bool PIVariant::value() const {return toBool();}
template<> inline char PIVariant::value() const {return (char)toInt();}
template<> inline uchar PIVariant::value() const {return (uchar)toInt();}
@@ -918,6 +1064,7 @@ template<> inline PIVariant::Type PIVariant::getType<PIRectd>() {return PIVarian
template<> inline PIVariant::Type PIVariant::getType<PILined>() {return PIVariant::pivLine;}
template<> inline PIVariant::Type PIVariant::getType<PIMathVectord>() {return PIVariant::pivMathVector;}
template<> inline PIVariant::Type PIVariant::getType<PIMathMatrixd>() {return PIVariant::pivMathMatrix;}
// clang-format on
REGISTER_VARIANT(bool)
REGISTER_VARIANT(char)
@@ -982,7 +1129,7 @@ BINARY_STREAM_READ(PIVariant) {
s >> tn;
#ifdef CUSTOM_PIVARIANT
PIByteArray vc = v._content;
v = PIVariant::fromValue(vc, tn);
v = PIVariant::fromValue(vc, tn);
#endif
} else {
v._typeID = PIVariant::typeIDFromType(v._type);
@@ -993,13 +1140,14 @@ BINARY_STREAM_READ(PIVariant) {
//! \relatesalso PICout
//! \~english Output operator to \a PICout
//! \~russian Оператор вывода в \a PICout
inline PICout operator <<(PICout s, const PIVariant & v) {
s.space(); s.saveAndSetControls(0);
inline PICout operator<<(PICout s, const PIVariant & v) {
s.space();
s.saveAndSetControls(0);
s << "PIVariant(" << v.typeName();
if (v.isValid())
s << ", " << v.toString();
if (v.isValid()) s << ", " << v.toString();
s << ")";
s.restoreControls(); return s;
s.restoreControls();
return s;
}

80
libs/main/types/pivarianttypes.cpp
View File

@@ -18,8 +18,9 @@
*/
#include "pivarianttypes.h"
#include "pipropertystorage.h"
#include "colors_p.h"
#include "pipropertystorage.h"
#ifndef MICRO_PIP
# include "piiodevice.h"
#endif
@@ -27,8 +28,7 @@
int PIVariantTypes::Enum::selectedValue() const {
for (const auto & e: enum_list)
if (e.name == selected)
return e.value;
if (e.name == selected) return e.value;
return 0;
}
@@ -55,16 +55,14 @@ bool PIVariantTypes::Enum::selectName(const PIString & n) {
int PIVariantTypes::Enum::value(const PIString & n) const {
for (const auto & e: enum_list)
if (e.name == n)
return e.value;
if (e.name == n) return e.value;
return 0;
}
PIString PIVariantTypes::Enum::name(int v) const {
for (const auto & e: enum_list)
if (e.value == v)
return e.name;
if (e.value == v) return e.name;
return PIString();
}
@@ -85,7 +83,6 @@ PIStringList PIVariantTypes::Enum::names() const {
}
PIVariantTypes::IODevice::IODevice() {
#ifndef MICRO_PIP
mode = PIIODevice::ReadWrite;
@@ -114,20 +111,24 @@ PIString PIVariantTypes::IODevice::toPICout() const {
PIString s;
s += "IODevice(" + prefix + ", mode=";
int rwc = 0;
if (mode & 1) {s += "r"; ++rwc;}
if (mode & 2) {s += "w"; ++rwc;}
if (mode & 1) {
s += "r";
++rwc;
}
if (mode & 2) {
s += "w";
++rwc;
}
if (rwc == 1) s += "o";
s += ", flags=";
#ifndef MICRO_PIP // TODO: PIIODevice for MICRO PIP
if (options != 0) {
if (((PIIODevice::DeviceOptions)options)[PIIODevice::BlockingRead])
s += " br";
if (((PIIODevice::DeviceOptions)options)[PIIODevice::BlockingWrite])
s += " bw";
if (((PIIODevice::DeviceOptions)options)[PIIODevice::BlockingRead]) s += " br";
if (((PIIODevice::DeviceOptions)options)[PIIODevice::BlockingWrite]) s += " bw";
}
#endif // MICRO_PIP
PIPropertyStorage ps = get();
piForeachC (PIPropertyStorage::Property & p, ps) {
piForeachC(PIPropertyStorage::Property & p, ps) {
s += ", " + p.name + "=\"" + p.value.toString() + "\"";
}
s += ")";
@@ -135,14 +136,54 @@ PIString PIVariantTypes::IODevice::toPICout() const {
}
PIVariantTypes::Enum & PIVariantTypes::Enum::operator <<(const PIVariantTypes::Enumerator & v) {
PIVariantTypes::Enum & PIVariantTypes::Enum::operator<<(const PIVariantTypes::Enumerator & v) {
enum_list << v;
return *this;
}
PIVariantTypes::Enum & PIVariantTypes::Enum::operator <<(const PIString & v) {
PIString PIVariantTypes::Enum::toString() {
static PIString masks = "\"";
PIString ret;
ret += "\"" + enum_name.masked(masks) + "\":(";
bool comma = false;
for (const auto & i: enum_list) {
if (comma) ret += ';';
comma = true;
ret += "\"" + i.name.masked(masks) + "\":";
ret += PIString::fromNumber(i.value);
}
ret += "):" + PIString::fromNumber(selectedValue());
return ret;
}
PIVariantTypes::Enum PIVariantTypes::Enum::fromString(PIString str) {
static PIString masks = "\"";
Enum ret;
if (str.size() < 3) return ret;
ret.enum_name = str.takeRange('"', '"').unmask(masks);
str.trim();
if (str.startsWith(":")) str.cutLeft(1).trim();
PIString el = str.takeRange('(', ')');
while (el.isNotEmpty()) {
Enumerator e;
e.name = el.takeRange('"', '"').unmask(masks);
el.trim();
if (el.startsWith(":")) el.cutLeft(1).trim();
e.value = el.takeInteger().toInt();
el.trim();
if (el.startsWith(";")) el.cutLeft(1).trim();
ret.enum_list << e;
}
str.trim();
if (str.startsWith(":")) str.cutLeft(1).trim();
ret.selectValue(str.toInt());
return ret;
}
PIVariantTypes::Enum & PIVariantTypes::Enum::operator<<(const PIString & v) {
if (enum_list.isEmpty()) {
enum_list << Enumerator(0, v);
} else {
@@ -152,14 +193,13 @@ PIVariantTypes::Enum & PIVariantTypes::Enum::operator <<(const PIString & v) {
}
PIVariantTypes::Enum & PIVariantTypes::Enum::operator <<(const PIStringList & v) {
PIVariantTypes::Enum & PIVariantTypes::Enum::operator<<(const PIStringList & v) {
for (const auto & s: v)
(*this) << s;
return *this;
}
PIVariantTypes::Color PIVariantTypes::Color::fromString(const PIString & str) {
if (str.size_s() < 2) return Color();
PIString cn = str.toLowerCase().trim();

8
libs/main/types/pivarianttypes.h
View File

@@ -150,6 +150,14 @@ struct PIP_EXPORT Enum {
//! \~russian Возвращает пустой ли Enum.
bool isEmpty() const {return enum_list.isEmpty();}
//! \~english Returns string full representation.
//! \~russian Возвращает полное строковое представление.
PIString toString();
//! \~english Returns Enum from string full representation.
//! \~russian Возвращает Enum из полного строкового представления.
static Enum fromString(PIString str);
//! \~english Name of Enum.
//! \~russian Имя Enum.

20
main.cpp
View File

@@ -13,7 +13,7 @@ struct SomeType {
};
PICout operator <<(PICout c, const SomeType & v) {
c << "SomeType(" << v.i << "," << v.f << ")";
c << "SomeType(" << v.i << "," << v.f << ")";
return c;
}
@@ -59,14 +59,16 @@ int main(int argc, char * argv[]) {
v.setValueFromString("0xFF00FFff");
piCout << v;*/
PIJSON j;
j["123"] = "str";
j[PIString::fromUTF8("ключ")] = PIString::fromUTF8("str_значение");
piCout << j;
piCout << PIJSON::fromJSON(j.toJSON(PIJSON::Compact, true));
piCout << PIJSON::fromJSON(j.toJSON(PIJSON::Compact, false));
piCout << PIJSON::fromJSON(j.toJSON(PIJSON::Tree, true));
piCout << PIJSON::fromJSON(j.toJSON(PIJSON::Tree, false));
PIVariantTypes::Enum e;
e.enum_name = "MyEnum";
e << PIVariantTypes::Enumerator(10105, "Null")
<< PIVariantTypes::Enumerator(20, "Sec")
<< PIVariantTypes::Enumerator(100, "Fir");
e.selectValue(20);
piCout << e.toString();
piCout << PIVariantTypes::Enum::fromString(e.toString()).toString();
piCout << PIVariantTypes::Enum::fromString("\"MyEnum\"(\"Null\":10105 \"Sec\":20 \"Fir\":100) 20").toString();
return 0;
}

42
utils/code_model_generator/main.cpp
View File

@@ -20,6 +20,7 @@
#include "picli.h"
#include "picodeparser.h"
#include "piiostream.h"
#include <iostream>
using namespace PICoutManipulators;
@@ -102,6 +103,10 @@ void help() {
piCout << help_string;
}
void printError(const PIString & msg) {
std::cerr << msg.data() << std::endl;
}
PIString toCName(const PIString &s) {
PIString ret(s.trimmed());
@@ -231,13 +236,14 @@ void makeEnumInfo(PIIOTextStream & ts, const PICodeParser::Enum * e) {
}
void writeClassStreamMembersOut(PIIOTextStream & ts, const PICodeParser::Entity * e, int & cnt, bool simple) {
bool writeClassStreamMembersOut(PIIOTextStream & ts, const PICodeParser::Entity * e, int & cnt, bool simple) {
PIVector<PICodeParser::Member> ml;
for (const PICodeParser::Member & m: e->members) {
if (m.is_type_ptr || (m.visibility != PICodeParser::Public)) continue;
ml << m;
}
bool is_union = e->type == "union";
PISet<int> used_id;
for (const PICodeParser::Member & m: ml) {
if (is_union && m.isBitfield())
continue;
@@ -245,6 +251,10 @@ void writeClassStreamMembersOut(PIIOTextStream & ts, const PICodeParser::Entity
++cnt;
if (m.meta.contains("id"))
cnt = m.meta.value("id").toInt();
if (used_id[cnt]) {
printError("Error with \"" + e->name + "\" stream operator: ID " + PIString::fromNumber(cnt) + " already used");
return false;
}
if (m.dims.isEmpty()) {
if (simple) {
ts << "\ts << ";
@@ -275,21 +285,23 @@ void writeClassStreamMembersOut(PIIOTextStream & ts, const PICodeParser::Entity
if (is_union)
break;
}
if (is_union) return;
if (is_union) return true;
for (const PICodeParser::Entity * ce: e->children) {
if (ce->has_name) continue;
writeClassStreamMembersOut(ts, ce, cnt, simple);
if (!writeClassStreamMembersOut(ts, ce, cnt, simple)) return false;
}
return true;
}
void writeClassStreamMembersIn(PIIOTextStream & ts, const PICodeParser::Entity * e, int & cnt, bool simple) {
bool writeClassStreamMembersIn(PIIOTextStream & ts, const PICodeParser::Entity * e, int & cnt, bool simple) {
PIVector<PICodeParser::Member> ml;
for (const PICodeParser::Member & m: e->members) {
if (m.is_type_ptr || (m.visibility != PICodeParser::Public)) continue;
ml << m;
}
bool is_union = e->type == "union";
PISet<int> used_id;
for (const PICodeParser::Member & m: ml) {
if (is_union && m.isBitfield())
continue;
@@ -297,6 +309,11 @@ void writeClassStreamMembersIn(PIIOTextStream & ts, const PICodeParser::Entity *
++cnt;
if (m.meta.contains("id"))
cnt = m.meta.value("id").toInt();
if (used_id[cnt]) {
printError("Error with \"" + e->name + "\" stream operator: ID " + PIString::fromNumber(cnt) + " already used");
return false;
}
used_id << cnt;
if (m.dims.isEmpty()) {
bool is_enum = parser.isEnum(m.type);
if (simple) {
@@ -339,11 +356,12 @@ void writeClassStreamMembersIn(PIIOTextStream & ts, const PICodeParser::Entity *
if (is_union)
break;
}
if (is_union) return;
if (is_union) return true;
for (const PICodeParser::Entity * ce: e->children) {
if (ce->has_name) continue;
writeClassStreamMembersIn(ts, ce, cnt, simple);
if (!writeClassStreamMembersIn(ts, ce, cnt, simple)) return false;
}
return true;
}
@@ -359,14 +377,14 @@ bool needClassStream(const PICodeParser::Entity * e) {
}
void makeClassStream(PIIOTextStream & ts, const PICodeParser::Entity * e) {
if (!needClassStream(e)) return;
bool makeClassStream(PIIOTextStream & ts, const PICodeParser::Entity * e) {
if (!needClassStream(e)) return true;
bool simple = e->meta.contains("simple-stream");
ts << "\nBINARY_STREAM_WRITE(" << e->name << ") {\n";
if (!simple)
ts << "\tPIChunkStream cs;\n";
int cnt = 0;
writeClassStreamMembersOut(ts, e, cnt, simple);
if (!writeClassStreamMembersOut(ts, e, cnt, simple)) return false;
if (!simple)
ts << "\ts << cs.data();\n";
ts << "\treturn s;\n}\n";
@@ -379,10 +397,11 @@ void makeClassStream(PIIOTextStream & ts, const PICodeParser::Entity * e) {
ts << "\t\tswitch (cs.read()) {\n";
}
cnt = 0;
writeClassStreamMembersIn(ts, e, cnt, simple);
if (!writeClassStreamMembersIn(ts, e, cnt, simple)) return false;
if (!simple)
ts << "\t\t}\n\t}\n";
ts << "\treturn s;\n}\n";
return true;
}
@@ -507,7 +526,8 @@ bool writeModel(PICodeParser & parser, PICLI & cli, const PIString out, bool met
for (const PICodeParser::Entity * e: parser.entities) {
if (!e->has_name || e->name.startsWith("_PI") ||
!(e->visibility == PICodeParser::Global || e->visibility == PICodeParser::Public)) continue;
makeClassStream(ts, e);
if (!makeClassStream(ts, e))
return false;
}
}
if (meta || enums || getters) {