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

PIVariant custom casts works

Browse Source
This commit is contained in:
Пелипенко Иван
2022-11-27 12:13:11 +03:00
parent f52fc5332c
commit a786c928e0
3 changed files with 184 additions and 210 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -112,7 +112,18 @@ void PIVariant::setValueFromString(const PIString & v) {
case PIVariant::pivDir: {PIVariantTypes::Dir r = toDir(); r.dir = v; setValue(r);} break;
case PIVariant::pivColor: {setValue(PIVariantTypes::Color(v.mid(1).toUInt(16)));} break;
case PIVariant::pivIODevice: {setValue(PIVariantTypes::IODevice());} break; // TODO
case PIVariant::pivCustom: {} break; // TODO;
case PIVariant::pivCustom: {
#ifdef CUSTOM_PIVARIANT
__PIVariantInfo__ * vi = __PIVariantInfoStorage__::get()->map->value(__PIVariantFunctions__<PIString>::typeIDHelper());
if (vi) {
__PIVariantInfo__::castHelperFunc cf = vi->cast.value(_typeID);
if (cf) {
PIByteArray sba; sba << v;
_content = cf(sba);
}
}
#endif
} break;
default: break;
}
}
@@ -216,8 +227,10 @@ PIVariant::Type PIVariant::typeFromID(uint type_id) {
if (type_id == typeID<PIMathMatrixd>()) return PIVariant::pivMathMatrix;
if (type_id == typeID<PILined>()) return PIVariant::pivLine;
if (type_id == typeID<PIVariantTypes::IODevice>()) return PIVariant::pivIODevice;
#ifdef CUSTOM_PIVARIANT
if (__PIVariantInfoStorage__::get()->map->contains(type_id))
return PIVariant::pivCustom;
#endif
return PIVariant::pivInvalid;
}

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

@@ -136,12 +136,12 @@ public:
return ret; \
} \
STATIC_INITIALIZER_BEGIN \
__PIVariantInfo__ * vi(__PIVariantInfoStorage__::get()->map->value(name.hash(), nullptr)); \
__PIVariantInfo__ * vi(__PIVariantInfoStorage__::get()->map->value(__PIVariantFunctions__< classname_from >::typeIDHelper(), nullptr)); \
if (!vi) { \
piCout << "Warning! Using REGISTER_VARIANT_CAST("#classname_from", "#classname_to") before REGISTER_VARIANT("#classname_from"), ignore."; \
return; \
} \
vi->cast[cname.hash()] = __PIVariantFunctions__<classname_from>::castHelper<classname_to>; \
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)
@@ -737,7 +737,11 @@ public:
template <typename T>
static uint typeID() {
#ifdef CUSTOM_PIVARIANT
return __PIVariantFunctions__<T>::typeIDHelper();
#else
return 0;
#endif
}
private:
@@ -762,13 +766,13 @@ private:
template<typename T> inline static T getAsValue(const PIVariant & v) {
#ifdef CUSTOM_PIVARIANT
if (v._content.isEmpty() || !v._info) return T();
PIString cn = __PIVariantFunctions__<T>::typeNameHelper();
uint cnid = __PIVariantFunctions__<T>::typeIDHelper();
//piCout << "gav" << cn;
PIByteArray ba;
if (cn == v._info->typeName) {
if (cnid == v._info->typeID) {
ba = v._content;
} else {
__PIVariantInfo__::castHelperFunc cf = v._info->cast.value(cn.hash());
__PIVariantInfo__::castHelperFunc cf = v._info->cast.value(cnid);
//piCout << "gav cast" << cf;
if (!cf) return T();
ba = cf(v._content);

365
main.cpp
View File

@@ -13,217 +13,174 @@ typedef PIVector<PIVariant> PIVariantVector;
REGISTER_VARIANT(PIVariantMap);
REGISTER_VARIANT(PIVariantVector);
#ifdef WINDOWS
# include <namedpipeapi.h>
# include <handleapi.h>
# include <fileapi.h>
# include <processthreadsapi.h>
typedef HANDLE pipe_type;
#else
# include <unistd.h>
typedef int pipe_type;
#endif
struct Pipe {
pipe_type fd_read = 0;
pipe_type fd_write = 0;
void create() {
#ifdef WINDOWS
CreatePipe(&fd_read, &fd_write, NULL, 0);
#else
pipe((int*)this);
#endif
}
void destoy() {
#ifdef WINDOWS
CloseHandle(fd_read);
CloseHandle(fd_write);
#else
close(fd_read);
close(fd_write);
#endif
}
int read(void * d, int s) {
#ifdef WINDOWS
DWORD ret(0);
ReadFile(fd_read, d, s, &ret, NULL);
return ret;
#else
return ::read(fd_read, d, s);
#endif
}
int write(void * d, int s) {
#ifdef WINDOWS
DWORD ret(0);
WriteFile(fd_write, d, s, &ret, NULL);
return ret;
#else
return ::write(fd_write, d, s);
#endif
}
};
constexpr int count = 4;
Pipe pipes[count];
class T: public PIThread {
class PIValueTree {
public:
T(int index): PIThread() {ind = index; pipe = pipes[index];}
void run() {
PIByteArray data(1024);
piCout << "[T"<<ind<<"] start";
int readed = pipe.read(data.data(), data.size());
piCout << "[T"<<ind<<"] readed" << readed << errorString();
piCout << "[T"<<ind<<"] end";
}
int ind;
Pipe pipe;
PIValueTree();
PIValueTree(const PIVariant & v);
PIValueTree(const PIString & n, const PIVariant & v);
enum FlagStandard {
Hidden = 0x01,
Editable = 0x02,
Label = 0x04,
ArrayReorder = 0x1001,
ArrayDynamic = 0x1002,
};
PITimeMeasurer tm;
void phase(const char * msg) {
piCout << "";
piCout << piRound(tm.elapsed_s() * 10) / 10. << "s" << msg;
bool isNull() const {return _is_null;}
bool isValid() const {return _value.isValid();}
const PIString & name() const {return _name;}
void setName(const PIString & n);
const PIVariant & value() const {return _value;}
void setValue(const PIVariant & v);
const PIVector<PIValueTree> & children() const {return _children;}
const PIVariantMap & attributes() const {return _attributes;}
PIVariantMap & attributes() {return _attributes;}
PIFlags<FlagStandard> flagsStandard() {return _flags_standard;}
uint flagsCustom() {return _flags_custom;}
bool contains(const PIString & name) const;
PIValueTree child(const PIString & name) const;
PIValueTree & child(const PIString & name);
PIValueTree & insert(const PIValueTree & n);
PIValueTree & remove(const PIString & name);
private:
static PIValueTree & nullValue();
PIString _name;
PIVariantMap _attributes;
PIVariant _value;
PIVector<PIValueTree> _children;
uint _flags_standard = Editable;
uint _flags_custom = 0u;
bool _is_null = false;
};
PIValueTree::PIValueTree() {
}
PIValueTree::PIValueTree(const PIVariant & v) {
setValue(v);
}
PIValueTree::PIValueTree(const PIString & n, const PIVariant & v) {
setName(n);
setValue(v);
}
void PIValueTree::setName(const PIString & n) {
if (_is_null) return;
_name = n;
}
void PIValueTree::setValue(const PIVariant & v) {
if (_is_null) return;
_value = v;
}
bool PIValueTree::contains(const PIString & name) const {
if (_is_null) return true;
for (const auto & c: _children)
if (c.name() == name)
return true;
return false;
}
PIValueTree PIValueTree::child(const PIString & name) const {
if (_is_null) return PIValueTree();
for (const auto & c: _children)
if (c.name() == name)
return c;
return PIValueTree();
}
PIValueTree & PIValueTree::child(const PIString & name) {
if (_is_null) return nullValue();
for (auto & c: _children)
if (c.name() == name)
return c;
return nullValue();
}
PIValueTree & PIValueTree::insert(const PIValueTree & n) {
if (_is_null) return nullValue();
for (auto & c: _children)
if (c.name() == n.name()) {
c = n;
return *this;
}
_children << n;
return *this;
}
PIValueTree & PIValueTree::remove(const PIString & name) {
if (_is_null) return nullValue();
_children.removeWhere([name](const PIValueTree & i){return i.name() == name;});
return *this;
}
PIValueTree & PIValueTree::nullValue() {
static PIValueTree ret;
ret._is_null = true;
return ret;
}
struct SomeType {
int i;
float f;
};
PICout operator <<(PICout c, const SomeType & v) {
c << "SomeType(" << v.i << "," << v.f << ")";
return c;
}
REGISTER_VARIANT(SomeType);
REGISTER_VARIANT_CAST(SomeType, PIString) {
return PIString::fromNumber(v.i) + ";" + PIString::fromNumber(v.f);
}
REGISTER_VARIANT_CAST(PIString, SomeType) {
PIStringList sl = v.split(';').resize(2);
return SomeType{sl[0].toInt(), sl[1].toFloat()};
}
int main(int argc, char * argv[]) {
/*piCout << "main";
PITimer timer;
timer.setSlot([](){
static int cnt = 0;
piCout << "tick" << ++cnt;
});
timer.start(500);
piSleep(1.12);
piCout << "end";
PITimeMeasurer tm;
timer.stop();
double tm_ms = tm.elapsed_m();
piCout << "stop took" << tm_ms;*/
/*PIWaitEvent event;
event.create();
tm.reset();
PIThread::runOnce([&event](){
//piMSleep(100);
piCout << "interrupt";
//event.interrupt();
});
event.sleep(2010000);
double tm_ms = tm.elapsed_m();
piCout << "waited for" << tm_ms;
return 0;*/
/*for (int i = 0; i < count; ++i)
pipes[i].create();
PIVector<T*> threads;
piCout << "main start";
for (int i = 0; i < count; ++i) {
T * t = new T(i);
threads << t;
t->startOnce();
}
piMSleep(100);
for (int i = 0; i < count; ++i) {
//pipes[i].write((void*)"string", 7);
piMSleep(500);
}
piCout << "main wait";
for (int i = 0; i < count; ++i) {
threads[i]->interrupt();
threads[i]->waitForFinish();
piCout << "main T" << i << "done";
}
piCout << "main end";
for (int i = 0; i < count; ++i) {
pipes[i].destoy();
delete threads[i];
}*/
//PIEthernet eth(PIEthernet::UDP), seth(PIEthernet::UDP);
//eth.setReadAddress("127.0.0.1", 50000);
//eth.startThreadedRead();
//piCout << eth.open();
/*PIByteArray req = PIByteArray::fromHex("205e011000000000ef");
PISerial ser;
ser.setSpeed(PISerial::S9600);
ser.setOption(PIIODevice::BlockingRead, false);
ser.setVTime(200);
ser.open("COM3");
CONNECTL(&ser, threadedReadEvent, ([](const uchar * data, ssize_t size){
piCout << "*ser readed" << size;
}));
PIThread thread;
thread.start([&](void*){
piCout << "[T] start";
PIByteArray data = ((PIIODevice*)&ser)->read(1024);
piCout << "[T] readed" << data.size();// << errorString();
piCout << "[T] end";
}, 200);
//ser.startThreadedRead();
piSleep(1);
ser.write(req);
phase("Send");
piSleep(2);
phase("End");*/
PIEthernet eth(PIEthernet::TCP_Client), seth(PIEthernet::TCP_Server), * server_client = nullptr;
seth.listen("127.0.0.1", 50000, true);
//seth.startThreadedRead();
CONNECTL(&seth, newConnection, ([&server_client](PIEthernet * e){
server_client = e;
e->setName("TCP SC");
piCout << "newConn" << e;
CONNECTL(e, threadedReadEvent, ([](const uchar * data, ssize_t size){
piCout << "*TCP SC* readed" << size;
}));
CONNECTL(e, disconnected, ([](bool error){
piCout << "*TCP SC* disconnected" << error;
}));
e->startThreadedRead();
}));
eth.setName("TCP CC");
//eth.setParameter(PIEthernet::KeepConnection, false);
CONNECTL(&eth, connected, ([&eth](){
piCout << "*TCP CC* connected";
eth.send("byte", 5);
}));
CONNECTL(&eth, disconnected, ([](bool error){
piCout << "*TCP CC* disconnected" << error;
}));
piMSleep(500);
phase("Connect");
eth.connect("127.0.0.1", 50000);
eth.startThreadedRead();
piMSleep(500);
phase("Send 5");
piCout << "c-ing" << eth.isConnecting();
piCout << "c- ed" << eth.isConnected();
eth.send("byte", 5);
piMSleep(500);
phase("Send 6");
eth.send("bytes", 6);
piMSleep(500);
phase("Disconnect");
if (server_client)
server_client->close();
//eth.close();
piMSleep(500);
phase("END");
PIValueTree root;
root.insert({"bool", PIVariant(false)});
root.insert({"integer", PIVariant(256)});
root.insert({"string", PIVariant("str")});
//for (auto it: root.children()) {
// piCout << it.name() << it.value();
//}
PIVariant v = PIVariant::fromValue(SomeType{1, 0.5f});
piCout << v;
piCout << v.toString();
v.setValueFromString("2;-0.1");
piCout << v;
piCout << v.toString();
return 0;
}