JSON-190: default-initialize "Out" variables explicitly.

server/ev_server.cc

@@ -17,6 +17,7 @@
 #include <pEp/openpgp_compat.h>
 #include <pEp/message_api.h> // for get_binary_path()
 #include <pEp/mime.h>
+#include <pEp/group.h>
 
 // libpEpAdapter:
 #include <pEp/Adapter.hh>
@@ -204,6 +205,15 @@ const FunctionMap functions = {
 		FP( "enable_identity_for_sync" , new FuncPC<PEP_STATUS, In_Pep_Session, InOut<pEp_identity*>> (&enable_identity_for_sync)),
 		FP( "disable_identity_for_sync", new FuncPC<PEP_STATUS, In_Pep_Session, InOut<pEp_identity*>> (&disable_identity_for_sync)),
 		FP( "disable_all_sync_channels", new Func<PEP_STATUS, In_Pep_Session> (&disable_all_sync_channels)),
+		
+		FP( "Group Encryption", new Separator ),
+		FP( "group_create"    , new FuncPC<PEP_STATUS, In_Pep_Session, In<pEp_identity*>, In<pEp_identity*>, In<identity_list*>, Out<pEp_group*>> (&group_create) ),
+		FP( "group_join"      , new FuncPC<PEP_STATUS, In_Pep_Session, In<pEp_identity*>, In<pEp_identity*>> (&group_join) ),
+		FP( "group_dissolve"  , new FuncPC<PEP_STATUS, In_Pep_Session, In<pEp_identity*>, In<pEp_identity*>> (&group_dissolve) ),
+		FP( "group_invite_member", new FuncPC<PEP_STATUS, In_Pep_Session, In<pEp_identity*>, In<pEp_identity*>> (&group_invite_member) ),
+		FP( "group_remove_member", new FuncPC<PEP_STATUS, In_Pep_Session, In<pEp_identity*>, In<pEp_identity*>> (&group_remove_member) ),
+		FP( "group_rating", new FuncPC<PEP_STATUS, In_Pep_Session, In<pEp_identity*>, In<pEp_identity*>, Out<PEP_rating>> (&group_rating) ),
+		
 
 #ifndef JSON_ADAPTER_LIBRARY
 		FP( "startSync", new Func<void> (&pEp::mini::startSync) ),

server/inout.hh

@@ -151,7 +151,9 @@ struct Out
 	typedef T* c_type; // the according type in C function parameter
 	enum { is_output = true, need_input = !(PF & ParamFlag::NoInput) }; // if need_input=false it would no longer consume an element in the input parameter array.
 	
-	Out() = default;
+	Out()
+	: value{}
+	{}
 	
 	// JSON-160: (t) is necessary on GCC and MSVC. {t} does not work here. Whyever...
 	explicit Out(const T& t) : value(t)

server/pEp-types.cc

@@ -4,6 +4,7 @@
 #include "json-adapter.hh"
 
 #include <pEp/pEp_string.h>
+#include <pEp/group.h>
 #include <pEp/status_to_string.hh>  // from libpEpAdapter
 
 #include <iostream> // Just to print debug stuff to std::cerr
@@ -88,6 +89,14 @@ In<const pEp_identity*>::~In()
 	free_identity(const_cast<pEp_identity*>(value));
 }
 
+template<>
+In<identity_list*>::~In()
+{
+	free_identity_list(value);
+	value=nullptr;
+}
+
+
 template<>
 Out<pEp_identity*>::~Out()
 {
@@ -108,6 +117,13 @@ In<const identity_list*>::~In()
 	free_identity_list(const_cast<identity_list*>(value));
 }
 
+template<>
+Out<pEp_group*>::~Out()
+{
+	free_group(value);
+	value=nullptr;
+}
+
 
 template<>
 In<PEP_enc_format>::~In()
@@ -752,6 +768,119 @@ js::Value to_json<PEP_CIPHER_SUITE>(const PEP_CIPHER_SUITE& v)
 }
 
 
+template<>
+pEp_member* from_json<pEp_member*>(const js::Value& v)
+{
+	if(v.is_null())
+		return nullptr;
+	
+	const js::Object& o = v.get_obj();
+	const bool   joined = from_json_object<bool, js::bool_type>(o, "joined");
+	pEp_identity* ident = from_json_object<pEp_identity*, js::obj_type>(o, "ident");
+	pEp_member*  member = new_member(ident);
+	member->joined = joined;
+	return member;
+}
+
+template<>
+js::Value to_json<pEp_member*>(pEp_member* const& member)
+{
+	if(member == nullptr)
+		return js::Value();
+	
+	js::Object o;
+	to_json_object(o, "ident" , member->ident);
+	to_json_object(o, "joined", member->joined);
+	return o;
+}
+
+template<>
+member_list* from_json<member_list*>(const js::Value& v)
+{
+	if(v.is_null())
+		return nullptr;
+	
+	const js::Array& a = v.get_array();
+	if(a.empty())
+		return nullptr;
+	
+	auto element = a.begin();
+	member_list* ml = new_memberlist( from_json<pEp_member*>(*element) );
+	
+	++element;
+	member_list* last_member = ml; // to make memberlist_add() below more efficient
+	
+	for(; element!=a.end(); ++element)
+	{
+		last_member = memberlist_add(last_member, from_json<pEp_member*>(*element) );
+	}
+	
+	return ml;
+}
+
+template<>
+js::Value to_json<const member_list*>(const member_list* const& oml)
+{
+	const member_list* ml = oml;
+	js::Array a;
+	
+	while(ml)
+	{
+		if(ml->member)
+		{
+			a.push_back( to_json<pEp_member*>(ml->member) );
+		}
+		ml = ml->next;
+	}
+	
+	return js::Value( std::move(a) );
+}
+
+template<>
+js::Value to_json<member_list*>(member_list* const& oml)
+{
+	return to_json( const_cast<const member_list*>(oml) );
+}
+
+
+template<>
+pEp_group* from_json<pEp_group*>(const js::Value& v)
+{
+	if(v.is_null())
+		return nullptr;
+	
+	const js::Object& o = v.get_obj();
+	auto group_identity = pEp::utility::make_c_ptr(from_json_object<pEp_identity*, js::obj_type>(o, "group_identity"), &free_identity);
+	auto manager        = pEp::utility::make_c_ptr(from_json_object<pEp_identity*, js::obj_type>(o, "manager"), &free_identity);
+	auto members        = pEp::utility::make_c_ptr(from_json_object<member_list*, js::array_type>(o, "members"), &free_memberlist);
+	
+	pEp_group* g = new_group( group_identity.get(), manager.get(), members.get());
+	if(g) // a valid pEp_group g owns the members, so release them before return:
+	{
+		group_identity.release();
+		manager.release();
+		members.release();
+		return g;
+	}
+	
+	// no valid group, cleanup is done automatically on return. :-)
+	return nullptr;
+}
+
+template<>
+js::Value to_json<pEp_group*>(pEp_group* const& group)
+{
+	if(group == nullptr)
+		return js::Value();
+	
+	js::Object o;
+	to_json_object(o, "group_identity", group->group_identity);
+	to_json_object(o, "manager"       , group->manager);
+	to_json_object(o, "members"       , group->members);
+	return o;
+}
+
+
 template<>
 js::Value Type2String<PEP_SESSION>::get()  { return "Session"; }
 
@@ -797,6 +926,10 @@ js::Value Type2String<PEP_CIPHER_SUITE>::get()  { return "PEP_CIPHER_SUITE"; }
 template<>
 js::Value Type2String<PEP_STATUS>::get()  { return "PEP_STATUS"; }
 
+template<>
+js::Value Type2String<pEp_group*>::get() { return "Group"; }
+
+
 template<>
 js::Value Type2String<Language>::get()  { return "Language"; }