* LinkedHashSet.list_iterator() is now disallowed (causes an assertion failure)
* LinkedHashSet.iterator() now returns a BidirIterator instead of just an
Iterator
+* ImDetails.im_addresses is now of type MultiMap<string, string>
Overview of changes from libfolks 0.4.0 to libfolks 0.5.0
=========================================================
{
unowned Value? val = details.lookup (Folks.PersonaStore.detail_key (
PersonaDetail.IM_ADDRESSES));
- unowned HashTable<string, LinkedHashSet<string>> im_addresses
+ MultiMap<string, string> im_addresses
= val != null
- ? (HashTable<string, LinkedHashSet<string>>) val.get_boxed ()
+ ? (MultiMap<string, string>) val.get_object ()
: null;
unowned Value? val2 = details.lookup
(this.detail_key (PersonaDetail.WEB_SERVICE_ADDRESSES));
? (HashMap<string, LinkedHashSet<string>>) val2.get_object ()
: null;
uint im_addresses_size = (im_addresses == null)
- ? 0 : im_addresses.size ();
+ ? 0 : im_addresses.size;
uint web_service_addresses_size = (web_service_addresses == null)
? 0 : web_service_addresses.size;
WebServiceDetails
{
private unowned GLib.KeyFile _key_file;
- /* FIXME: As described in the ImDetails interface, we have to use
- * GenericArray<string> here rather than just string[], as null-terminated
- * arrays aren't supported as generic types. */
- private HashTable<string, LinkedHashSet<string>> _im_addresses;
+ private HashMultiMap<string, string> _im_addresses;
private HashMap<string, LinkedHashSet<string>> _web_service_addresses;
private string _alias;
private const string[] _linkable_properties =
/**
* {@inheritDoc}
*/
- public HashTable<string, LinkedHashSet<string>> im_addresses
+ public MultiMap<string, string> im_addresses
{
get
{ return this._im_addresses; }
set
{
/* Remove the current IM addresses from the key file */
- this._im_addresses.foreach ((protocol, v) =>
+ foreach (var protocol in this._im_addresses.get_keys ())
{
try
{
/* Ignore the error, since it's just a group or key not found
* error. */
}
- });
+ }
/* Add the new IM addresses to the key file and build a normalised
* table of them to set as the new property value */
- HashTable<string, LinkedHashSet<string>> im_addresses =
- new HashTable<string, LinkedHashSet<string>> (str_hash, str_equal);
+ var im_addresses = new HashMultiMap<string, string> ();
- value.foreach ((k, v) =>
+ foreach (var protocol in value.get_keys ())
{
- unowned string protocol = (string) k;
- unowned LinkedHashSet<string?> addresses =
- (LinkedHashSet<string?>) v;
- LinkedHashSet<string> normalized_addresses =
- new LinkedHashSet<string> ();
+ var addresses = value.get (protocol);
+ var normalised_addresses = new HashSet<string> ();
foreach (string address in addresses)
{
- string normalized_address;
+ string normalised_address;
try
{
- normalized_address = ImDetails.normalise_im_address (
+ normalised_address = ImDetails.normalise_im_address (
address, protocol);
}
catch (ImDetailsError e)
continue;
}
- normalized_addresses.add (normalized_address);
+ normalised_addresses.add (normalised_address);
+ im_addresses.set (protocol, normalised_address);
}
- string[] addrs = (string[]) normalized_addresses.to_array ();
- addrs.length = normalized_addresses.size;
+ string[] addrs = (string[]) normalised_addresses.to_array ();
+ addrs.length = normalised_addresses.size;
this._key_file.set_string_list (this.display_id, protocol, addrs);
- im_addresses.insert (protocol, normalized_addresses);
- });
+ }
this._im_addresses = im_addresses;
id);
this._key_file = key_file;
- this._im_addresses = new HashTable<string, LinkedHashSet<string>> (
- str_hash, str_equal);
+ this._im_addresses = new HashMultiMap<string, string> ();
this._web_service_addresses
= new HashMap<string, LinkedHashSet<string>> (str_hash,
str_equal);
var im_addresses = this._key_file.get_string_list (
this.display_id, protocol);
- var address_set = new LinkedHashSet<string> ();
-
foreach (var im_address in im_addresses)
{
string address;
warning (e.message);
continue;
}
- address_set.add (address);
- }
- this._im_addresses.insert (protocol, address_set);
+ this._im_addresses.set (protocol, address);
+ }
}
}
catch (KeyFileError e)
{
if (prop_name == "im-addresses")
{
- this.im_addresses.foreach ((k, v) =>
+ foreach (var protocol in this._im_addresses.get_keys ())
{
- unowned string protocol = (string) k;
- unowned LinkedHashSet<string> im_addresses =
- (LinkedHashSet<string>) v;
+ var im_addresses = this._im_addresses.get (protocol);
foreach (string address in im_addresses)
callback (protocol + ":" + address);
- });
+ }
}
else if (prop_name == "web-service-addresses")
{
}
}
- private HashTable<string, LinkedHashSet<string>> _im_addresses =
- new HashTable<string, LinkedHashSet<string>> (str_hash, str_equal);
+ private HashMultiMap<string, string> _im_addresses =
+ new HashMultiMap<string, string> ();
private HashMap<string, LinkedHashSet<string>> _web_service_addresses =
new HashMap<string, LinkedHashSet<string>> (str_hash, str_equal);
/**
* {@inheritDoc}
*/
- public HashTable<string, LinkedHashSet<string>> im_addresses
+ public MultiMap<string, string> im_addresses
{
get { return this._im_addresses; }
private set {}
var facebook_jid = this._build_facebook_jid (store.id, id);
if (facebook_jid != null)
{
- var im_address_array = new LinkedHashSet<string> ();
try
{
var facebook_jid_copy = facebook_jid.dup();
var normalised_addr = (owned) normalise_im_address
((owned) facebook_jid_copy, "jabber");
string im_proto = "jabber";
- var proto_copy = im_proto.dup ();
- im_address_array.add ((owned) normalised_addr);
- this._im_addresses.insert ((owned) proto_copy,
- (owned) im_address_array);
+ this._im_addresses.set (im_proto, normalised_addr);
}
catch (ImDetailsError e)
{
private HashTable<string, bool> _groups;
private bool _is_favourite;
private string _alias;
- private HashTable<string, LinkedHashSet<string>> _im_addresses;
+ private HashMultiMap<string, string> _im_addresses;
private const string[] _linkable_properties = { "im-addresses" };
/* Whether we've finished being constructed; this is used to prevent
}
/**
- * A mapping of IM protocol to an ordered set of IM addresses.
+ * A mapping of IM protocol to an (unordered) set of IM addresses.
*
* See {@link Folks.ImDetails.im_addresses}.
*/
- public HashTable<string, LinkedHashSet<string>> im_addresses
+ public MultiMap<string, string> im_addresses
{
get { return this._im_addresses; }
private set {}
this._is_constructed = true;
/* Set our single IM address */
- LinkedHashSet<string> im_address_set = new LinkedHashSet<string> ();
+ this._im_addresses = new HashMultiMap<string, string> ();
+
try
{
- im_address_set.add (ImDetails.normalise_im_address (id,
- account.get_protocol ()));
+ this._im_addresses.set (account.get_protocol (),
+ ImDetails.normalise_im_address (id, account.get_protocol ()));
}
catch (ImDetailsError e)
{
warning (e.message);
}
- this._im_addresses =
- new HashTable<string, LinkedHashSet<string>> (str_hash, str_equal);
- this._im_addresses.insert (account.get_protocol (), im_address_set);
-
/* Groups */
this._groups = new HashTable<string, bool> (str_hash, str_equal);
else if (k == Folks.PersonaStore.detail_key (
PersonaDetail.IM_ADDRESSES))
{
- var im_addresses =
- (HashTable<string, LinkedHashSet<string>>) v.get_boxed ();
+ var im_addresses = (MultiMap<string, string>) v.get_object ();
int im_cnt = 0;
foreach (var proto in im_addresses.get_keys ())
{
- var addrs_a = im_addresses.lookup (proto);
+ var addrs_a = im_addresses.get (proto);
foreach (var addr in addrs_a)
{
}
internal async void _set_im_addresses (Folks.Persona persona,
- owned HashTable<string, LinkedHashSet<string>> im_addresses)
+ MultiMap<string, string> im_addresses)
{
/* FIXME:
* - this conversion should go away once we've switched to use the
* same data structure for each property that is a list of something.
* See: https://bugzilla.gnome.org/show_bug.cgi?id=646079 */
- GLib.List <FieldDetails> ims = new GLib.List <FieldDetails> ();
+ var ims = new HashSet<FieldDetails> ();
foreach (var proto in im_addresses.get_keys ())
{
- var addrs = im_addresses.lookup (proto);
+ var addrs = im_addresses.get (proto);
foreach (var a in addrs)
{
var fd = new FieldDetails (a);
fd.set_parameter ("proto", proto);
- ims.prepend ((owned) fd);
+ ims.add (fd);
}
}
- yield this._set_attrib (persona, (owned) ims,
- Trf.Attrib.IM_ADDRESSES);
+ yield this._set_attrib_set (persona, ims, Trf.Attrib.IM_ADDRESSES);
}
internal async void _set_postal_addresses (Folks.Persona persona,
related_connection = Trf.OntologyDefs.NCO_URL;
break;
case Trf.Attrib.IM_ADDRESSES:
- related_attrib = Trf.OntologyDefs.NCO_IMADDRESS;
- related_prop = Trf.OntologyDefs.NCO_IMID;
- related_prop_2 = Trf.OntologyDefs.NCO_IMPROTOCOL;
- related_connection = Trf.OntologyDefs.NCO_HAS_IMADDRESS;
- yield this._remove_attributes_from_persona (persona,
- _REMOVE_IM_ADDRS);
- break;
+ assert_not_reached ();
case Trf.Attrib.POSTAL_ADDRESSES:
related_attrib = Trf.OntologyDefs.NCO_POSTAL_ADDRESS;
related_connection = Trf.OntologyDefs.NCO_HAS_POSTAL_ADDRESS;
if (what == Trf.Attrib.IM_ADDRESSES)
{
builder.predicate (related_prop_2);
- unowned GLib.List<string> im_params =
- fd.get_parameter_values ("proto");
- builder.object_string (im_params.nth_data (0));
+ var im_params = fd.get_parameter_values ("proto").to_array ();
+ builder.object_string (im_params[0]);
}
}
yield this._tracker_update (builder.result, "set_attrib");
}
+ /* NOTE:
+ * - first we nuke old attribs
+ * - we create new affls with the new attribs
+ */
+ private async void _set_attrib_set (Folks.Persona persona,
+ Set<Object> attribs, Trf.Attrib what)
+ {
+ var p_id = ((Trf.Persona) persona).tracker_id ();
+
+ unowned string? related_attrib = null;
+ unowned string? related_prop = null;
+ unowned string? related_prop_2 = null;
+ unowned string? related_connection = null;
+
+ switch (what)
+ {
+ case Trf.Attrib.IM_ADDRESSES:
+ related_attrib = Trf.OntologyDefs.NCO_IMADDRESS;
+ related_prop = Trf.OntologyDefs.NCO_IMID;
+ related_prop_2 = Trf.OntologyDefs.NCO_IMPROTOCOL;
+ related_connection = Trf.OntologyDefs.NCO_HAS_IMADDRESS;
+ yield this._remove_attributes_from_persona (persona,
+ _REMOVE_IM_ADDRS);
+ break;
+ case Trf.Attrib.POSTAL_ADDRESSES:
+ case Trf.Attrib.URLS:
+ assert_not_reached ();
+ }
+
+ var builder = new Tracker.Sparql.Builder.update ();
+ builder.insert_open (null);
+ int i = 0;
+ foreach (var p in attribs)
+ {
+ FieldDetails fd = null;
+ PostalAddress pa = null;
+
+ string affl = "_:a%d".printf (i);
+ string attr;
+
+ switch (what)
+ {
+ case Trf.Attrib.POSTAL_ADDRESSES:
+ case Trf.Attrib.URLS:
+ assert_not_reached ();
+ case Trf.Attrib.IM_ADDRESSES:
+ default:
+ fd = (FieldDetails) p;
+ attr = "_:p%d".printf (i);
+ builder.subject (attr);
+ builder.predicate ("a");
+ builder.object (related_attrib);
+ builder.predicate (related_prop);
+ builder.object_string (fd.value);
+
+ if (what == Trf.Attrib.IM_ADDRESSES)
+ {
+ builder.predicate (related_prop_2);
+ var im_params =
+ fd.get_parameter_values ("proto").to_array ();
+ builder.object_string (im_params[0]);
+ }
+
+ break;
+ }
+
+ builder.subject (affl);
+ builder.predicate ("a");
+ builder.object (Trf.OntologyDefs.NCO_AFFILIATION);
+ builder.predicate (related_connection);
+ builder.object (attr);
+ builder.subject ("?contact");
+ builder.predicate (Trf.OntologyDefs.NCO_HAS_AFFILIATION);
+ builder.object (affl);
+
+ i++;
+ }
+ builder.insert_close ();
+ builder.where_open ();
+ builder.subject ("?contact");
+ builder.predicate ("a");
+ builder.object (Trf.OntologyDefs.NCO_PERSON);
+ string filter = " FILTER(tracker:id(?contact) = %s) ".printf (p_id);
+ builder.append (filter);
+ builder.where_close ();
+
+ yield this._tracker_update (builder.result, "set_attrib");
+ }
+
private async bool _tracker_update (string query, string caller)
{
bool ret = false;
private HashTable<string, HashTable<string, string>> _tracker_ids_ims =
new HashTable<string, HashTable<string, string>> (str_hash, str_equal);
- private HashTable<string, LinkedHashSet<string>> _im_addresses =
- new HashTable<string, LinkedHashSet<string>> (str_hash, str_equal);
+ private HashMultiMap<string, string> _im_addresses =
+ new HashMultiMap<string, string> ();
+
/**
* {@inheritDoc}
*/
- public HashTable<string, LinkedHashSet<string>> im_addresses
+ public MultiMap<string, string> im_addresses
{
get { return this._im_addresses; }
public set
{
if (prop_name == "im-addresses")
{
- this.im_addresses.foreach ((k, v) =>
+ foreach (var protocol in this._im_addresses.get_keys ())
{
- unowned string protocol = (string) k;
- unowned LinkedHashSet<string> im_addresses =
- (LinkedHashSet<string>) v;
+ var im_addresses = this._im_addresses.get (protocol);
foreach (string address in im_addresses)
callback (protocol + ":" + address);
- });
+ }
}
else if (prop_name == "local-ids")
{
return;
}
- this._im_addresses.remove_all ();
+ this._im_addresses.clear ();
string[] addresses_a = addresses.split ("\n");
internal bool _add_im_address (string tracker_id, string im_proto,
string account_id, bool notify = true)
{
- LinkedHashSet<string> im_address_array;
-
try
{
var account_id_copy = account_id.dup ();
var normalised_addr = (owned) normalise_im_address
((owned) account_id_copy, im_proto);
- im_address_array = this._im_addresses.lookup (im_proto);
- if (im_address_array == null)
- {
- im_address_array = new LinkedHashSet<string> ();
- im_address_array.add ((owned) normalised_addr);
- var proto_copy = im_proto.dup ();
- this._im_addresses.insert ((owned) proto_copy,
- (owned) im_address_array);
- }
- else
- {
- im_address_array.add (normalised_addr);
- }
+ this._im_addresses.set (im_proto, normalised_addr);
var im_proto_hash = new HashTable<string, string> (str_hash,
str_equal);
var proto = proto_im.get_keys ().nth_data (0);
var im_addr = proto_im.lookup (proto);
- var im_list = this._im_addresses.lookup (proto);
- if (im_list != null)
+ if (this._im_addresses.remove (proto, im_addr))
{
- foreach (var addr_iter in im_list)
+ this._tracker_ids_ims.remove (tracker_id);
+ if (notify)
{
- if (addr_iter == im_addr)
- {
- im_list.remove (im_addr);
- this._tracker_ids_ims.remove (tracker_id);
- if (notify)
- {
- this.notify_property ("im-addresses");
- }
- return true;
- }
+ this.notify_property ("im-addresses");
}
+
+ return true;
}
return false;
*/
using GLib;
+using Gee;
/**
* Errors related to IM addresses and IM address handling.
public interface Folks.ImDetails : Object
{
/**
- * A mapping of IM protocol to an ordered set of IM addresses.
+ * A mapping of IM protocol to an (unordered) set of IM addresses.
*
* Each mapping is from an arbitrary protocol identifier to a set of IM
- * addresses on that protocol for the contact, listed in preference order.
- * The most-preferred IM address for each protocol comes first in that
- * protocol's list.
+ * addresses on that protocol for the contact, listed in no particular order.
*
- * There must be no duplicate IM addresses in each ordered set, though a given
+ * There must be no duplicate IM addresses in each set, though a given
* IM address may be present in the sets for different protocols.
*
* All the IM addresses must be normalised using
* {@link ImDetails.normalise_im_address} before being added to this property.
*
- * @since 0.3.4
+ * @since UNRELEASED
*/
- public abstract HashTable<string, LinkedHashSet<string>> im_addresses
+ public abstract MultiMap<string, string> im_addresses
{
get; set;
}
this._configured_writeable_store_type_id);
/* `protocols_addrs_set` will be passed to the new Kf.Persona */
- var protocols_addrs_set =
- new HashTable<string, LinkedHashSet<string>> (str_hash, str_equal);
+ var protocols_addrs_set = new HashMultiMap<string, string> ();
var web_service_addrs_set =
new HashMap<string, LinkedHashSet<string>> (str_hash, str_equal);
{
if (persona is ImDetails)
{
- ((ImDetails) persona).im_addresses.foreach ((k, v) =>
+ ImDetails im_details = (ImDetails) persona;
+
+ /* protocols_addrs_set = union (all personas' IM addresses) */
+ foreach (var protocol in im_details.im_addresses.get_keys ())
{
- unowned string protocol = (string) k;
- unowned LinkedHashSet<string> addresses =
- (LinkedHashSet<string>) v;
+ var im_addresses = im_details.im_addresses.get (protocol);
- var address_set = protocols_addrs_set.lookup (protocol);
- if (address_set == null)
+ foreach (var im_address in im_addresses)
{
- address_set = new LinkedHashSet<string> ();
- protocols_addrs_set.insert (protocol, address_set);
+ protocols_addrs_set.set (protocol, im_address);
}
-
- address_set.add_all (addresses);
- });
+ }
}
if (persona is WebServiceDetails)
var details = new HashTable<string, Value?> (str_hash, str_equal);
- if (protocols_addrs_set.size () > 0)
+ if (protocols_addrs_set.size > 0)
{
- var im_addresses_value = Value (typeof (HashTable));
- im_addresses_value.set_boxed (protocols_addrs_set);
+ var im_addresses_value = Value (typeof (MultiMap));
+ im_addresses_value.set_object (protocols_addrs_set);
details.insert (PersonaStore.detail_key (PersonaDetail.IM_ADDRESSES),
im_addresses_value);
}
/* The number of Personas in this Individual which have
* Persona.is_user == true. Iff this is > 0, Individual.is_user == true. */
private uint _persona_user_count = 0;
- private HashTable<string, LinkedHashSet<string>> _im_addresses;
+ private HashMultiMap<string, string> _im_addresses;
private HashMap<string, LinkedHashSet<string>> _web_service_addresses;
/**
/**
* {@inheritDoc}
*/
- public HashTable<string, LinkedHashSet<string>> im_addresses
+ public MultiMap<string, string> im_addresses
{
get { return this._im_addresses; }
private set {}
*/
public Individual (GLib.List<Persona>? personas)
{
- this._im_addresses =
- new HashTable<string, LinkedHashSet<string>> (str_hash, str_equal);
+ this._im_addresses = new HashMultiMap<string, string> ();
this._web_service_addresses =
new HashMap<string, LinkedHashSet<string>> (str_hash, str_equal);
this._persona_set = new HashSet<Persona> (null, null);
private void _update_im_addresses ()
{
/* populate the IM addresses as the union of our Personas' addresses */
+ this._im_addresses.clear ();
+
foreach (var persona in this.personas)
{
if (persona is ImDetails)
{
var im_details = (ImDetails) persona;
- im_details.im_addresses.foreach ((k, v) =>
+ foreach (var cur_protocol in im_details.im_addresses.get_keys ())
{
- var cur_protocol = (string) k;
- var cur_addresses = (LinkedHashSet<string>) v;
- var im_set = this._im_addresses.lookup (cur_protocol);
+ var cur_addresses =
+ im_details.im_addresses.get (cur_protocol);
- if (im_set == null)
+ foreach (var address in cur_addresses)
{
- im_set = new LinkedHashSet<string> ();
- this._im_addresses.insert (cur_protocol, im_set);
+ this._im_addresses.set (cur_protocol, address);
}
-
- im_set.add_all (cur_addresses);
- });
+ }
}
}
this.notify_property ("im-addresses");
{
foreach (var proto in this._individual_a.im_addresses.get_keys ())
{
- var addrs_b = this._individual_b.im_addresses.lookup (proto);
- if (addrs_b == null)
- continue;
-
- var addrs_a = this._individual_a.im_addresses.lookup (proto);
+ var addrs_a = this._individual_a.im_addresses.get (proto);
+ var addrs_b = this._individual_b.im_addresses.get (proto);
foreach (var im_a in addrs_a)
{
- foreach (var im_b in addrs_b)
+ if (addrs_b.contains (im_a))
{
- if (im_a == im_b)
- {
- this._result = MatchResult.HIGH;
- return;
- }
+ this._result = MatchResult.HIGH;
+ return;
}
}
}
Folks.PersonaStore.detail_key (PersonaDetail.EMAIL_ADDRESSES),
(owned) v8);
- Value? v9 = Value (typeof (HashTable<string, LinkedHashSet<string>>));
- HashTable<string, LinkedHashSet<string>> im_addrs =
- new HashTable<string, LinkedHashSet<string>> (null, null);
- LinkedHashSet<string> proto1 = new LinkedHashSet<string> ();
- proto1.add (this._im_addr_1);
- im_addrs.insert ("jabber", proto1);
- LinkedHashSet<string> proto2 = new LinkedHashSet<string> ();
- proto2.add (this._im_addr_2);
- im_addrs.insert ("yahoo", proto2);
- v9.set_boxed (im_addrs);
+ Value? v9 = Value (typeof (MultiMap<string, string>));
+ var im_addrs = new HashMultiMap<string, string> ();
+ im_addrs.set ("jabber", this._im_addr_1);
+ im_addrs.set ("yahoo", this._im_addr_2);
+ v9.set_object (im_addrs);
details.insert (
Folks.PersonaStore.detail_key (PersonaDetail.IM_ADDRESSES), v9);
foreach (var proto in i.im_addresses.get_keys ())
{
- var addrs = i.im_addresses.lookup (proto);
+ var addrs = i.im_addresses.get (proto);
foreach (var a in addrs)
{
if (a == this._im_addr_1)
{
foreach (var proto in i.im_addresses.get_keys ())
{
- var addrs = i.im_addresses.lookup (proto);
+ var addrs = i.im_addresses.get (proto);
if (proto == "jabber")
{
{
this._individual_id = i.id;
- foreach (unowned string proto in i.im_addresses.get_keys ())
+ foreach (var proto in i.im_addresses.get_keys ())
{
- var addrs = i.im_addresses.lookup (proto);
- var im_address_iter = addrs.get (0);
- if (im_address_iter == this._imaddress_1)
+ var addrs = i.im_addresses.get (proto);
+ if (addrs.size == 1 && addrs.contains (this._imaddress_1))
{
i.notify["im-addresses"].connect (this._notify_im_cb);
this._initial_imaddress_found = true;
private void _notify_im_cb (Object individual_obj, ParamSpec ps)
{
Folks.Individual i = (Folks.Individual) individual_obj;
- foreach (unowned string proto in i.im_addresses.get_keys ())
+ foreach (var proto in i.im_addresses.get_keys ())
{
- var addrs = i.im_addresses.lookup (proto);
- var im_address_iter = addrs.get (0);
- if (im_address_iter == this._imaddress_2)
+ var addrs = i.im_addresses.get (proto);
+ if (addrs.size == 1 && addrs.contains (this._imaddress_2))
{
this._updated_imaddr_found = true;
this._main_loop.quit ();
{
HashTable<string, Value?> details1 = new HashTable<string, Value?>
(str_hash, str_equal);
- Value? v1 = Value (typeof (HashTable<string, LinkedHashSet<string>>));
- HashTable<string, LinkedHashSet<string>> im_addrs1 =
- new HashTable<string, LinkedHashSet<string>> (null, null);
- LinkedHashSet<string> addrs1 = new LinkedHashSet<string> ();
- addrs1.add (this._im_address_1);
- im_addrs1.insert (this._proto, addrs1);
- v1.set_boxed (im_addrs1);
+ Value? v1 = Value (typeof (MultiMap<string, string>));
+ var im_addrs1 = new HashMultiMap<string, string> ();
+ im_addrs1.set (this._proto, this._im_address_1);
+ v1.set_object (im_addrs1);
details1.insert ("im-addresses", (owned) v1);
Value? v2 = Value (typeof (string));
HashTable<string, Value?> details2 = new HashTable<string, Value?>
(str_hash, str_equal);
- Value? v3 = Value (typeof (HashTable<string, LinkedHashSet<string>>));
- HashTable<string, LinkedHashSet<string>> im_addrs2 =
- new HashTable<string, LinkedHashSet<string>> (null, null);
- LinkedHashSet<string> addrs2 = new LinkedHashSet<string> ();
- addrs2.add (this._im_address_2);
- im_addrs2.insert (this._proto, addrs2);
- v3.set_boxed (im_addrs2);
+ Value? v3 = Value (typeof (MultiMap<string, string>));
+ var im_addrs2 = new HashMultiMap<string, string> ();
+ im_addrs2.set (this._proto, this._im_address_2);
+ v3.set_object (im_addrs2);
details2.insert ("im-addresses", (owned) v3);
Value? v4 = Value (typeof (string));
/* Lets check if it contains all the linking properties */
foreach (var proto in i.im_addresses.get_keys ())
{
- var addrs = i.im_addresses.lookup (proto);
+ var addrs = i.im_addresses.get (proto);
foreach (var a in addrs)
{
if (a == this._linking_props.get ("prop1"))
HashTable<string, Value?> details2 = new HashTable<string, Value?>
(str_hash, str_equal);
Value? val;
- HashTable<string, LinkedHashSet<string>> im_addrs;
- LinkedHashSet<string> proto;
+ HashMultiMap<string, string> im_addrs;
val = Value (typeof (string));
val.set_string (this._persona_fullname_1);
details1.insert (Folks.PersonaStore.detail_key (PersonaDetail.FULL_NAME),
(owned) val);
- val = Value (typeof (HashTable<string, LinkedHashSet<string>>));
- im_addrs = new HashTable<string, LinkedHashSet<string>> (null, null);
- proto = new LinkedHashSet<string> ();
- proto.add (this._im_addr_1);
- im_addrs.insert ("jabber", (owned) proto);
- proto = new LinkedHashSet<string> ();
- proto.add (this._im_addr_2);
- im_addrs.insert ("yahoo", (owned) proto);
- val.set_boxed ((owned) im_addrs);
+ val = Value (typeof (MultiMap<string, string>));
+ im_addrs = new HashMultiMap<string, string> ();
+ im_addrs.set ("jabber", this._im_addr_1);
+ im_addrs.set ("yahoo", this._im_addr_2);
+ val.set_object (im_addrs);
details1.insert (
Folks.PersonaStore.detail_key (PersonaDetail.IM_ADDRESSES),
(owned) val);
details2.insert (Folks.PersonaStore.detail_key (PersonaDetail.FULL_NAME),
(owned) val);
- val = Value (typeof (HashTable<string, LinkedHashSet<string>>));
- im_addrs = new HashTable<string, LinkedHashSet<string>> (null, null);
- proto = new LinkedHashSet<string> ();
- proto.add (this._im_addr_1);
- im_addrs.insert ("jabber", (owned) proto);
- val.set_boxed ((owned) im_addrs);
+ val = Value (typeof (MultiMap<string, string>));
+ im_addrs = new HashMultiMap<string, string> ();
+ im_addrs.set ("jabber", this._im_addr_1);
+ val.set_object (im_addrs);
details2.insert (
Folks.PersonaStore.detail_key (PersonaDetail.IM_ADDRESSES),
(owned) val);
{
i.notify["im-addresses"].connect (this._notify_im_addresses_cb);
- HashTable<string, LinkedHashSet<string>> im_addresses =
- new HashTable<string, LinkedHashSet<string>>
- (str_hash, str_equal);
-
- var addrs_1 = new LinkedHashSet<string> ();
- addrs_1.add ("one@example.org");
- addrs_1.add ("two@example.org");
- im_addresses.insert ("aim",
- (owned) addrs_1);
-
- var addrs_2 = new LinkedHashSet<string> ();
- addrs_2.add ("three@example.org");
- addrs_2.add ("four@example.org");
- im_addresses.insert ("yahoo",
- (owned) addrs_2);
+ var im_addresses = new HashMultiMap<string, string> ();
+
+ im_addresses.set ("aim", "one@example.org");
+ im_addresses.set ("aim", "two@example.org");
+
+ im_addresses.set ("yahoo", "three@example.org");
+ im_addresses.set ("yahoo", "four@example.org");
Trf.Persona p = (Trf.Persona)i.personas.nth_data (0);
p.im_addresses = (owned) im_addresses;
{
foreach (var proto in i.im_addresses.get_keys ())
{
- var addrs = i.im_addresses.lookup (proto);
+ var addrs = i.im_addresses.get (proto);
foreach (var a in addrs)
{
foreach (unowned string my_a in this._addresses)
private async Persona? parse_contact (Xml.Node *contact_node)
{
string alias = null;
- HashTable<string, LinkedHashSet<string>> im_addresses =
- new HashTable<string, LinkedHashSet<string>> (str_hash, str_equal);
+ var im_addresses = new HashMultiMap<string, string> ();
string im_address_string = "";
/* Parse the <buddy> elements beneath <contact> */
* we need to insert into the Persona's im-addresses property
* for the linking to work. */
string im_address = subiter->get_content ();
-
- LinkedHashSet<string> im_address_set =
- im_addresses.lookup (tp_protocol);
- if (im_address_set == null)
- {
- im_address_set = new LinkedHashSet<string> ();
- im_addresses.insert (tp_protocol, im_address_set);
- }
-
- im_address_set.add (im_address);
+ im_addresses.set (tp_protocol, im_address);
im_address_string += " %s\n".printf (im_address);
}
}
}
/* Don't bother if there's no alias and only one IM address */
- if (im_addresses.size () < 2 &&
+ if (im_addresses.size < 2 &&
(alias == null || alias.strip () == "" ||
alias.strip () == im_address_string.strip ()))
{
/* Create or update the relevant Persona */
HashTable<string, Value?> details =
new HashTable<string, Value?> (str_hash, str_equal);
- Value im_addresses_value = Value (typeof (HashTable));
- im_addresses_value.set_boxed (im_addresses);
+ Value im_addresses_value = Value (typeof (MultiMap));
+ im_addresses_value.set_object (im_addresses);
details.insert ("im-addresses", im_addresses_value);
Persona persona;
}
else if (prop_name == "im-addresses")
{
- HashTable<string, LinkedHashSet<string>> im_addresses =
- (HashTable<string, LinkedHashSet<string>>)
- prop_value.get_boxed ();
+ MultiMap<string, string> im_addresses =
+ (MultiMap<string, string>) prop_value.get_object ();
output_string = "{ ";
bool first = true;
- /* FIXME: This is rather inefficient */
- im_addresses.foreach ((k, v) =>
+ foreach (var protocol in im_addresses.get_keys ())
{
if (first == false)
output_string += ", ";
- output_string += "'%s' : { ".printf ((string) k);
+ output_string += "'%s' : { ".printf (protocol);
first = false;
- LinkedHashSet<string> addresses = (LinkedHashSet<string>) v;
+ var addresses = im_addresses.get (protocol);
bool _first = true;
foreach (var a in addresses)
{
}
output_string += " }";
- });
+ }
output_string += " }";
return output_string;