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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -150,6 +150,14 @@ struct PIP_EXPORT Enum {
//! \~russian Возвращает пустой ли Enum. //! \~russian Возвращает пустой ли Enum.
bool isEmpty() const {return enum_list.isEmpty();} 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. //! \~english Name of Enum.
//! \~russian Имя Enum. //! \~russian Имя Enum.

20
main.cpp
View File

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

42
utils/code_model_generator/main.cpp
View File

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