You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
807 lines
22 KiB
807 lines
22 KiB
#include <iostream>
|
|
#include <cctype>
|
|
#include <pEp/pEpEngine.h>
|
|
#include <pEp/message_api.h>
|
|
#include <pEp/keymanagement.h>
|
|
#include <pEp/identity_list.h>
|
|
#include <utility>
|
|
#include <pEp/utils.hh>
|
|
#include <pEp/pEpLog.hh>
|
|
#include <pEp/inspect.hh>
|
|
#include <type_traits>
|
|
#include "../examples/libc99/libc99.h"
|
|
|
|
namespace pEp {
|
|
|
|
char* alloc_str(const std::string& str)
|
|
{
|
|
char* ret = strdup(str.c_str());
|
|
pEpLog(CXX::Inspect::all(ret));
|
|
return ret;
|
|
}
|
|
|
|
template<class T>
|
|
void free(T ptr_type)
|
|
{
|
|
pEpLog(CXX::Inspect::all(ptr_type));
|
|
::pEp_free(ptr_type);
|
|
}
|
|
|
|
template<>
|
|
void free(char* ptr_type)
|
|
{
|
|
pEpLog(CXX::Inspect::all(ptr_type));
|
|
::pEp_free(ptr_type);
|
|
}
|
|
|
|
template<>
|
|
void free(::pEp_identity* ptr_type)
|
|
{
|
|
pEpLog(CXX::Inspect::all(ptr_type));
|
|
::pEp_free(ptr_type);
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
#define EXSTR(msg) std::string(__FUNCTION__) + "() - " + msg
|
|
|
|
template<class T>
|
|
class POD {
|
|
static_assert(
|
|
std::is_pod<T>::value && !std::is_pointer<T>::value,
|
|
"only POD value types supported");
|
|
|
|
public:
|
|
POD()
|
|
{
|
|
pEpLogClass("called");
|
|
};
|
|
|
|
explicit POD(T* pod_p, const T& init_val)
|
|
{
|
|
bind(pod_p, init_val);
|
|
}
|
|
|
|
// Best to use this constructor, as the object is in a valid state when the wrapped
|
|
// c_str (char*) is known
|
|
explicit POD(T* pod_p)
|
|
{
|
|
bind(pod_p);
|
|
}
|
|
|
|
void bind(T* pod_p, const T& init_val)
|
|
{
|
|
bind(pod_p);
|
|
this->operator=(init_val);
|
|
}
|
|
|
|
void bind(T* pod_p)
|
|
{
|
|
if (pod_p == nullptr) {
|
|
throw Exception{ EXSTR("cant bind on a nullptr") };
|
|
}
|
|
|
|
if (_is_initialized) {
|
|
throw Exception{ EXSTR("can only bind once") };
|
|
}
|
|
// init
|
|
_pod_p = pod_p;
|
|
_is_initialized = true;
|
|
pEpLogClass(to_string());
|
|
}
|
|
|
|
// make a copy
|
|
POD& operator=(T value)
|
|
{
|
|
pEpLogClass("Before: " + to_string() + " - new val: '" + CXX::Inspect::val(value) + "'");
|
|
*_pod_p = value;
|
|
// pEpLogClass("After: " + to_string());
|
|
return *this;
|
|
}
|
|
|
|
// return a copy
|
|
operator T() const
|
|
{
|
|
return *_pod_p;
|
|
}
|
|
|
|
// return address of the wrappee
|
|
T* data()
|
|
{
|
|
return _pod_p;
|
|
}
|
|
|
|
// return address of the wrappee (const)
|
|
const T* c_data() const
|
|
{
|
|
return _pod_p;
|
|
}
|
|
|
|
std::string to_string() const
|
|
{
|
|
std::string ret{ "[" + CXX::Inspect::all(_pod_p) + "]" };
|
|
return ret;
|
|
}
|
|
|
|
static bool log_enabled;
|
|
|
|
private:
|
|
bool _is_initialized{ false };
|
|
T* _pod_p{ nullptr };
|
|
|
|
Adapter::pEpLog::pEpLogger logger{ "pEp::POD", log_enabled };
|
|
Adapter::pEpLog::pEpLogger& m4gic_logger_n4me = logger;
|
|
|
|
class Exception : public std::runtime_error {
|
|
public:
|
|
explicit Exception(const std::string& msg) : std::runtime_error(msg) {}
|
|
};
|
|
};
|
|
|
|
template<class T>
|
|
bool pEp::POD<T>::log_enabled{ true };
|
|
|
|
template<class T>
|
|
std::ostream& operator<<(std::ostream& o, pEp::POD<T> pEpPOD)
|
|
{
|
|
return o << (T)pEpPOD;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
// Manages a char* to appear like a std::string
|
|
// char* c_str
|
|
// c_str MUST point to either:
|
|
// * NULL - means there is no value/mem alloc yet
|
|
// * dyn allocated memory
|
|
// in case the mem is already allocated, there must be 2 modes
|
|
// * take ownership (and free it)
|
|
// * dont take ownership, only provide a C++ interface
|
|
// There must be the option to construct the object before the wrapped c_str (char*)
|
|
// is known. This leads to a pEp::String object in invalid state, and it must be initialized using
|
|
// bind(). Otherwise all(most) functions will throw.
|
|
// bind() can only be called once, will throw otherwise.
|
|
// NON-owning mode, just does not free the string when it dies, owning mode does.
|
|
// Thats the only difference.
|
|
class String {
|
|
public:
|
|
String()
|
|
{
|
|
pEpLogClass("called");
|
|
}
|
|
|
|
// Best to use this constructor, as the object is in a valid state when the wrapped
|
|
// c_str (char*) is known
|
|
String(bool is_owner, char** c_str_pp)
|
|
{
|
|
bind(is_owner, c_str_pp);
|
|
}
|
|
|
|
String(bool is_owner, char** c_str_pp, const std::string& init_val)
|
|
{
|
|
bind(is_owner, c_str_pp, init_val);
|
|
}
|
|
|
|
void bind(bool is_owner, char** c_str_pp, const std::string& init_val)
|
|
{
|
|
bind(is_owner, c_str_pp);
|
|
this->operator=(init_val);
|
|
}
|
|
|
|
// bind and set ownership
|
|
void bind(bool is_owner, char** c_str_pp)
|
|
{
|
|
if (c_str_pp == nullptr) {
|
|
throw Exception{ EXSTR("cant bind on a nullptr") };
|
|
}
|
|
|
|
if (_is_bound) {
|
|
throw Exception{ EXSTR("can only be bound once") };
|
|
}
|
|
|
|
// init
|
|
_c_str_pp = c_str_pp;
|
|
_is_bound = true;
|
|
pEpLogClass(to_string());
|
|
set_owner(is_owner);
|
|
|
|
//if the c_str_p is nullptr then init with ""
|
|
if (*_c_str_pp == nullptr) {
|
|
this->operator=("");
|
|
}
|
|
}
|
|
|
|
~String()
|
|
{
|
|
if (_is_owner) {
|
|
_free(*_c_str_pp);
|
|
}
|
|
}
|
|
|
|
// make a copy
|
|
String& operator=(const std::string& str)
|
|
{
|
|
pEpLogClass("Before: " + to_string() + " - new val: '" + pEp::Utils::clip(str, 30) + "'");
|
|
if (_c_str_pp == nullptr) {
|
|
throw Exception{ EXSTR("invalid state") };
|
|
}
|
|
|
|
// DEALLOCATION
|
|
_free(*_c_str_pp);
|
|
|
|
// ALLOCATION
|
|
*_c_str_pp = _copy(str);
|
|
pEpLogClass("After: " + to_string());
|
|
return *this;
|
|
}
|
|
|
|
// return a copy of whatever c_str currently is (maybe created by us, maybe changed meanwhile)
|
|
operator std::string() const
|
|
{
|
|
if (_c_str_pp == nullptr) {
|
|
throw Exception{ EXSTR("invalid state") };
|
|
}
|
|
|
|
if (*_c_str_pp != nullptr) {
|
|
return { *_c_str_pp };
|
|
}
|
|
return {};
|
|
}
|
|
|
|
char** data()
|
|
{
|
|
return _c_str_pp;
|
|
}
|
|
|
|
const char* c_data() const
|
|
{
|
|
if (_c_str_pp == nullptr) {
|
|
throw Exception{ EXSTR("invalid state") };
|
|
}
|
|
return *_c_str_pp;
|
|
}
|
|
|
|
bool operator==(const pEp::String& pstr) const
|
|
{
|
|
return *(pstr.c_data()) == (*c_data());
|
|
}
|
|
|
|
bool operator!=(const pEp::String& pstr) const
|
|
{
|
|
return !(*this == pstr);
|
|
}
|
|
|
|
std::string to_string() const
|
|
{
|
|
|
|
if (_c_str_pp == nullptr) {
|
|
throw Exception{ EXSTR("invalid state") };
|
|
}
|
|
|
|
std::string ret{ "[" + CXX::Inspect::all(_c_str_pp) + " / " +
|
|
CXX::Inspect::all(*_c_str_pp) + "]" };
|
|
return ret;
|
|
}
|
|
|
|
void set_owner(bool is_owner)
|
|
{
|
|
pEpLogClass(std::to_string(is_owner));
|
|
_is_owner = is_owner;
|
|
}
|
|
|
|
bool is_owner() const
|
|
{
|
|
return _is_owner;
|
|
}
|
|
|
|
static bool log_enabled;
|
|
|
|
private:
|
|
static char* _copy(const std::string& str)
|
|
{
|
|
char* ret = strdup(str.c_str());
|
|
pEpLog(CXX::Inspect::all(ret));
|
|
return ret;
|
|
}
|
|
|
|
static void _free(char* ptr_type)
|
|
{
|
|
pEpLog(CXX::Inspect::all(ptr_type));
|
|
::pEp_free(ptr_type);
|
|
}
|
|
|
|
bool _is_bound{ false };
|
|
bool _is_owner{ false };
|
|
char** _c_str_pp{ nullptr };
|
|
|
|
Adapter::pEpLog::pEpLogger logger{ "pEp::String", log_enabled };
|
|
Adapter::pEpLog::pEpLogger& m4gic_logger_n4me = logger;
|
|
|
|
class Exception : public std::runtime_error {
|
|
public:
|
|
explicit Exception(const std::string& msg) : std::runtime_error(msg) {}
|
|
};
|
|
};
|
|
|
|
bool pEp::String::log_enabled{ true };
|
|
|
|
std::ostream& operator<<(std::ostream& o, const pEp::String& pEpStr)
|
|
{
|
|
return o << std::string(pEpStr);
|
|
}
|
|
|
|
} // namespace pEp
|
|
|
|
void test_getters(int* c_int_p, pEp::POD<int>& pint, int expected)
|
|
{
|
|
pEpLog("to_string(): " + pint.to_string());
|
|
// compare addresses
|
|
pEpLog("addresses == c_int_p");
|
|
assert(pint.c_data() == c_int_p);
|
|
assert(pint.data() == c_int_p);
|
|
|
|
// compare values
|
|
if (c_int_p != nullptr) {
|
|
pEpLog("operator int(): " + std::to_string(pint));
|
|
assert(pint == *c_int_p);
|
|
assert(pint == expected);
|
|
|
|
// will segfault with nullptr, and this is correct
|
|
pEpLog("data(): " + std::to_string(*pint.data()));
|
|
assert(*pint.data() == *c_int_p);
|
|
assert(*pint.data() == expected);
|
|
|
|
pEpLog("c_data(): " + std::to_string(*pint.c_data()));
|
|
assert(*pint.c_data() == *c_int_p);
|
|
assert(*pint.c_data() == expected);
|
|
}
|
|
}
|
|
|
|
void test_assign(int* c_int_p, pEp::POD<int>& pint)
|
|
{
|
|
{
|
|
pEpLogH2("assign operator");
|
|
int new_val = 23;
|
|
pint = new_val;
|
|
test_getters(c_int_p, pint, new_val);
|
|
}
|
|
{
|
|
pEpLogH2("raw c_str assign");
|
|
int new_val = 23;
|
|
*c_int_p = new_val;
|
|
test_getters(c_int_p, pint, new_val);
|
|
}
|
|
}
|
|
|
|
|
|
void test_getters(char** c_str_p, pEp::String& pstr, const std::string& expected)
|
|
{
|
|
pEpLog("to_string(): " + pstr.to_string());
|
|
// compare addresses
|
|
pEpLog("addresses == c_str_p");
|
|
assert(pstr.c_data() == *c_str_p);
|
|
assert(pstr.data() == c_str_p);
|
|
|
|
// compare values
|
|
if (*c_str_p != nullptr) {
|
|
pEpLog("operator std::string(): " + std::string(pstr));
|
|
assert(std::string(pstr) == std::string(*c_str_p));
|
|
assert(std::string(pstr) == expected);
|
|
|
|
// will segfault with nullptr, and this is correct
|
|
pEpLog("data(): " + std::string(*pstr.data()));
|
|
assert(std::string(*pstr.data()) == std::string(*c_str_p));
|
|
assert(std::string(*pstr.data()) == expected);
|
|
|
|
pEpLog("c_data(): " + std::string(pstr.c_data()));
|
|
assert(std::string(pstr.c_data()) == std::string(*c_str_p));
|
|
assert(std::string(pstr.c_data()) == expected);
|
|
} else {
|
|
std::string tmp{ pstr };
|
|
pEpLog("operator std::string(): " + tmp);
|
|
assert(tmp.empty());
|
|
}
|
|
}
|
|
|
|
void test_assign(char** c_str_p, pEp::String& pstr)
|
|
{
|
|
{
|
|
pEpLogH2("assign operator");
|
|
std::string new_val{ "assign operator" };
|
|
pstr = new_val;
|
|
test_getters(c_str_p, pstr, new_val);
|
|
}
|
|
{
|
|
pEpLogH2("raw c_str assign");
|
|
std::string new_val{ "raw c_str assign" };
|
|
free(*c_str_p);
|
|
*c_str_p = strdup(new_val.c_str());
|
|
test_getters(c_str_p, pstr, new_val);
|
|
}
|
|
}
|
|
|
|
|
|
namespace pEp {
|
|
// TOOD:
|
|
// ctor not exception safe
|
|
// You can create an instance of a c-struct or you can wrap an already existing c-struct
|
|
// In both cases, you can define if the wrapper owns the instance, or not.
|
|
// If if owns it, it will free() it when the wrapper dies, otherwise it doesnt.
|
|
template<typename T>
|
|
class PODStruct {
|
|
public:
|
|
PODStruct() = delete;
|
|
|
|
// Creates a new instance or binds an existing one
|
|
PODStruct(bool is_owner, T** c_struct_pp = nullptr)
|
|
{
|
|
pEpLogClass("called");
|
|
_init(is_owner, c_struct_pp);
|
|
}
|
|
|
|
// Creates a new instance or binds an existing one
|
|
// but takes custom alloc/free functions
|
|
PODStruct(
|
|
bool is_owner,
|
|
std::function<T*()> alloc,
|
|
std::function<void(T*)> free,
|
|
T** c_struct_pp = nullptr) :
|
|
_effective_alloc(std::move(alloc)),
|
|
_effective_free(std::move(free))
|
|
{
|
|
_init(is_owner, c_struct_pp);
|
|
}
|
|
|
|
void bind(bool is_owner, T** c_struct_pp)
|
|
{
|
|
if (c_struct_pp == nullptr) {
|
|
throw Exception{ EXSTR("cant bind on a nullptr") };
|
|
}
|
|
|
|
if (_is_bound) {
|
|
throw Exception{ EXSTR("can only bind once") };
|
|
}
|
|
|
|
// init
|
|
_c_struct_pp = c_struct_pp;
|
|
_c_struct_p = *_c_struct_pp;
|
|
_is_bound = true;
|
|
pEpLogClass(to_string());
|
|
set_owner(is_owner);
|
|
}
|
|
|
|
~PODStruct()
|
|
{
|
|
if (_is_owner) {
|
|
_effective_free(_c_struct_p);
|
|
}
|
|
}
|
|
|
|
T** data()
|
|
{
|
|
return _c_struct_pp;
|
|
}
|
|
|
|
const T* c_data() const
|
|
{
|
|
if (_c_struct_pp == nullptr) {
|
|
throw Exception{ EXSTR("invalid state") };
|
|
}
|
|
return *_c_struct_pp;
|
|
}
|
|
|
|
operator T*()
|
|
{
|
|
return _c_struct_p;
|
|
}
|
|
|
|
std::string to_string() const
|
|
{
|
|
std::string ret{ "[" + CXX::Inspect::all(_c_struct_p) + "]" };
|
|
return ret;
|
|
}
|
|
|
|
void set_owner(bool is_owner)
|
|
{
|
|
pEpLogClass(std::to_string(is_owner));
|
|
_is_owner = is_owner;
|
|
}
|
|
|
|
bool is_owner() const
|
|
{
|
|
return _is_owner;
|
|
}
|
|
|
|
static bool log_enabled;
|
|
|
|
private:
|
|
const std::function<T*()> _effective_alloc{ _alloc };
|
|
const std::function<void(T*)> _effective_free{ _free };
|
|
|
|
bool _is_bound{ false };
|
|
bool _is_owner{ false };
|
|
T** _c_struct_pp{ nullptr };
|
|
T* _c_struct_p{ nullptr };
|
|
|
|
Adapter::pEpLog::pEpLogger logger{ "typeid(T).name()", log_enabled };
|
|
Adapter::pEpLog::pEpLogger& m4gic_logger_n4me = logger;
|
|
|
|
class Exception : public std::runtime_error {
|
|
public:
|
|
explicit Exception(const std::string& msg) : std::runtime_error(msg) {}
|
|
};
|
|
|
|
void _init(bool is_owner, T** c_struct_pp)
|
|
{
|
|
// if no pp is given, alloc new,
|
|
// otherwise bind to it
|
|
if (!c_struct_pp) {
|
|
_c_struct_p = _effective_alloc();
|
|
bind(is_owner, &_c_struct_p);
|
|
} else {
|
|
bind(is_owner, c_struct_pp);
|
|
}
|
|
}
|
|
|
|
// default alloc/free
|
|
static T* _alloc()
|
|
{
|
|
T* ret = (T*)calloc(1, sizeof(T));
|
|
pEpLog(CXX::Inspect::all(ret));
|
|
return ret;
|
|
}
|
|
|
|
static void _free(T* ptr)
|
|
{
|
|
pEpLog(CXX::Inspect::all(ptr));
|
|
free(ptr);
|
|
}
|
|
};
|
|
|
|
// TOOD:
|
|
// ctor not exception safe
|
|
// You can create an instance of a c-struct or you can wrap an already existing c-struct
|
|
// In both cases, you can define if the wrapper owns the instance, or not.
|
|
// If if owns it, it will free() it when the wrapper dies, otherwise it doesnt.
|
|
//
|
|
// alloc/free:
|
|
// the alloc() and free() functions HAVE to use calloc/malloc NOT 'new', because we are interfacing
|
|
// c99 code that could possibly get ownership of the struct and can only free memory that has
|
|
// been allocated using malloc/calloc. (malloc/free - new/delete are NOT compatible)
|
|
class TestStruct1 : public PODStruct<::Test_struct1> {
|
|
public:
|
|
TestStruct1(bool is_owner, ::Test_struct1** test_struct1_p = nullptr) :
|
|
PODStruct<::Test_struct1>(is_owner, test_struct1_p)
|
|
{
|
|
}
|
|
|
|
// fields of the struct as 'properties' ;)
|
|
pEp::POD<int> c_int{ &(*data())->c_int };
|
|
pEp::POD<::Test_enum> c_enum{ &(*data())->c_enum };
|
|
pEp::String c_str{ true, &(*data())->c_str };
|
|
};
|
|
|
|
template<>
|
|
bool PODStruct<::Test_struct1>::log_enabled{ true };
|
|
} // namespace pEp
|
|
|
|
|
|
int main()
|
|
{
|
|
// c-types are always POD
|
|
// we need to handle pointer types and value types differently
|
|
// pointer types need to be memory-managed (heap)
|
|
// value types are being copied around (stack)
|
|
static_assert(std::is_pod<int>::value && !std::is_pointer<int>::value, "not an integral");
|
|
static_assert(
|
|
std::is_pod<::Test_enum>::value && !std::is_pointer<::Test_enum>::value,
|
|
"not an integral");
|
|
static_assert(
|
|
std::is_pod<::Test_struct1>::value && !std::is_pointer<::Test_struct1>::value,
|
|
"not an integral");
|
|
|
|
// pEp::Utils::readKey();
|
|
pEp::Adapter::pEpLog::set_enabled(true);
|
|
|
|
// POD
|
|
if (0) {
|
|
// VALID USAGE
|
|
int init_val = 0;
|
|
// new pEp::POD on int
|
|
{
|
|
pEpLogH1("new pEp::POD on int");
|
|
int c_int = init_val;
|
|
pEp::POD<int> pint(&c_int);
|
|
test_getters(&c_int, pint, init_val);
|
|
test_assign(&c_int, pint);
|
|
}
|
|
// equality operator
|
|
{
|
|
pEpLogH1("equality operator");
|
|
int c_int1 = init_val;
|
|
int c_int2 = init_val;
|
|
pEp::POD<int> pint1(&c_int1);
|
|
pEp::POD<int> pint2(&c_int2);
|
|
assert(pint1 == pint2);
|
|
|
|
c_int2 = 23;
|
|
assert(pint1 != pint2);
|
|
}
|
|
}
|
|
|
|
// String
|
|
// pEp::String::log_enabled = false;
|
|
if (0) {
|
|
//TODO: Test non-owning mode
|
|
|
|
// INVALID USAGE
|
|
// char* c_str_u; // uninitialized == INVALID
|
|
// undefined behaviour, most likely "pointer being freed was not allocated"
|
|
// {
|
|
// char* c_str;
|
|
// pEp::String pstr(c_str);
|
|
// }
|
|
// char* c_str_s = "fdsfs"; // statically initialized == INVALID
|
|
// {
|
|
// char ca[4] = { 'p', 'E', 'p'};
|
|
// char* c_str = ca;
|
|
// pEp::String pstr(c_str);
|
|
// }
|
|
|
|
// VALID USAGE
|
|
// new pEp::String on char* pointing to NULL
|
|
{
|
|
pEpLogH1("new pEp::String on char* pointing to NULL");
|
|
char* c_str = NULL; // nullptr
|
|
|
|
pEp::String pstr(true, &c_str);
|
|
test_getters(&c_str, pstr, "");
|
|
test_assign(&c_str, pstr);
|
|
}
|
|
|
|
std::string init_val{ "initialized c string" };
|
|
// new pEp::String on already initalized char*
|
|
{
|
|
pEpLogH1("new pEp::String on already initalized char*");
|
|
char* c_str = strdup(init_val.c_str());
|
|
|
|
pEp::String pstr(true, &c_str);
|
|
test_getters(&c_str, pstr, init_val);
|
|
test_assign(&c_str, pstr);
|
|
}
|
|
|
|
// bind()
|
|
{
|
|
pEpLogH1("bind()");
|
|
pEp::String pstr{};
|
|
|
|
char* c_str = strdup(init_val.c_str());
|
|
//TODO: PITYASSERT_THROWS
|
|
pstr.bind(true, &c_str);
|
|
test_getters(&c_str, pstr, init_val);
|
|
test_assign(&c_str, pstr);
|
|
}
|
|
|
|
// equality operator
|
|
{
|
|
pEpLogH1("equality operator");
|
|
pEp::String pstr1{};
|
|
|
|
char* c_str1 = strdup(init_val.c_str());
|
|
char* c_str2 = strdup(init_val.c_str());
|
|
pstr1.bind(true, &c_str1);
|
|
pEp::String pstr2{ true, &c_str2 };
|
|
assert(pstr1 == pstr2);
|
|
pstr2 = "huhu";
|
|
assert(pstr1 != pstr2);
|
|
}
|
|
}
|
|
|
|
// Struct
|
|
if (1) {
|
|
// create an instance
|
|
if (1) {
|
|
pEp::TestStruct1 pstruct1{ true };
|
|
// pEp::TestStruct1 pstruct1(true, 23, TWO, "pEp");
|
|
pEpLog(pstruct1.c_int);
|
|
pEpLog(pstruct1.c_enum);
|
|
pEpLog(pstruct1.c_str);
|
|
|
|
::Test_struct1* c_struct1 = pstruct1;
|
|
pEpLog(c_struct1->c_int);
|
|
pEpLog(c_struct1->c_enum);
|
|
pEpLog(c_struct1->c_str);
|
|
pEpLog("DONE");
|
|
}
|
|
|
|
// wrap already existing instance
|
|
{
|
|
::Test_struct1* c_struct1 = ::new_test_struct(0, ONE, "pEp");
|
|
pEpLog(c_struct1->c_int);
|
|
pEpLog(c_struct1->c_enum);
|
|
pEpLog(c_struct1->c_str);
|
|
pEpLog("DONE");
|
|
|
|
pEp::TestStruct1 pstruct1(true, &c_struct1);
|
|
pEpLog(pstruct1.c_int);
|
|
pEpLog(pstruct1.c_enum);
|
|
pEpLog(pstruct1.c_str);
|
|
pEpLog("DONE");
|
|
}
|
|
}
|
|
|
|
// if (0) {
|
|
// ::PEP_SESSION session;
|
|
// setenv("HOME", ".", 1);
|
|
// ::init(&session, nullptr, nullptr, nullptr);
|
|
//
|
|
// // create identity
|
|
// pEp::Identity id1{ "wrong@entry.lol", "wrong", "23", "INVA_FPR" };
|
|
//
|
|
// pEpLog(id1);
|
|
// id1.username = "alice";
|
|
// id1.address = "alice@peptest.org";
|
|
//
|
|
// pEpLog(id1.address);
|
|
// pEpLog(id1.username);
|
|
// ::myself(session, id1);
|
|
// pEpLog(id1);
|
|
//
|
|
// pEp::Identity id2{ "bob" };
|
|
// ::update_identity(session, id2);
|
|
// pEpLog(id2);
|
|
// }
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
//
|
|
//// TOOD:
|
|
//// ctor not exception safe
|
|
//class Identity {
|
|
//public:
|
|
// Identity(
|
|
// const std::string& address = "",
|
|
// const std::string& username = "",
|
|
// const std::string& user_id = "",
|
|
// const std::string& fpr = "")
|
|
// {
|
|
// pEpLogClass("called");
|
|
// _wrappee = ::new_identity(nullptr, nullptr, nullptr, nullptr);
|
|
//
|
|
// // set the pEp::String wrapper underlying c_str
|
|
// this->address.bind(true, &_wrappee->address, address);
|
|
// this->username.bind(true, &_wrappee->username, username);
|
|
// this->user_id.bind(true, &_wrappee->user_id, user_id);
|
|
// this->fpr.bind(true, &_wrappee->fpr, fpr);
|
|
// }
|
|
//
|
|
// ~Identity()
|
|
// {
|
|
// _free();
|
|
// }
|
|
//
|
|
//
|
|
// pEp::String address{};
|
|
// pEp::String username{};
|
|
// pEp::String user_id{};
|
|
// pEp::String fpr{};
|
|
//
|
|
// operator ::pEp_identity*()
|
|
// {
|
|
// return _wrappee;
|
|
// }
|
|
//
|
|
// static bool log_enabled;
|
|
//
|
|
//private:
|
|
// void _free()
|
|
// {
|
|
// // pEp::free(_wrappee);
|
|
// }
|
|
//
|
|
// ::pEp_identity* _wrappee{ nullptr };
|
|
// Adapter::pEpLog::pEpLogger logger{ "IdentWrappySP", log_enabled };
|
|
// Adapter::pEpLog::pEpLogger& m4gic_logger_n4me = logger;
|
|
//};
|
|
//
|
|
//bool Identity::log_enabled{ true };
|
|
//
|
|
|