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

review fixes

Browse Source
This commit is contained in:
Бычков Андрей
2025-08-12 13:57:06 +03:00
parent 7e371132ae
commit d62599fb8e
4 changed files with 436 additions and 333 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
libs/main/serialization/pijsonserialization.h
View File

@@ -23,8 +23,8 @@
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#ifndef pijsonserialization_H #ifndef PIJSONSERIALIZATION_H
#define pijsonserialization_H #define PIJSONSERIALIZATION_H
#include "pijson.h" #include "pijson.h"
@@ -191,8 +191,8 @@ inline PIJSON piSerializeJSON(const PIDeque<T> & v) {
template<typename T> template<typename T>
inline PIJSON piSerializeJSON(const PIVector2D<T> & v) { inline PIJSON piSerializeJSON(const PIVector2D<T> & v) {
PIJSON ret; PIJSON ret;
ret["cols"] = v.cols(); ret["cols"] = static_cast<uint>(v.cols());
ret["rows"] = v.rows(); ret["rows"] = static_cast<uint>(v.rows());
ret["mat"] = piSerializeJSON(v.plainVector()); ret["mat"] = piSerializeJSON(v.plainVector());
return ret; return ret;
} }
@@ -255,10 +255,9 @@ inline void piDeserializeJSON(PIVariant & v, const PIJSON & js) {
template<typename T> template<typename T>
inline void piDeserializeJSON(complex<T> & v, const PIJSON & js) { inline void piDeserializeJSON(complex<T> & v, const PIJSON & js) {
T c[2]; if (!js.isArray()) return;
piDeserializeJSON(c[0], js[0]); piDeserializeJSON(reinterpret_cast<T(&)[2]>(v)[0], js[0]);
piDeserializeJSON(c[1], js[1]); piDeserializeJSON(reinterpret_cast<T(&)[2]>(v)[1], js[1]);
v = complex<T>(c[0], c[1]);
} }
template<typename T> template<typename T>
@@ -366,10 +365,10 @@ template<typename T>
inline void piDeserializeJSON(PIVector2D<T> & v, const PIJSON & js) { inline void piDeserializeJSON(PIVector2D<T> & v, const PIJSON & js) {
v.clear(); v.clear();
if (!js.isObject()) return; if (!js.isObject()) return;
v.resize(js["rows"].toInt(), js["cols"].toInt());
const auto & mat(js["mat"]); const auto & mat(js["mat"]);
if (!mat.isArray()) return; if (!mat.isArray()) return;
piDeserializeJSON(v.plainVector(), mat); piDeserializeJSON(v.plainVector(), mat);
v.resize(js["rows"].toInt(), js["cols"].toInt());
} }
template<typename T> template<typename T>
@@ -412,4 +411,4 @@ T PIJSON::deserialize(const PIJSON & json) {
} }
#endif // pijsonserialization_h #endif // PIJSONSERIALIZATION_H

81
libs/main/text/piregularexpression.cpp
View File

@@ -39,8 +39,8 @@ PRIVATE_DEFINITION_START(PIRegularExpression)
PIString getNEString(const void * ptr, uint32_t max_size) { PIString getNEString(const void * ptr, uint32_t max_size) {
PIString ret; PIString ret;
auto * cptr = (PIChar *)ptr; const auto * cptr = static_cast<const PIChar *>(ptr);
uint32_t sz = 0; uint32_t sz = 0;
while (*cptr != PIChar()) { while (*cptr != PIChar()) {
ret.append(*cptr); ret.append(*cptr);
cptr++; cptr++;
@@ -64,15 +64,14 @@ PRIVATE_DEFINITION_START(PIRegularExpression)
bool compile(PIString & pat, Options opt) { bool compile(PIString & pat, Options opt) {
free(); free();
if (pat.isEmpty()) return false; if (pat.isEmpty()) return false;
auto * pat_ptr = &(pat[0]); const auto * pat_ptr = &pat.front();
int error_number = 0; int error_number = 0;
compiled = pcre2_compile((PCRE2_SPTR)pat_ptr, pat.size(), convertOptions(opt), &error_number, &error_offset, nullptr); compiled = pcre2_compile((PCRE2_SPTR)pat_ptr, pat.size(), convertOptions(opt), &error_number, &error_offset, nullptr);
if (!compiled) { if (!compiled) {
PIChar buffer[256]; PIChar buffer[256];
int sz = pcre2_get_error_message(error_number, (PCRE2_UCHAR16 *)buffer, sizeof(buffer)); const int sz = pcre2_get_error_message(error_number, reinterpret_cast<PCRE2_UCHAR16 *>(buffer), sizeof(buffer));
error_msg = PIString(buffer, sz); error_msg = PIString(buffer, sz);
return false; return false;
// printf("PCRE2 compilation failed at offset %d: %s\n", (int)erroroffset, buffer);
} }
error_msg.clear(); error_msg.clear();
match_data = pcre2_match_data_create_from_pattern(compiled, nullptr); match_data = pcre2_match_data_create_from_pattern(compiled, nullptr);
@@ -86,7 +85,7 @@ PRIVATE_DEFINITION_START(PIRegularExpression)
capture_count = cap_cout; capture_count = cap_cout;
auto tabptr = name_table; auto tabptr = name_table;
for (uint32_t i = 0; i < namecount; i++) { for (uint32_t i = 0; i < namecount; i++) {
int gnum = *(ushort *)tabptr; const int gnum = *tabptr;
PIString gname = getNEString(tabptr + 1, name_entry_size); PIString gname = getNEString(tabptr + 1, name_entry_size);
named_group_index[gname] = gnum; named_group_index[gname] = gnum;
named_group_name[gnum] = gname; named_group_name[gnum] = gname;
@@ -97,26 +96,25 @@ PRIVATE_DEFINITION_START(PIRegularExpression)
} }
void match(Matcher & ret) { void match(Matcher & ret) {
int rc = pcre2_match(compiled, const int rc = pcre2_match(compiled,
(PCRE2_SPTR)ret.subjectPtr(), (PCRE2_SPTR)ret.subjectPtr(),
ret.subject->size(), ret.subject->size(),
ret.start_offset, ret.start_offset,
PCRE2_NO_UTF_CHECK, PCRE2_NO_UTF_CHECK,
match_data, match_data,
nullptr); nullptr);
ret.has_match = ret.is_error = false; ret.has_match = ret.is_error = false;
ret.groups.clear(); ret.groups.clear();
if (rc == PCRE2_ERROR_NOMATCH) return; if (rc == PCRE2_ERROR_NOMATCH) return;
if (rc < 0) { if (rc < 0) {
ret.is_error = true; ret.is_error = true;
} else { } else {
ret.has_match = true; ret.has_match = true;
auto ovector = pcre2_get_ovector_pointer(match_data); const auto ovector = pcre2_get_ovector_pointer(match_data);
for (int i = 0; i < rc; i++) { for (int i = 0; i < rc; i++) {
Matcher::Group g; Matcher::Group g;
g.index = ovector[2 * i]; g.index = ovector[2 * i];
g.size = ovector[2 * i + 1] - ovector[2 * i]; g.size = ovector[2 * i + 1] - ovector[2 * i];
// g.string = PIString(&(sub_ptr[g.index]), g.size);
ret.groups << g; ret.groups << g;
} }
ret.start_offset = ovector[1]; ret.start_offset = ovector[1];
@@ -194,7 +192,7 @@ int PIRegularExpression::captureGroupIndex(const PIString & gname) const {
} }
PIRegularExpression::Matcher PIRegularExpression::makeMatcher(PIString & subject, size_t offset) { PIRegularExpression::Matcher PIRegularExpression::matchIterator(PIString & subject, size_t offset) {
PIRegularExpression::Matcher ret(this); PIRegularExpression::Matcher ret(this);
ret.start_offset = offset; ret.start_offset = offset;
ret.subject = &subject; ret.subject = &subject;
@@ -202,7 +200,16 @@ PIRegularExpression::Matcher PIRegularExpression::makeMatcher(PIString & subject
} }
PIRegularExpression::Matcher PIRegularExpression::makeMatcher(const PIString & subject, size_t offset) { PIRegularExpression::Matcher PIRegularExpression::matchIterator(PIString && subject, size_t offset) {
PIRegularExpression::Matcher ret(this);
ret.start_offset = offset;
ret.subject_own = std::move(subject);
ret.subject = &ret.subject_own;
return ret;
}
PIRegularExpression::Matcher PIRegularExpression::matchIterator(const PIString & subject, size_t offset) {
PIRegularExpression::Matcher ret(this); PIRegularExpression::Matcher ret(this);
ret.start_offset = offset; ret.start_offset = offset;
ret.subject_own = subject; ret.subject_own = subject;
@@ -212,14 +219,21 @@ PIRegularExpression::Matcher PIRegularExpression::makeMatcher(const PIString & s
PIRegularExpression::Matcher PIRegularExpression::match(PIString & subject, size_t offset) { PIRegularExpression::Matcher PIRegularExpression::match(PIString & subject, size_t offset) {
PIRegularExpression::Matcher ret = makeMatcher(subject, offset); PIRegularExpression::Matcher ret = matchIterator(subject, offset);
PRIVATE->match(ret);
return ret;
}
PIRegularExpression::Matcher PIRegularExpression::match(PIString && subject, size_t offset) {
PIRegularExpression::Matcher ret = matchIterator(std::move(subject), offset);
PRIVATE->match(ret); PRIVATE->match(ret);
return ret; return ret;
} }
PIRegularExpression::Matcher PIRegularExpression::match(const PIString & subject, size_t offset) { PIRegularExpression::Matcher PIRegularExpression::match(const PIString & subject, size_t offset) {
PIRegularExpression::Matcher ret = makeMatcher(subject, offset); PIRegularExpression::Matcher ret = matchIterator(subject, offset);
PRIVATE->match(ret); PRIVATE->match(ret);
return ret; return ret;
} }
@@ -230,7 +244,7 @@ PIRegularExpression::Matcher::Matcher(PIRegularExpression * p): parent(p) {}
PIChar * PIRegularExpression::Matcher::subjectPtr() const { PIChar * PIRegularExpression::Matcher::subjectPtr() const {
if (!subject) return nullptr; if (!subject) return nullptr;
return &(*subject)[0]; return &subject->front();
} }
@@ -248,8 +262,9 @@ bool PIRegularExpression::Matcher::next() {
PIStringList PIRegularExpression::Matcher::matchedStrings() const { PIStringList PIRegularExpression::Matcher::matchedStrings() const {
if (!subject) return {}; if (!subject) return {};
PIStringList ret; PIStringList ret;
for (const auto & g: groups) for (const auto & g: groups) {
ret << subject->mid(g.index, g.size); ret << subject->mid(g.index, g.size);
}
return ret; return ret;
} }
@@ -304,19 +319,19 @@ PIRegularExpression PIRegularExpression::fromPOSIX(const PIString & pattern, Opt
void PIRegularExpression::convertFrom(const PIString & pattern, uint type, Options opt) { void PIRegularExpression::convertFrom(const PIString & pattern, uint type, Options opt) {
if (pattern.isEmpty()) return; if (pattern.isEmpty()) return;
PIChar * cptr = &((PIString &)pattern)[0]; const auto cptr = &const_cast<PIString &>(pattern).front();
PCRE2_UCHAR * out = nullptr; PCRE2_UCHAR * out = nullptr;
PCRE2_SIZE out_size = 0; PCRE2_SIZE out_size = 0;
int rc = pcre2_pattern_convert((PCRE2_SPTR)cptr, const int rc = pcre2_pattern_convert((PCRE2_SPTR)cptr,
pattern.size_s(), pattern.size_s(),
type | PCRE2_CONVERT_UTF | PCRE2_CONVERT_NO_UTF_CHECK, type | PCRE2_CONVERT_UTF | PCRE2_CONVERT_NO_UTF_CHECK,
&out, &out,
&out_size, &out_size,
nullptr); nullptr);
if (rc != 0) { if (rc != 0) {
piCout << "PIRegularExpression::convertFrom error" << rc; piCout << "PIRegularExpression::convertFrom error" << rc;
} else { } else {
setPattern(PIString((PIChar *)out, out_size), opt); setPattern(PIString(reinterpret_cast<PIChar *>(out), out_size), opt);
} }
pcre2_converted_pattern_free(out); pcre2_converted_pattern_free(out);
} }

16
libs/main/text/piregularexpression.h
View File

@@ -23,10 +23,10 @@
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#ifndef piregularexpression_h #ifndef PIREGULAREXPRESSION_H
#define piregularexpression_h #define PIREGULAREXPRESSION_H
#include <pistring.h> #include "pistring.h"
class PIP_EXPORT PIRegularExpression { class PIP_EXPORT PIRegularExpression {
public: public:
@@ -105,9 +105,11 @@ public:
Matcher match(const PIString & subject, size_t offset = 0); Matcher match(const PIString & subject, size_t offset = 0);
Matcher match(PIString & subject, size_t offset = 0); Matcher match(PIString & subject, size_t offset = 0);
Matcher match(PIString && subject, size_t offset = 0);
Matcher makeMatcher(const PIString & subject, size_t offset = 0); Matcher matchIterator(const PIString & subject, size_t offset = 0);
Matcher makeMatcher(PIString & subject, size_t offset = 0); Matcher matchIterator(PIString & subject, size_t offset = 0);
Matcher matchIterator(PIString && subject, size_t offset = 0);
static PIRegularExpression fromGlob(const PIString & pattern, Options opt = None); static PIRegularExpression fromGlob(const PIString & pattern, Options opt = None);
static PIRegularExpression fromPOSIX(const PIString & pattern, Options opt = None); static PIRegularExpression fromPOSIX(const PIString & pattern, Options opt = None);
@@ -116,8 +118,8 @@ private:
void convertFrom(const PIString & pattern, uint type, Options opt); void convertFrom(const PIString & pattern, uint type, Options opt);
PRIVATE_DECLARATION(PIP_EXPORT) PRIVATE_DECLARATION(PIP_EXPORT)
PIString pat_, subj_own; PIString pat_;
Options opt_; Options opt_;
}; };
#endif #endif // PIREGULAREXPRESSION_H

653
main.cpp
View File

@@ -1,283 +1,370 @@
#include "libs/http_client/curl_thread_pool_p.h" #include "libs/http_client/curl_thread_pool_p.h"
#include "pidigest.h" #include "picodeparser.h"
#include "pihttpclient.h" #include "pidigest.h"
#include "pip.h" #include "pihttpclient.h"
#include "pip.h"
using namespace PICoutManipulators; #include "pivaluetree_conversions.h"
using namespace PIHTTP;
using namespace PICoutManipulators;
using namespace PIHTTP;
class PIThreadPoolLoopNW {
public:
PIThreadPoolLoopNW(int thread_cnt = -1) { struct SN {
if (thread_cnt <= 0) thread_cnt = piMaxi(1, PISystemInfo::instance()->processorsCount); int _ii;
piForTimes(thread_cnt) { complexf _co;
auto * t = new PIThread([this]() { PIIODevice::DeviceMode m;
while (true) { };
sem_exec.acquire(); struct S {
if (is_destroy) return; bool _b;
int cc = counter.fetch_add(1); int _i;
func(cc); float _f;
sem_done.release(); PIString str;
} // SN _sn;
}); PIVector2D<bool> v2d;
threads << t; PIByteArray ba;
} PISystemTime st;
for (auto * t: threads) PINetworkAddress na;
t->start(); PIPointd po;
// piCout << "PIThreadPoolLoop" << proc_cnt << "threads"; PILined li;
} PIRectd re;
};
virtual ~PIThreadPoolLoopNW() {
is_destroy = true; template<>
for (auto * t: threads) PIJSON piSerializeJSON(const SN & v) {
t->stop(); PIJSON ret;
sem_exec.release(threads.size()); ret["_ii"] = piSerializeJSON(v._ii);
for (auto * t: threads) { ret["_co"] = piSerializeJSON(v._co);
if (!t->waitForFinish(100_ms)) t->terminate(); ret["m"] = piSerializeJSON(v.m);
delete t; return ret;
} }
} template<>
PIJSON piSerializeJSON(const S & v) {
void setFunction(std::function<void(int)> f) { func = f; } PIJSON ret;
ret["_b"] = piSerializeJSON(v._b);
void wait() { ret["_i"] = piSerializeJSON(v._i);
// piCout << "wait" << wait_count; ret["_f"] = piSerializeJSON(v._f);
if (wait_count <= 0) return; ret["str"] = piSerializeJSON(v.str);
sem_done.acquire(wait_count); // ret["_sn"] = piSerializeJSON(v._sn);
wait_count = 0; ret["v2d"] = piSerializeJSON(v.v2d);
// piCout << "wait done"; ret["ba"] = piSerializeJSON(v.ba);
} ret["st"] = piSerializeJSON(v.st);
ret["na"] = piSerializeJSON(v.na);
void start(int index_start, int index_count) { ret["po"] = piSerializeJSON(v.po);
counter = index_start; ret["li"] = piSerializeJSON(v.li);
wait_count = index_count; ret["re"] = piSerializeJSON(v.re);
sem_exec.release(index_count);
} return ret;
}
void exec(int index_start, int index_count) {
start(index_start, index_count); template<>
wait(); void piDeserializeJSON(SN & v, const PIJSON & js) {
} v = {};
piDeserializeJSON(v._ii, js["_ii"]);
void exec(int index_start, int index_count, std::function<void(int)> f) { piDeserializeJSON(v._co, js["_co"]);
setFunction(f); piDeserializeJSON(v.m, js["m"]);
exec(index_start, index_count); }
} template<>
void piDeserializeJSON(S & v, const PIJSON & js) {
private: v = {};
PIVector<PIThread *> threads; piDeserializeJSON(v._b, js["_b"]);
std::function<void(int)> func; piDeserializeJSON(v._i, js["_i"]);
PISemaphore sem_exec, sem_done; piDeserializeJSON(v._f, js["_f"]);
std::atomic_bool is_destroy = {false}; piDeserializeJSON(v.str, js["str"]);
std::atomic_int counter = {0}, wait_count = {0}; // piDeserializeJSON(v._sn, js["_sn"]);
}; piDeserializeJSON(v.v2d, js["v2d"]);
piDeserializeJSON(v.ba, js["ba"]);
piDeserializeJSON(v.st, js["st"]);
// PIKbdListener kbd; piDeserializeJSON(v.na, js["na"]);
PIVector<int> vec; piDeserializeJSON(v.po, js["po"]);
piDeserializeJSON(v.li, js["li"]);
int main(int argc, char * argv[]) { piDeserializeJSON(v.re, js["re"]);
vec.resize(16); }
vec.fill([](int i) { return i; });
piCout << vec; int main(int argc, char * argv[]) {
// PIRegularExpression pire("привет"_u8, PIRegularExpression::CaseInsensitive);
PIThreadPoolLoop tpl(8); // PIString subj = "the dog ПриВет sat on the cat"_u8;
tpl.setFunction([](int i) { vec[i]++; }); // PIRegularExpression pire("^(?<date>\\d\\d)/(?<month>\\d\\d)/(?<year>\\d\\d\\d\\d)$"_u8);
// PIString subj = "08/12/1985"_u8;
const int count = 10000;
PITimeMeasurer tm; PIString pat = "*.Exe";
piForTimes(count) { PIRegularExpression re_g = PIRegularExpression::fromGlob(pat, PIRegularExpression::CaseInsensitive);
tpl.exec(0, 16); PIRegularExpression re_p = PIRegularExpression::fromPOSIX(pat, PIRegularExpression::CaseInsensitive);
} PIStringList files = {
// tpl.exec(0, 16); "(Audio) 20250318-0852-16.8641941.m4a",
auto el = tm.elapsed().toMilliseconds(); "dxwebsetup.exe",
piCout << "el" << el << "ms," << (el / count * 1000) << "us per round"; "Firefox Installer.exe",
"LTA8092XS8_R8.pdf",
// tpl.wait(); "SteamSetup.exe",
piCout << vec; "TBT_1.41.1325.0.exe",
return 0; };
piCout << " src pat" << pat.quoted();
/*piForTimes(10) { piCout << " Glob pat" << re_g.pattern().quoted();
PIThread t; piCout << "POSIX pat" << re_p.pattern().quoted();
t.setName("thread____"); piCout << "\nG P File";
t.startOnce([]() { for (auto f: files) {
// piCout << "thread"; piCout << (re_g.match(f) ? 1 : 0) << (re_p.match(f) ? 1 : 0) << f;
piMSleep(2.); }
}); // return 0;
PITimeMeasurer tm; PIRegularExpression pire("(?:\\/\\/\\s*)?.*\\n?(?:\\bfunction\\b)\\s*(?<name>\\b\\w+\\b)\\s*(?:\\((?<args>[^;()]*?)\\))",
t.stopAndWait(); PIRegularExpression::Multiline);
auto el = tm.elapsed(); PIString subj = PIString::fromUTF8(PIFile::readAll("telegram.qs", false));
piCout << el.toMilliseconds();
} piCout << "Pattern:" << pire.pattern();
piCout << "Valid:" << pire.isValid();
return 0;*/ piCout << "Error at" << pire.errorPosition() << ":" << pire.errorString();
piCout << "Groups count:" << pire.captureGroupsCount();
/*auto src = PIByteArray::fromAscii("The quick brown fox jumps over the lazy dog"); piCout << "Named groups:" << pire.captureGroupNames();
auto key = PIByteArray::fromAscii("key"); piCout << "";
PIStringList tnl; auto mr = pire.matchIterator(subj);
int max_size = 0; auto pire2 = pire;
for (int t = 0; t < (int)PIDigest::Type::C ount; ++t) {
tnl << PIDigest::typeName((PIDigest::Type)t); while (mr.next()) {
max_size = piMaxi(max_size, tnl.back().size_s()); // piCout << "Subject" << subj;
} piCout << "Matched:" << mr.hasMatch();
PIByteArray hs;
piCout << PIString::fromAscii(src); piCout << "By number";
for (int t = 0; t < (int)PIDigest::Type::Count; ++t) { for (int i = 0; i <= pire.captureGroupsCount(); ++i)
hs = PIDigest::calculate(src, (PIDigest::Type)t); piCout << i << "=" << mr.matchedString(i).trimmed();
piCout << tnl[t].expandLeftTo(max_size, ' ') << "->" << hs.toHex();
} piCout << "By name";
for (int t = 0; t < (int)PIDigest::Type::Count; ++t) { for (auto g: pire.captureGroupNames())
const int bench_count = 100000; piCout << g.quoted() << "=" << mr.matchedString(g);
PITimeMeasurer tm;
piForTimes(bench_count) { piCout << "";
hs = PIDigest::calculate(src, (PIDigest::Type)t); }
}
auto el = tm.elapsed(); piCout << "!!!!!!!!!!!!!!!!!";
piCout << tnl[t].expandLeftTo(max_size, ' ') << "time" << el.toMilliseconds();
} pire.match("vfsmndvbjbdlgdvb gdgf");
pire.match(subj);
// src.clear();
// crypto_hash_sha512(sout.data(), src.data(), src.size()); {
// piCout << "sod:" << sout.toHex(); PIVector<complexf> vec;
// piCout << "512:" << sha5xx(src, initial_512, 64).toHex(); vec << complexf{0.1, 0.2} << complexf{-1, 0.5};
return 0;*/ auto js = PIJSON::serialize(vec);
piCout << vec;
/*PIHTTPServer server; piCout << js;
server.listen({"127.0.0.1:7777"}); piCout << PIJSON::deserialize<typeof(vec)>(js);
// server.setBasicAuthRealm("pip"); }
// server.setBasicAuthEnabled(true);
// server.setBasicAuthCallback([](const PIString & u, const PIString & p) -> bool { return 0;
// piCout << "basic auth" << u << p; /*PICodeParser parser;
// return (u == "u" && p == "p"); parser.parseFile("c:/work/shstk/pip/test_header.h", false);
// });
server.registerPath("sendMessage", Method::Post, [](const PIHTTP::MessageConst & msg) -> PIHTTP::MessageMutable { for (const auto * e: parser.entities) {
return MessageMutable().setCode(Code::Accepted); piCout << e->type << e->name << "{";
}); for (const auto & m: e->members) {
server.registerUnhandled([](const PIHTTP::MessageConst & msg) -> PIHTTP::MessageMutable { piCout << " " << m.type << m.name;
PIHTTP::MessageMutable ret; }
piCout << "server rec:\n\tpath: %1\n\tmethod: %2\n\targs: %3\n\theaders: %4\n\tbody: %5\n"_a.arg(msg.path()) piCout << "}";
.arg(PIHTTP::methodName(msg.method())) }
.arg(piStringify(msg.arguments()))
.arg(PIStringList(msg.headers().map<PIString>([](PIString k, PIString v) { return k + " = " + v; })).join("\n\t\t ")) return 0;*/
.arg(PIString::fromUTF8(msg.body()));
ret.setCode(PIHTTP::Code::BadRequest); // PIJSON j = piSerializeJSON(s);
ret.setBody(PIByteArray::fromAscii("hello client! 0123456789")); // piDeserializeJSON(s, j);
piSleep(5.); PIVector<complexf> vec;
return ret; vec << complexf{0.1, 0.2} << complexf{-1, 0.5};
}); auto js = PIJSON::serialize(vec);
kbd.waitForFinish(); piCout << vec;
return 0;*/ piCout << js;
piCout << PIJSON::deserialize<typeof(vec)>(js);
/*PIHTTP::MessageMutable req;
req.setBody(PIByteArray::fromAscii("hello server!")).addArgument("a0", "val.0").addArgument("a~r1", "знач,1"_u8); /*PIVector<S> s;
auto * c = PIHTTPClient::create("http://u:p@127.0.0.1:7777/api", PIHTTP::Method::Get, req); s << S{false, 0, 0.1} << S{true, 1, -10.1};
c->onFinish([](PIHTTP::MessageConst msg) { PIMap<int, S> m;
piCout << "client rec:\n\tpath: %1\n\tmethod: %2\n\targs: %3\n\theaders: %4\n\tbody: %5\n"_a.arg(msg.path()) m[1] = S{false, 0, 0.15};
.arg(PIHTTP::methodName(msg.method())) m[2] = S{true, 1, -10.1};
.arg(piStringify(msg.arguments())) // m[1]._sn._co = {3, 4};
.arg( PIJSON j = piSerializeJSON(m);
PIStringList(msg.headers().map<PIString>([](PIString k, PIString v) { return k + " = " + v; })).join("\n\t\t piCout << j;
")) .arg(PIString::fromUTF8(msg.body())); piDeserializeJSON(m, j);
}) piCout << m[1]._f;*/
->onError([c](PIHTTP::MessageConst r) { // piCout << m[1]._sn._co;
piCout << "error" << (int)r.code();
piCout << "msg" << c->lastError(); /*PIVector<int> v({-1, 0, 10, 200});
}) PIMap<int, float> m({
->onAbort([c](PIHTTP::MessageConst r) { {-1, -0.1 },
piCout << "abort" << (int)r.code(); {0, 0.1 },
piCout << "msg" << c->lastError(); {100, 200.2}
}) });
->start();*/
auto * c = PIHTTPClient::create( piCout << v;
PIString("127.0.0.1:7777/%1").arg("sendMessag"), piCout << piSerializeJSON(v);
Method::Post, piDeserializeJSON(v, piSerializeJSON(v));
MessageMutable().addHeader(Header::ContentType, "application/json").setBody(PIByteArray::fromAscii("{hello}"))); piCout << v;
c->onFinish([](const PIHTTP::MessageConst & msg) { piCout << "message finish" << (int)msg.code() << PIString::fromUTF8(msg.body()); }) piCout << m;
->onError([c](const PIHTTP::MessageConst & msg) { piCout << "message error" << c->lastError(); }) piDeserializeJSON(m, piSerializeJSON(m));
->onAbort([c](const PIHTTP::MessageConst & msg) { piCout << "aborted"; }) piCout << piSerializeJSON(m);*/
->start();
return 0;
piMSleep(1000);
// CurlThreadPool::instance()->destroy(); /*auto src = PIByteArray::fromAscii("The quick brown fox jumps over the lazy dog");
// kbd.enableExitCapture(); auto key = PIByteArray::fromAscii("key");
// WAIT_FOR_EXIT
// kbd.stopAndWait(); PIStringList tnl;
int max_size = 0;
// server.stop(); for (int t = 0; t < (int)PIDigest::Type::C ount; ++t) {
c->abort(); tnl << PIDigest::typeName((PIDigest::Type)t);
piMSleep(10); max_size = piMaxi(max_size, tnl.back().size_s());
}
return 0; PIByteArray hs;
piCout << PIString::fromAscii(src);
// piCout << PIString::readableSize(PISystemMonitor::usedRAM()); for (int t = 0; t < (int)PIDigest::Type::Count; ++t) {
hs = PIDigest::calculate(src, (PIDigest::Type)t);
/*PIVector<int> vi; piCout << tnl[t].expandLeftTo(max_size, ' ') << "->" << hs.toHex();
piForTimes(10) { }
piSleep(2.); for (int t = 0; t < (int)PIDigest::Type::Count; ++t) {
vi.enlarge(1000000); const int bench_count = 100000;
piCout << "now" << vi.size() << vi.capacity(); PITimeMeasurer tm;
} piForTimes(bench_count) {
hs = PIDigest::calculate(src, (PIDigest::Type)t);
piSleep(5.);*/ }
/*kbd.enableExitCapture(); auto el = tm.elapsed();
piCout << tnl[t].expandLeftTo(max_size, ' ') << "time" << el.toMilliseconds();
PIHTTPServer server; }
server.setFavicon(PIFile::readAll("logo.png", false)); // src.clear();
// server.setOption(MicrohttpdServer::Option::HTTPSEnabled, true); // crypto_hash_sha512(sout.data(), src.data(), src.size());
server.listen({"127.0.0.1", 7777}); // piCout << "sod:" << sout.toHex();
// server.listen({"192.168.1.10", 7778}); // piCout << "512:" << sha5xx(src, initial_512, 64).toHex();
return 0;*/
server.registerPath("/", MicrohttpdServer::Method::Get, [](const MicrohttpdServer::Request & r) -> MicrohttpdServer::Reply {
MicrohttpdServer::Reply ret; /*PIHTTPServer server;
ret.setBody(PIByteArray::fromAscii(pageTitle)); server.listen({"127.0.0.1:7777"});
return ret; // server.setBasicAuthRealm("pip");
}); // server.setBasicAuthEnabled(true);
// server.setBasicAuthCallback([](const PIString & u, const PIString & p) -> bool {
server.registerPath("/html", MicrohttpdServer::Method::Get, [](const MicrohttpdServer::Request & r) -> MicrohttpdServer::Reply { // piCout << "basic auth" << u << p;
MicrohttpdServer::Reply ret; // return (u == "u" && p == "p");
ret.setBody("<!DOCTYPE html><html><body><p>arg=%1</p></body></html>"_a.arg(r.args.value("a0")).toUTF8()); // });
return ret; server.registerPath("sendMessage", Method::Post, [](const PIHTTP::MessageConst & msg) -> PIHTTP::MessageMutable {
}); return MessageMutable().setCode(Code::Accepted);
});
server.registerPath("/api", MicrohttpdServer::Method::Put, [](const MicrohttpdServer::Request & r) -> MicrohttpdServer::Reply { server.registerUnhandled([](const PIHTTP::MessageConst & msg) -> PIHTTP::MessageMutable {
MicrohttpdServer::Reply ret; PIHTTP::MessageMutable ret;
ret.setBody(PIByteArray::fromAscii("<!DOCTYPE html><html><body>API</body></html>")); piCout << "server rec:\n\tpath: %1\n\tmethod: %2\n\targs: %3\n\theaders: %4\n\tbody: %5\n"_a.arg(msg.path())
return ret; .arg(PIHTTP::methodName(msg.method()))
}); .arg(piStringify(msg.arguments()))
.arg(PIStringList(msg.headers().map<PIString>([](PIString k, PIString v) { return k + " = " + v; })).join("\n\t\t "))
server.registerPath("/api/", MicrohttpdServer::Method::Post, [](const MicrohttpdServer::Request & r) -> MicrohttpdServer::Reply { .arg(PIString::fromUTF8(msg.body()));
MicrohttpdServer::Reply ret; ret.setCode(PIHTTP::Code::BadRequest);
ret.setBody("<!DOCTYPE html><html><body>API etry %1</body></html>"_a.arg(r.path).toUTF8()); ret.setBody(PIByteArray::fromAscii("hello client! 0123456789"));
ret.setCode(405); piSleep(5.);
return ret; return ret;
}); });
kbd.waitForFinish();
server.registerUnhandled([](const MicrohttpdServer::Request & r) -> MicrohttpdServer::Reply { return 0;*/
MicrohttpdServer::Reply ret;
ret.setBody("<!DOCTYPE html><html><body>Unknown</body></html>"_a.arg(r.path).toUTF8()); /*PIHTTP::MessageMutable req;
ret.setCode(404); req.setBody(PIByteArray::fromAscii("hello server!")).addArgument("a0", "val.0").addArgument("a~r1", "знач,1"_u8);
return ret; auto * c = PIHTTPClient::create("http://u:p@127.0.0.1:7777/api", PIHTTP::Method::Get, req);
});*/ c->onFinish([](PIHTTP::MessageConst msg) {
piCout << "client rec:\n\tpath: %1\n\tmethod: %2\n\targs: %3\n\theaders: %4\n\tbody: %5\n"_a.arg(msg.path())
/*server.setRequestCallback([](MicrohttpdServer::Request r) -> MicrohttpdServer::Reply { .arg(PIHTTP::methodName(msg.method()))
MicrohttpdServer::Reply rep; .arg(piStringify(msg.arguments()))
piCout << "request" << r.path; .arg(
piCout << " header" << r.headers; PIStringList(msg.headers().map<PIString>([](PIString k, PIString v) { return k + " = " + v; })).join("\n\t\t
piCout << " args" << r.args; ")) .arg(PIString::fromUTF8(msg.body()));
piCout << " body" << r.body; })
piCout << ""; ->onError([c](PIHTTP::MessageConst r) {
rep.setBody(PIByteArray::fromAscii("[{\"value1\": true, \"value2\": \"ыекштп\"}]")); piCout << "error" << (int)r.code();
return rep; piCout << "msg" << c->lastError();
});*/ })
->onAbort([c](PIHTTP::MessageConst r) {
/*piCout << "start" << server.isListen(); piCout << "abort" << (int)r.code();
piCout << "msg" << c->lastError();
WAIT_FOR_EXIT })
->start();*/
server.stop();*/ auto * c = PIHTTPClient::create(
PIString("127.0.0.1:7777/%1").arg("sendMessag"),
return 0; Method::Post,
} MessageMutable().addHeader(Header::ContentType, "application/json").setBody(PIByteArray::fromAscii("{hello}")));
c->onFinish([](const PIHTTP::MessageConst & msg) { piCout << "message finish" << (int)msg.code() << PIString::fromUTF8(msg.body()); })
->onError([c](const PIHTTP::MessageConst & msg) { piCout << "message error" << c->lastError(); })
->onAbort([c](const PIHTTP::MessageConst & msg) { piCout << "aborted"; })
->start();
piMSleep(1000);
// CurlThreadPool::instance()->destroy();
// kbd.enableExitCapture();
// WAIT_FOR_EXIT
// kbd.stopAndWait();
// server.stop();
c->abort();
piMSleep(10);
return 0;
// piCout << PIString::readableSize(PISystemMonitor::usedRAM());
/*PIVector<int> vi;
piForTimes(10) {
piSleep(2.);
vi.enlarge(1000000);
piCout << "now" << vi.size() << vi.capacity();
}
piSleep(5.);*/
/*kbd.enableExitCapture();
PIHTTPServer server;
server.setFavicon(PIFile::readAll("logo.png", false));
// server.setOption(MicrohttpdServer::Option::HTTPSEnabled, true);
server.listen({"127.0.0.1", 7777});
// server.listen({"192.168.1.10", 7778});
server.registerPath("/", MicrohttpdServer::Method::Get, [](const MicrohttpdServer::Request & r) -> MicrohttpdServer::Reply {
MicrohttpdServer::Reply ret;
ret.setBody(PIByteArray::fromAscii(pageTitle));
return ret;
});
server.registerPath("/html", MicrohttpdServer::Method::Get, [](const MicrohttpdServer::Request & r) -> MicrohttpdServer::Reply {
MicrohttpdServer::Reply ret;
ret.setBody("<!DOCTYPE html><html><body><p>arg=%1</p></body></html>"_a.arg(r.args.value("a0")).toUTF8());
return ret;
});
server.registerPath("/api", MicrohttpdServer::Method::Put, [](const MicrohttpdServer::Request & r) -> MicrohttpdServer::Reply {
MicrohttpdServer::Reply ret;
ret.setBody(PIByteArray::fromAscii("<!DOCTYPE html><html><body>API</body></html>"));
return ret;
});
server.registerPath("/api/", MicrohttpdServer::Method::Post, [](const MicrohttpdServer::Request & r) -> MicrohttpdServer::Reply {
MicrohttpdServer::Reply ret;
ret.setBody("<!DOCTYPE html><html><body>API etry %1</body></html>"_a.arg(r.path).toUTF8());
ret.setCode(405);
return ret;
});
server.registerUnhandled([](const MicrohttpdServer::Request & r) -> MicrohttpdServer::Reply {
MicrohttpdServer::Reply ret;
ret.setBody("<!DOCTYPE html><html><body>Unknown</body></html>"_a.arg(r.path).toUTF8());
ret.setCode(404);
return ret;
});*/
/*server.setRequestCallback([](MicrohttpdServer::Request r) -> MicrohttpdServer::Reply {
MicrohttpdServer::Reply rep;
piCout << "request" << r.path;
piCout << " header" << r.headers;
piCout << " args" << r.args;
piCout << " body" << r.body;
piCout << "";
rep.setBody(PIByteArray::fromAscii("[{\"value1\": true, \"value2\": \"ыекштп\"}]"));
return rep;
});*/
/*piCout << "start" << server.isListen();
WAIT_FOR_EXIT
server.stop();*/
return 0;
}